• Возможность организации ассоциативных связей между объектами в соответствии с UML.
  
• Определены концепты, которые в compile-time позволяют гибко определять тип указателей UPL в обобщённых алгоритмах.
  
• Указатель upl::weak может ссылаться на объект, который находится под управлением upl::unique.
  
• Указатель upl::unified позволяет передать уникальное владение объектом в цепочке, где может выполняться копирование.
  
• С помощью upl::unified можно временно продлить время жизни объекта в заданной области видимости, что позволяет корректно завершить работу с ним, даже когда все остальные указатели на этот объект удалены.
  
• Добавлены указатели с одинарной кратностью, которые не могут быть пустыми и всегда ссылаются на один объект.

Целью проекта UPL является создание инструментальной библиотеки для повышения качества и удобства программирования на языке C++ в стиле ООП, в частности для организации ассоциативных связей между объектами в многопоточной среде.

UPL предоставляет расширенную семантику для концепций владения и управления временем жизни объектов, по сравнению с умными указателями стандартной библиотеки C++. Больше внимания уделяет указателям с уникальным владением (слабые ссылки для них, возможность передачи в функторы, которые требуют копирование аргументов (std::function)), обеспечивает продление времени жизни объекта в заданной области видимости, добавляет указатели с одинарной кратностью, которые всегда ссылаются на один объект.

Указатели UPL не являются заменой умных указателей стандартной библиотеки C++ и могут использоваться совместно с ними (конечно, одновременно объект может находиться под управлением только одной библиотеки). UPL предназначена для случаев, когда не хватает функциональности умных указателей стандартной библиотеки C++ и требуются дополнительные возможности для организации связей между объектами в многопоточной среде.

• Указатель upl::weak может ссылаться на объект, который находится под управлением upl::unique.
  
• Указатель upl::unified позволяет передать уникальное владение объектом в цепочке, где может выполняться копирование.

С помощью upl::unified можно временно продлить время жизни объекта в заданной области видимости, что позволяет корректно завершить работу с ним, даже когда все остальные указатели на этот объект удалены.

• тем, что описано в UML;
  
• тем, что восприняли вы;
  
• тем, как вы свое восприятие "положили" на возможности C++.

V>>Что то у меня порвался шаблон немного

class Car;
class Engine;

class Car
{
    upl::unique<Engine> engineStrong;   //рассматриваем этот unique как полюс ассоциации "машина [0,1] -- [0,1] двигатель"
    upl::weak<Engine>   engineWeak;     //альтернативный полюс для engineStrong. Вот про него речь. С ним проблемы.
};

class Engine
{
    unspecified<Car> car;               //противоположный для engineStrong+engineWeak, может быть upl::weak, а может что то другое. Не интересует
};

#include <memory>
#include <functional>
#include <iostream>

using namespace std;

void foo(shared_ptr<int> ptr) { cout << "foo shared: " << *ptr << endl; }
void bar(unique_ptr<int> ptr) { cout << "bar unique: " << *ptr << endl; }

int main()
{
    auto s = make_shared<int>(7);
    function<void()> foo_f = bind(&foo, move(s));
    foo_f();

    auto u = make_unique<int>(7);
    function<void()> bar_f = bind(&bar, move(u)); // error: conversion from 'std::_Bind_helper<false, void (*)(std::unique_ptr<int>)...
    bar_f();

    return 0;
}

V>class Car;
V>class Engine;

V>class Car
V>{
V>    upl::unique<Engine> engineStrong;   //рассматриваем этот unique как полюс ассоциации "машина [0,1] -- [0,1] двигатель"
V>    upl::weak<Engine>   engineWeak;     //альтернативный полюс для engineStrong. Вот про него речь. С ним проблемы.
V>};

V>class Engine
V>{
V>    unspecified<Car> car;               //противоположный для engineStrong+engineWeak, может быть upl::weak, а может что то другое. Не интересует
V>};
V>

class Monitor
{
    upl::weak<Engine> engineWeak;
}

class UniqueEngine {
  std::shared_ptr<Engine> engine_;
public:
  UniqueEngine(const UniqueEngine &) = disable;
  UniqueEngine(UniqueEngine &&) = default;
  UniqueEngine(std::unique_ptr<Engine> en) : engine_(std::move(en)) {}
  ...
  std::weak_ptr<Engine> weak_ref() { return {engine_}; }
  ...
};
...
class Car {
  UniqueEngine engine_;
  ...
public:
  auto engine() { return engine_.weak_ref(); }
};
class Monitor {
  std::weak_ptr<Engine> engine_;
  ...
};

class Car : public std::enable_shared_from_this {
  Engine engine_;
public:
  std::weak_ptr<Engine> engine() {
    return { std::shared_ptr<Engine>(shared_from_this(), &engine) };
  };
};

VT>Если вам хватает функциональности std::shared_ptr, и не нужны всякие псевдоконцепции, то и ладно

function<void()> foo_f = [&]{foo(move(s));};
function<void()> bar_f = [&]{bar(move(u));};

_NN>function<void()> foo_f = [&]{foo(move(s));};
_NN>function<void()> bar_f = [&]{bar(move(u));};
_NN>

#include <memory>
#include <functional>
#include <vector>
#include <iostream>

using namespace std;

void bar(unique_ptr<int> ptr) { cout << "bar unique: " << *ptr << endl; }

int main()
{
    vector<function<void()>> commands;
    {
        auto u = make_unique<int>(7);
        commands.push_back([&] { bar(move(u)); });
    }
    commands[0]();

    return 0;
}

