cmake_minimum_required(VERSION 3.14)

project(cow LANGUAGES CXX)

set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Core)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Core)

add_executable(cow
    main.cpp
)
target_link_libraries(cow Qt${QT_VERSION_MAJOR}::Core)

#include <QtCore/QCoreApplication>
#include <QtCore/QDebug>
#include <QtCore/QScopedPointer>
#include <QtCore/QThread>
#include <QtCore/QTimer>

#define PRINT_FUNCTION_INFO qDebug() << Q_FUNC_INFO << this << QThread::currentThread();

struct Foo {
    Foo()                       { PRINT_FUNCTION_INFO }
    Foo(const Foo&)             { PRINT_FUNCTION_INFO }
    Foo(Foo&&)                  { PRINT_FUNCTION_INFO }
    Foo& operator=(const Foo&)  { PRINT_FUNCTION_INFO return *this; }
    Foo& operator=(Foo&&)       { PRINT_FUNCTION_INFO return *this; }
    ~Foo()                      { PRINT_FUNCTION_INFO }
};

class Bar : public QObject {
    Q_OBJECT

public:
    explicit Bar(QObject* parent = nullptr) : QObject(parent) {}
    void emitSignals() { emit dataByValueSignal(foos); }
    QVector<Foo> foos;

signals:
    void dataByValueSignal(QVector<Foo>);

public slots:
    void dataByValue(QVector<Foo> foo)
    {
        // It is ok to pass "big" QVector object by value because of COW (but const reference is still better).
        // Also can safely modify copy of 'COW class' transfered with signals and slots in another thread.
        // Using non-const methods will make deep copy of QVector content behind the scene.
        foo.append(Foo()); // <- comment out to see effect of COW
        qDebug() << Q_FUNC_INFO << foo.size();
    }
};

int main(int argc, char *argv[])
{
    // main thread
    const Bar bar;

    // this code will run in another thread
    auto producer = [&bar] {
        Bar anotherBar;
        anotherBar.foos.append(Foo());

        qRegisterMetaType<QVector<Foo>>("QVector<Foo>");
        // connect to object in another thread and pass object with COW by value
        // no copies of QVector *content* at this point and thread safe
        QObject::connect(&anotherBar, &Bar::dataByValueSignal, &bar, &Bar::dataByValue);
        anotherBar.emitSignals();

        // can safely modify local copy of Qt class
        QThread::sleep(1);
        anotherBar.foos.pop_front();
        qDebug() << QThread::currentThread() << anotherBar.foos.size();
    };

    const QScopedPointer<QThread> thread(QThread::create(producer));
    const QCoreApplication a(argc, argv);
    QObject::connect(thread.data(), &QThread::finished, qApp, &QCoreApplication::quit);
    QTimer::singleShot(0, qApp, [&thread]{thread->start();}); // start thread when event loop is running
    return qApp->exec();
}

#include "main.moc"

#include <QtCore/QCoreApplication>
#include <QtCore/QDebug>
#include <QtCore/QScopedPointer>
#include <QtCore/QThread>
#include <QtCore/QTimer>

#define PRINT_FUNCTION_INFO qDebug() << Q_FUNC_INFO << this << QThread::currentThread();

struct Foo {
    Foo()                       { PRINT_FUNCTION_INFO }
    Foo(const Foo&)             { PRINT_FUNCTION_INFO }
    Foo(Foo&&)                  { PRINT_FUNCTION_INFO }
    Foo& operator=(const Foo&)  { PRINT_FUNCTION_INFO return *this; }
    Foo& operator=(Foo&&)       { PRINT_FUNCTION_INFO return *this; }
    ~Foo()                      { PRINT_FUNCTION_INFO }
};

class Bar : public QObject {
    Q_OBJECT

public:
    explicit Bar(QObject* parent = nullptr) : QObject(parent) {}
    void emitSignals() { emit dataByValueSignal(foos); }
    QVector<Foo> foos;

signals:
    void dataByValueSignal(QVector<Foo>);

public slots:
    void dataByValue(QVector<Foo> foo)
    {
        // It is ok to pass "big" QVector object by value because of COW (but const reference is still better).
        // Also can safely modify copy of 'COW class' transfered with signals and slots in another thread.
        // Using non-const methods will make deep copy of QVector content behind the scene.
        foo.append(Foo()); // <- comment out to see effect of COW
        qDebug() << Q_FUNC_INFO << foo.size();
    }
};

class Producer : public QObject
{
    Q_OBJECT
    const Bar& bar;
public:
    Producer(const Bar& b): bar(b){}
public slots:
    void do_produce() {
        Bar anotherBar;
        anotherBar.foos.append(Foo());

        // connect to object in another thread and pass object with COW by value
        // no copies of QVector *content* at this point and thread safe
        QObject::connect(&anotherBar, &Bar::dataByValueSignal, &bar, &Bar::dataByValue);
        anotherBar.emitSignals();

        // can safely modify local copy of Qt class
        QThread::sleep(1);
        anotherBar.foos.pop_front();
        qDebug() << QThread::currentThread() << anotherBar.foos.size();
    }
};


