ChunMinChang

# Build C++ client example
# Process with GNU make

all: test

check: all
	./test

HEADER := lru_table.h
CXXFLAGS = -g -Wall -std=c++17 -DLRU_TABLE_DEBUG=1

ChunMinChang

#include <assert.h>
#include <iostream>
#include <string>
#include <unordered_map>

class Player {
 public:
  static void DoAction(std::string action) {
    std::string message;

ChunMinChang

#[derive(Clone, Debug, PartialEq)]
enum Channel {
    FrontLeft = 0,
    FrontRight = 1,
    FrontCenter = 2,
    LowFrequency = 3,
    BackLeft = 4,
    BackRight = 5,
    FrontLeftOfCenter = 6,
    FrontRightOfCenter = 7,

ChunMinChang

#ifndef FINALLY_H
#define FINALLY_H

#include <utility>

template<class Lambda>
class Finally {
public:
  Finally(Lambda &&func): func_(std::forward<Lambda>(func)) {};
  ~Finally() { func_(); };

ChunMinChang

fn main() {
    println!("123 * 345 = {}", multiply(123, 345));
}

fn multiply(mut a: u32, mut b: u32) -> u32 {
    let mut sum = 0;
    while a != 0 {
        if a & 1 == 1 {
            sum = add(sum, b);
        }

ChunMinChang

all:
				# Build a static library
				gcc -c -o query.o query.c
				ar rcs libquery.a query.o
				# Build and run a C sample
				gcc sample.c libquery.a -o sample-c
				./sample-c
				# Build and run a C++ sample
				g++ sample.cpp libquery.a -o sample-cpp
				./sample-cpp

ChunMinChang

Lifetimes for The Rust References

Terms

• x outlives y
  • When y is alive, x is alive. But x and y can be destroyed at the same time. That is, x must live at least as long as y.
• x strictly outlives y
  • When y is alive, x is alive, and x must be alive when y is destroyed. That is, x lives longer than y.
• If starttime(z) and endtime(z) are the timestamps when z is created and destroyed, then
  • x outlives y: (starttime(x) <= starttime(y)) ∧ (endtime(x) >= endtime(y)).
• x strictly outlives y: (starttime(x) <= starttime(y)) ∧ (endtime(x) > endtime(y)).

ChunMinChang

all:
				rustc property_listener_native_apis.rs
				rustc property_listener_generic_type.rs
				rustc property_listener_within_context.rs
clean:
				rm property_listener_native_apis
				rm property_listener_generic_type
				rm property_listener_within_context

ChunMinChang

mod sys;

use std::ffi::CString;
use std::os::raw::c_void;
use std::{thread, time::Duration};

// A macro to print the function name
macro_rules! function {
    () => {{
        fn f() {}

ChunMinChang

all:
				# Build a static library from the Rust file
				rustc --crate-type=staticlib ext.rs
				# Compile the C file with the static library
				# gcc -o sample-c sample.c libext.a
				gcc -o sample sample.c -L. -lext
				./sample
clean:
				rm libext.a
				rm sample