ivcn

set nocompatible "be Improved                                                                                                                                                      
filetype off 
"syntax on       " enable syntax processing
set background=light
colorscheme gruvbox

""""""" tab settings
set tabstop=4       " number of visual spaces per TAB
set softtabstop=4   " number of spaces in tab when editing
set expandtab       " tabs are spaces

ivcn

DIR=/path/to/folder/

./bootstrap.sh --prefix=${DIR} --includedir=headers --libdir=dist --with-libraries=date_time
./b2 --prefix=${DIR} install

ivcn

#include <chrono>
#include <iostream>
#include <random>
#include <vector>

using std::cout;
using std::endl;
using std::vector;

class TestRandom {

ivcn

To print some network packets:

tshark [options] -r input.pcap.gz "Wireshark display filter" [-w output.pcap]

Useful options:

• -r - file to read
• -w - file to write
• -2 - two-pass analysis
• -P - print packet summary
• -V - print packet details (fields of dissected protocols)

ivcn

#include <iostream>
#include <deque>
#include <functional>
#include <thread>
#include <condition_variable>
#include <mutex>
#include <random>

//thread pool
class ThreadPool

ivcn

#ifndef _RESOURCE_H_
#define _RESOURCE_H_

#include <thread>

class Resource {
public:
    static Resource *make(int partNumber) {
        int timeToSleep = partNumber;
        //sleep(timeToSleep);

ivcn

template<typename ElementType>
class Queue {
public:
    Queue(size_t size)  :
        buffer(size),
        front(0),
        end(0) {}

    void push(ElementType newElement) {
        std::unique_lock<std::mutex> lk(m);

ivcn

void mainImage( out vec4 fragColor, in vec2 fragCoord )
{
    vec2 center = iResolution.xy / 2.0;
    float r1 = iResolution.y / 5.0;
    float r2 = iResolution.y / 3.0;
    
	vec2 uv = fragCoord.xy / iResolution.xy;
    float dist = distance(fragCoord.xy, center);
    if( dist >= r1 && dist <= r2) {
        float d = (dist-r1)/(r2-r1);

ivcn

int main() {
    std::mutex m1;
    std::mutex m2;
    std::thread t1([&m1, &m2] {
        print("1. Acquiring m1.");
        m1.lock();
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
        print("1. Acquiring m2");
        m2.lock(); 
    });

ivcn

class thread_handle {
private:
    std::thread t;
    int id;

public:
    template<typename F, typename... Args>
    thread_handle(int _id, F&& f, Args&&... args) :
        id(_id),
        t(std::move(std::thread(f, args...))) {