int main(int argc, char *argv[])
{
    // main thread
    const Bar bar;

    qRegisterMetaType<QVector<Foo>>("QVector<Foo>");
    const QScopedPointer<QThread> thread(new QThread);

    Producer prod(bar);
    prod.moveToThread(thread.data());

    const QCoreApplication a(argc, argv);
    QObject::connect(thread.data(), &QThread::started, &prod, &Producer::do_produce);
    QObject::connect(thread.data(), &QThread::finished, qApp, &QCoreApplication::quit);
    QTimer::singleShot(0, qApp, [&thread]{thread->start();}); // start thread when event loop is running
    return qApp->exec();
}

//#include "main.moc"

#include <QtCore/QCoreApplication>
#include <QtCore/QDebug>
#include <QtCore/QScopedPointer>
#include <QtCore/QThread>
#include <QtCore/QTimer>

#define PRINT_FUNCTION_INFO qDebug() << Q_FUNC_INFO << this << QThread::currentThread();

struct Foo {
    Foo()                       { PRINT_FUNCTION_INFO }
    Foo(const Foo&)             { PRINT_FUNCTION_INFO }
    Foo(Foo&&)                  { PRINT_FUNCTION_INFO }
    Foo& operator=(const Foo&)  { PRINT_FUNCTION_INFO return *this; }
    Foo& operator=(Foo&&)       { PRINT_FUNCTION_INFO return *this; }
    ~Foo()                      { PRINT_FUNCTION_INFO }
};

class Bar : public QObject {
    Q_OBJECT

public:
    explicit Bar(QObject* parent = nullptr) : QObject(parent) {}
    void emitSignals() { emit dataByValueSignal(foos); }
    QVector<Foo> foos;

signals:
    void dataByValueSignal(const QVector<Foo>&) const;

public slots:
    void dataByValue(const QVector<Foo>& foo)
    {
        qDebug() << QThread::currentThread() << Q_FUNC_INFO << foo.size();
        // It is ok to pass "big" QVector object by value because of COW (but const reference is still better).
        // Also can safely modify copy of 'COW class' transfered with signals and slots in another thread.
        // Using non-const methods will make deep copy of QVector content behind the scene.
        //foo.append(Foo()); // <- comment out to see effect of COW
        foos = foo;
        qDebug() << QThread::currentThread() << "consumer data" << QString::number( uint64_t(foos.constData()), 16 );
    }
};

class Producer : public QObject
{
    Q_OBJECT
    const Bar& bar;
public:
    Producer(const Bar& b): bar(b){}
public slots:
    void do_produce() {
        Bar anotherBar;
        anotherBar.foos.append(Foo());

        // connect to object in another thread and pass object with COW by value
        // no copies of QVector *content* at this point and thread safe
        qDebug() << QThread::currentThread() << "producer data before signal" << QString::number( uint64_t(anotherBar.foos.constData()), 16 );
        QObject::connect(&anotherBar, &Bar::dataByValueSignal, &bar, &Bar::dataByValue);
        anotherBar.emitSignals();
        qDebug() << QThread::currentThread() << "producer data after signal" << QString::number( uint64_t(anotherBar.foos.constData()), 16 );
        // can safely modify local copy of Qt class
        QThread::sleep(1);
        anotherBar.foos.pop_front();
        qDebug() << QThread::currentThread() << anotherBar.foos.size();
    }
};

int main(int argc, char *argv[])
{
    // main thread
    const Bar bar;

    qRegisterMetaType<QVector<Foo>>("QVector<Foo>");
    const QScopedPointer<QThread> thread(new QThread);

    Producer prod(bar);
    prod.moveToThread(thread.data());

    const QCoreApplication a(argc, argv);
    QObject::connect(thread.data(), &QThread::started, &prod, &Producer::do_produce);
    QObject::connect(thread.data(), &QThread::finished, qApp, &QCoreApplication::quit);
    QTimer::singleShot(0, qApp, [&thread]{thread->start();}); // start thread when event loop is running
    return qApp->exec();
}

#include "main.moc"

#include <QtCore/QCoreApplication>
#include <QtCore/QDebug>

int main(int, char *[])
{
    struct Foo
    {
        mutable int data = -1; // <- we are very 'smart'
    };
    const auto vector = QVector<Foo>{Foo()};
    [vector]{ // capture by value, this makes copy of QVector, but content is implicitly shared
        // function "at" must be used for read-only access,
        // since it returns const reference and never makes deep copy.
        // It is still possible to modify data marked as mutable and make
        // changes which affects other owners of implicitly shared data.
        vector.at(0).data = 42;
        //  foo[0].data = 42; // <- right way to do
    }();
    // Ops: our local constant data is modified in another place because COW is broken with mutable!
    qDebug() << vector.at(0).data;
    return 0;
}