#include <algorithm> // to use std::remove_if
#include <iostream>  // to use std::cout
#include <vector>
// A helper class used for vector
class Point {
public:
  // constructors
  Point() : x_(0), y_(0) {}
  Point(int x, int y) : x_(x), y_(y) {}
  // inline asks the compiler to substitute the function
  // directly at the calling location instead of performing
  // a normal function call, to improve performance for small functions
  inline int GetX() const { return x_; }
  inline void SetX(int x) { x_ = x; }

  void PrintPoint() const {
    std::cout << "Point: (" << x_ << ", " << "y_" << ")\n";
  }

private:
  int x_;
  int y_;
};

int main() {
  std::vector<Point> point_vector;
  // approach 1 to append to a vector
  point_vector.push_back(Point(35, 36));
  // approach 2, pass the argument to Point(x,y) constructor
  // slightly faster than push_back
  point_vector.emplace_back(37, 38);
  // iterate through index
  // size_t: unsigned integers specifially used in loop or counting
  for (size_t i = 0; i < point_vector.size(); ++i) {
    point_vector[i].PrintPoint();
  }
  // iterate through mutable reference
  for (Point &item : point_vector) {
    item.SetX(10);
  }
  // iterate through immutable reference
  for (const Point &item : point_vector) {
    item.GetX();
  }

  // initialize the vector with an initializer list
  std::vector<int> int_vector = {0, 1, 2, 3};
  // erase element given its index
  // int_vector.begin() returns a std::vector<int>::iterator
  // pointing to the first elemnt in the vector
  // the vector iterator has a plus iterator
  int_vector.erase(int_vector.begin() + 2); // {0, 1, 3}
  // erase a range of elements
  // int_vector.end() points to the end of a vector (not the last element)
  // and cannot be accessed.
  int_vector.erase(int_vector.begin() + 1, int_vector.end()); // {0}
  // erase elements via filtering
  // std::remove_if(range_begin, range_end, condition) returns an iterator
  // pointing to the first element to be erased
  // remove_if() also partitions point_vector so that unsatisfied elements are
  // moved before the point_vector.begin(), i.e., the vector is reordered
  point_vector.erase(
      std::remove_if(point_vector.begin(), point_vector.end(),
                     [](const Point &point) { return point.GetX() == 10; }),
      point_vector.end());

  return 0;
}

#include <iostream>
#include <set>

int main() {
  std::set<int> int_set;
  // can insert element with .insert() or .emplace()
  // .emplace() allows to construct the object in place
  for (int i = 1; i <= 5; ++i) {
    int_set.insert(i);
  }
  for (int i = 6; i <= 10; ++i) {
    int_set.emplace(i);
  }
  // iterate the set
  for (std::set<int>::iterator it = int_set.begin(); it != int_set.end();
       ++it) {
    std::cout << *it << " ";
  }
  std::cout << "\n";
  // .find(key) returns an iterator pointing to the key
  // if it is in the set, otherwise returns .end()
  std::set<int>::iterator search = int_set.find(2);
  if (search != int_set.end()) {
    std::cout << "2 is not found\n";
  }
  // check whether the set contains a key with .count()
  // it returns either 0 or 1 as each key is unique
  if (int_set.count(11) == 0) {
    std::cout << "11 is not in the set.\n";
  }
  // erase a key, returns the count of removed elements 0 or 1
  int_set.erase(4);
  // erase a key given its position, returns the iterator to the next element
  int_set.erase(int_set.begin());
  // erase a range of elements
  int_set.erase(int_set.find(9), int_set.end());
}

#include <iostream>
#include <string>
#include <unordered_map>
#include <utility> // to use std::make_pair

