BFE>>ModelExample2 a;
BFE>>ModelExample2 b;
BFE>>a.g() = b.g();
BFE>>

a.g()=10;
a.g()=b.g();

#include "Notifier.h"

#define ERR_MODIFY_READONLY    "modify in readonly mode"
#define ERR_LOCK_READONLY      "unable to lock in readonly mode"
#define ERR_ALREADY_SUBSCRIBED "listener already subscibed"
#define ERR_NOT_SUBSCRIBED     "listener not registered"
#define ERR_HAS_CHILD          "this node already attached"
#define ERR_NO_CHILD           "no such child node found"
#define ERR_BAD_LOCK_LEVEL     "lock_level must be 0"
#define ERR_BAD_LOCK_LEVEL_RO  "lock_level<0 must be 0"
void throw_exception(const char* reason) {
    throw reason;
}

Notifier::Notifier() {
    lock_level=0;
    modified=false;
}
Notifier::~Notifier() {
    if (lock_level!=0) {
        // fatal error!
        lock_level=lock_level;
    }
}
void Notifier::Modified() {
    modified=true; 
    if (lock_level>0) return;
    if (lock_level<0) throw_exception(ERR_MODIFY_READONLY);
    NotifyAll(); 
}
void Notifier::NotifyChange() {
    Modified();
}
void Notifier::Lock() {
    if (lock_level<0) throw_exception(ERR_LOCK_READONLY);
    if (++lock_level==1) LockChildren();
}
void Notifier::Unlock() {
    if (--lock_level==0) {        
        lock_level++;
        UnlockChildren();
        lock_level--;
        if (modified) NotifyAll();
    }
}
void Notifier::AttachChild(Notifier& child) {
    if (children.find(&child)!=children.end()) throw_exception(ERR_HAS_CHILD);
    children.insert(&child);
    if (lock_level>0) child.Lock();
    child.Subscribe(*this,!modified && child.IsModified());
}
void Notifier::DetachChild(Notifier& child) {
    children_it it=children.find(&child);
    if (it==children.end()) throw_exception(ERR_NO_CHILD);
    children.erase(it);
    child.Unsubscribe(*this);
    if (lock_level>0) child.Unlock();
}
void Notifier::Subscribe(NotifyListener &listener,bool notify_attach) {
    if (listeners.find(&listener)!=listeners.end()) throw_exception(ERR_ALREADY_SUBSCRIBED);
    listeners.insert(&listener);
    if (notify_attach) listener.NotifyChange();
}
void Notifier::Unsubscribe(NotifyListener &listener) {
    listeners_it it=listeners.find(&listener);
    if (it==listeners.end()) throw_exception(ERR_NOT_SUBSCRIBED);
    listeners.erase(it);
}
void Notifier::LockChildren() {
    for(children_it it=children.begin();it!=children.end();++it) {
        (*it)->Lock();
    }
}
void Notifier::UnlockChildren() {
    for(children_it it=children.begin();it!=children.end();++it) {
        (*it)->Unlock();
    }
}
void Notifier::NotifyAll() {
    if (lock_level!=0) {
        if (lock_level<0) throw_exception(ERR_BAD_LOCK_LEVEL_RO);
        else throw_exception(ERR_BAD_LOCK_LEVEL);
    }
    lock_level=-1; // enter read only mode
    for(listeners_it it=listeners.begin();it!=listeners.end();++it) {
        (*it)->NotifyChange();
    }
    modified=false;
    lock_level=0; // leave readonly mode
}
int  Notifier::GetDeepLevel() const {
    int deep=0;
    for(children_cit it=children.begin();it!=children.end();++it) {
        int d=(*it)->GetDeepLevel();
        if (deep<d) deep=d;
    }
    return deep+1;
}
bool Notifier::IsDeepUnlocked() const {
    for(children_cit it=children.begin();it!=children.end();++it) {
        if (!(*it)->IsDeepUnlocked()) return false;
    }
    return true;
}

delegate<signature> - оператор объявления типа делегата с сигнатурой signature

delegate(function, оbject, (arg1, arg2, ... argN | _1, _2, ... _N) ) - оператор создания функционального объекта для делегата с сигнатурой function,
из функции function и (если function - член-функция) указателя на объект оbject
//короче std::bind-like синтаксис, пусть только дедукцией занимается компилятор, а не костыли вида std::bind

enum class EventType
{
  Test  = 0x0001,
};

struct Object
{
  void OnEvent(EventType event)
  {
    //1st subscriber callback
  }
};

void OnEvent(EventType event)
{
  //2nd subscriber callback
}

int main()
{
  Object object;
  delegate<void(EventType event)> d = delegate(&Object::OnEvent, &object); //делегат d инициализируется первым подписчиком
  d += delegate(OnEvent); //добавляется второй подписчик
  d += [](EventType event) { /*3rd subscriber callback*/ }; //добавляется третий подписчик

  d -= delegate(OnEvent); //второй, пожалуй, лишний
  d(EventType::Test); //вызов подписчиков 1 и 3: метода Object::OnEvent объекта object и анонимной функции
  //???
  //ENJOY!!1
}