V>Ну, тут сплошные засады Ты просто накладываешь полезняшки на чашу весов какого то своего скрытого кейса. Но надо понимать, что если ты на свою чашу что то добавил — то с другой забрал. Например, ты убил детерминированность времени жизни указываемого объекта, а существует большое число прикладных кейсов, в которых такая детерминированность нужна/полезна. Например, ты существенно увеличил расход ресурсов потому что для твоего кейса это не существенно, но для многих перерасход будет фатальным. Клоню к тому, что "унификации" не получилось. Получился какой то сугубо конкретный тул. Да еще и чужую терминологию употребил, чем сбил всех с толку, а с so5team даже подрался

Указатели UPL не являются заменой умных указателей стандартной библиотеки C++ и могут использоваться совместно с ними (конечно, одновременно объект может находиться под управлением только одной библиотеки). UPL предназначена для случаев, когда не хватает функциональности умных указателей стандартной библиотеки C++ и требуются дополнительные возможности для организации связей между объектами в многопоточной среде.

Указатель upl::weak может ссылаться на объект, который находится под управлением upl::unique

vector<int> a;
a.push_back(1);
int* x = &a[0];
a.clear();
*x = 1;

auto a = unique_ptr<int>(new int(1));
auto b = shared_ptr<int>(move(a));
    
foo(b); // Можем копировать b без проблем

void bar(unique_ptr<int> ptr) { cout << "bar unique: " << *ptr << endl; }

void bar(int value) { cout << "bar unique: " << value << endl; }

A guarded pointer, QPointer<T>, behaves like a normal C++ pointer T *, except that it is automatically set to 0 when the referenced object is destroyed (unlike normal C++ pointers, which become "dangling pointers" in such cases). T must be a subclass of QObject.

#include <upl/pointer.h>
#include <iostream>

struct Engine
{
public:
    int rpm() { return ++m_rpm; }

private:
    int m_rpm{0};
};

class Car
{
public:
    Car(upl::unique<Engine> engine) : m_engine{std::move(engine)} {}

    void replaceEngine(upl::unique<Engine> engine)
    { m_engine = std::move(engine); }

    upl::unique<Engine> releaseEngine()
    { return std::move(m_engine); }

private:
    upl::unique<Engine> m_engine;
};

class Monitor
{
public:
    Monitor(upl::weak<Engine> engine) : m_engine{engine} {}

    void replaceEngine(upl::weak<Engine> engine)
    { m_engine = engine; }

    // This method is executed in a separate thread.
    void activate()
    {
        using namespace std;

        upl::unified<Engine> engine_lock = m_engine.lock();
        if (engine_lock)
            cout << "Engine rpm = " << (*engine_lock).rpm() << endl;
        else
            cout << "No engine" << endl;
    }

private:
    upl::weak<Engine> m_engine;
};

int main()
{
    using namespace std;

    upl::unique<Engine>  engine_1{in_place};
    upl::unique<Monitor> monitor_1{in_place, engine_1};
    upl::unique<Car>     car_1{in_place, move(engine_1)};

    (*monitor_1).activate();
    (*monitor_1).activate();

    engine_1 = (*car_1).releaseEngine();
    upl::unique<Monitor> monitor_2{in_place, engine_1};
    upl::unique<Car>     car_2{in_place, move(engine_1)};

    (*monitor_1).activate();
    (*monitor_2).activate();

    upl::unique<Engine> engine_2{in_place};
    (*monitor_2).replaceEngine(engine_2);
    (*car_2).replaceEngine(move(engine_2));

    (*monitor_1).activate();
    (*monitor_2).activate();

    return 0;
}

Engine rpm = 1
Engine rpm = 2
Engine rpm = 3
Engine rpm = 4
No engine
Engine rpm = 1

• MasterPointer<T>. "Владеющий" умный указатель. Может быть в единственном числе. Moveable но не Copyable. Из MasterPointer-а можно получить WeakPointer.
  
• WeakPointer<T>. Аналог std::weak_ptr, но принципиальная разница в том, что из WeakPointer можно получить только SlavePointer, но нельзя получить MasterPointer. Copyable + Moveable.
  
• SlavePointer<T>. "Невладеющий" умный указатель. Получается из WeakPointer. Продлевает жизнь объекта. Но из SlavePointer-а нельзя получить MasterPointer. Copyable + Moveable.

template<typename OnSuccess, typename OnFailure>
decltype(auto) try_acquire_then_handle(OnSuccess on_success, OnFailure on_failure) {
  auto shptr = handle_.lock();
  if(shptr)
    return on_success(*shptr);
  else
    return on_failure();
}

void activate() {
  engine_.try_acquire_then_handle(
    [](auto & engine) { cout << "Engine rpm: " << engine.rpm() << endl; },
    []() { cout << "No engine" << endl; }
  );
}

#include <memory>
#include <functional>
#include <iostream>

using namespace std;

void foo( shared_ptr<int> ptr )
{
     cout << "foo shared: " << *ptr << endl;
}
void bar( unique_ptr<int>& ptr )
{
     cout << "bar unique: " << *ptr << endl;
}

int main()
{
     auto s = make_shared<int>( 7 );
     function<void()> foo_f = bind( &foo, move( s ) );
     foo_f();

     auto u = make_unique<int>( 7 );
     auto bar_f = bind( &bar, move( u ) );
     bar_f();

     return 0;
}