int main() {
  std::unordered_map<std::string, int> map;
  // insert items
  map.insert({"foo", 2});
  map.insert({{"bar", 1}, {"eggs", 2}});
  // insert items via pairs
  map.insert(std::make_pair("hello", 10));
  // insert items in an array-style
  map["world"] = 3;
  // update the value
  map["foo"] = 9;
  // .find() returns an iterator pointing to the item
  // or the end
  std::unordered_map<std::string, int>::iterator result = map.find("bar");
  if (result != map.end()) {
    // one way to access the item
    // both '\n' and std::endl prints newliine, but std::endl
    // also flushes the output buffer, so use '\n' is better
    std::cout << "key: " << result->first << " value: " << result->second
              << std::endl;
    // another way is dereferencing
    std::pair<std::string, int> pair = *result;
    std::cout << "key: " << pair.first << " value: " << pair.second
              << std::endl;
    // check whether a key exists with .count()
    if (map.count("foo") == 0) {
      std::cout << "foo does not exist\n";
    }
    // erase an item via a key
    map.erase("world");
    // or via an iterator
    map.erase(map.find("bar"));
    // can iterate the map via iterator or via for-each
    for (std::unordered_map<std::string, int>::iterator it = map.begin();
         it != map.end(); ++it) {
      std::cout << "(" << it->first << ", " << it->second << "), ";
    }
    std::cout << "\n";
  }
}

#include <iostream>
#include <memory>  // to use std::unique_ptr
#include <utility> // to use std::move

// class Point is the same as before

// takes in a unique point reference and changes its x value
void SetXTo10(std::unique_ptr<Point> &ptr) { ptr->SetX(10); }
int main() {
  // initialize an empty unique pointer
  std::unique_ptr<Point> u1;
  // initialize a unique pointer with constructors
  std::unique_ptr<Point> u2 = std::make_unique<Point>();
  std::unique_ptr<Point> u3 = std::make_unique<Point>(2, 3);
  // can treat a unique pointer as a boolean to determine whether
  // the pointer contains data
  std::cout << "Pointer u1 is " << (u1 ? "not empty" : "empty") << std::endl;
  if (u2) {
    std::cout << u2->GetX() << std::endl;
  }
  // unique_ptr has no copy constructor!
  std::unique_ptr<Point> u4 = u3; // won't compile!
  // can transfer ownership with std::move
  std::unique_ptr<Point> u5 = std::move(u3); // then u3 becomes empty!
  // pass the pointer as a reference so the ownership does not change
  SetXTo10(u5); // can still access u5 afterwards
  return 0;
}

// the following code can compile
// but it causes a double deletion!
MyClass *obj = new MyClass();
std::unique_ptr<MyClass> ptr1(obj);
std::unique_ptr<MyClass> ptr2(obj);

#include <iostream>
#include <memory>
#include <utility>

// class Point is the same as before

// modify a Point inside a shared_ptr by passing the reference
void modify_ptr_via_ref(std::shared_ptr<Point> &point) { point->SetX(10); }
// modify a Point inside a shared_ptr by passing the rvalue reference
// If an object is passed by rvalue reference, one should assume the ownership
// is moved after the function call, so the original object cannot be used
void modify_ptr_via_rvalue_ref(std::shared_ptr<Point> &&point) {
  point->SetY(11);
}
// copy a shared_pointer with the default constructor
// so one should define own copy constructor and assignment when an object
// contains pointers
void copy_shard_ptr_in_function(std::shared_ptr<Point> point) {
  std::cout << "Use count of the shared pointer: " << point.use_count()
            << std::endl; // add by 1
  // the copy is destroyed at the end, so the count is decremented
}

int main() {
  // the pointer constructors are the same as unique_ptr
  std::shared_ptr<Point> s1;
  std::shared_ptr<Point> s2 = std::make_shared<Point>();
  std::shared_ptr<Point> s3 = std::make_shared<Point>(2, 3);
  // copy a shared pointer via copy assignment or copy constructor
  // increment the reference count, which can be tracked by .use_count
  std::cout << "Use count of s3" << s3.use_count() << std::endl; // 1
  std::shared_ptr<Point> s4 = s3; // copy assignment
  std::cout << "Use count of s3" << s3.use_count() << std::endl; // 2
  std::shared_ptr<Point> s5(s4);
  std::cout << "Use count of s3" << s3.use_count() << std::endl; // 3
  s3->SetX(100); // also changes the data in s4 and s5
  std::shared_ptr<Point> s6 = std::move(s5); // s5 transfer the ownership to s6
  std::cout << "Use count of s3" << s3.use_count()
            << std::endl; // still 3: s3, s4, s6
  // as unique_ptr, shared_ptr can be passed by references and rvalue references
  modify_ptr_via_ref(s2);                   // setX(11)
  modify_ptr_via_rvalue_ref(std::move(s2)); // setY(12)
  std::cout << "s2.x = " << s2->GetX()
            << " , s2.y = " << s2->GetY(); // (11, 12)
  // shared_ptr can also be passed by value/copy
  std::cout << "Use count of s2" << s2.use_count() << std::endl; // 1
  copy_shared_ptr_in_function(s2); // inside the function, the use count is 2
  std::cout << "Use count of s2" << s2.use_count()
            << std::endl; // 1 again as the copy is detroyed
  return 0;
}

#include <iostream>
#include <mutex>
#include <thread>

// define a global variable to be modified
// by multiple threads
int count = 0;
// declare a mutex
std::mutex m;
void add_count() {
  m.lock(); // acquire the lock
  count += 1;
  m.unlock(); // release the lock
}
int main() {
  std::thread t1(add_count);
  std::thread t2(add_count);
  t1.join();
  t2.join();
  std::cout << count << std::endl; // always 2
  return 0;
}

#include <iostream>
#include <mutex>

int count = 0;
std::mutex m;
void add_count() {
  // the scoped_lock constructor allows for the thread
  // to acquire the mutex m
  std::scoped_lock slk(m);
  count += 1;
  // once the function finishes, slk is destructurd and
  // m is released
}

#include <condition_variable>
#include <iostream>
#include <mutex>
#include <thread>

int count = 0;
std::mutex m;
// declare a condition variable
std::condition_variable cv;
void add_count_and_notify() {
  std::scoped_lock slk(m);
  count += 1;
  if (count == 2) {
    // notidy one waiting thread
    // otherwise the waiter thread hangs forever
    cv.notify_one();
  }
}
void waiter_thread() {
  // a unique_lock is movable but not copiable
  // more flexible than scoped_lock as it can unlock
  // and relock manually, while scoped_lock can only be
  // unlocked automatically.
  // scoped_lock cannot be used with condition variables
  std::unique_lock lk(m);
  cv.wait(lk, [] { return count == 2; });
  std::cout << count << std::endl;
}
int main() {
  std::thread t1(waiter_thread);
  // make t1 really waits
  std::this_thread::sleep_for(std::chrono::milliseconds(100));
  std::thread t2(add_count_and_notify);
  std::thread t3(add_count_and_notify);
  t1.join();
  t2.join();
  t3.join();
  return 0;
}

1: const [persons, setPersons] = useState([]);
2: 
3: testingStuff = () => {
4:     /* assume persons is empty before */
5:     setPersons([...persons, "me"]);
6: }
7: console.log(persons);

1: useEffect(() => {
2:     console.log(persons);
3: }, [persons]);

1: useEffect(() => {
2: /* do something, e.g., interact with an external service */
3: 
4: return () => {
5: /* cleanup function on dismount, e.g., disconnect from external service */
6: }
7: }, [/*dependencies */])

1: /* fetch data on mount */
2: useEffect(() => {
3:     get("/api/packages").then((packageList) => {
4:         setPackages(packageList);
5:     });
6: }, []);

1: /* send data then toggle admin state */
2: const handleToggleAdmin = () => {
3:     // .then(), do something once the promise is fulfilled
4:     post("/api/user/admin", { admin: !admin }).then(() => {
5:         setAdmin(!admin);
6:     });
7: };
8: /* <Button onClick={handleToggleAdmin} */

1: // JSX is a way of writing HTML in js
2: let content = loading ? <p>Loading...</p> : <p>Loaded</p>;
3: return (
4:     <div>
5:         <h1>Title</h1>
6:         {content}
7:     </div>
8: );

1: const data = [
2:     { id: 0, text: "Text 1" },
3:     { id: 1, text: "Text 2" },
4: ];
5: // render a component for each data item
6: return data.map((item) => (
7:     <ItemComponent key={item.id}>{item.text}</ItemComponent>
8: ));