// start
- UI shared_ptr -> nullptr
- RT shared_ptr -> nullptr

// new object (A) in RT
- UI shared_ptr -> nullptr
- RT shared_ptr -> A | version 1
- RT sends "version 1" message to UI
- UI receives "version 1" notification and copies RT shared_ptr
- UI shared_ptr -> A | version 1

// new object (B) in UI
- RT shared_ptr -> A | version 1
- UI shared_ptr -> B | version 2
- UI sends "version 2" message to RT
- RT receives "version 2" notification and copies UI shared_ptr
- A is destroyed as a result (assuming the rest of the code is not still pointing to it)
- RT shared_ptr -> B | version 2 

// declaration
JmbParam<int64> fUIToRTVersion; // used by UI to communicate new version to RT
JmbParam<int64> fRTToUIVersion; // used by RT to communicate new version to UI
JmbParam<SharedObjectMgr<MyType> *> fSharedObjectMgrPtr; // the shared mgr

// definition
fUIToRTVersion =
  jmb<Int64ParamSerializer>(EParamIDs::kUIToRTVersion, STR16 ("UI Version (msg)"))
    .guiOwned()
    .shared()
    .transient()
    .add();

fRTToUIVersion =
  jmb<Int64ParamSerializer>(EParamIDs::kRTToUIVersion, STR16 ("RT Version (msg)"))
    .rtOwned()
    .shared()
    .transient()
    .add();

fSharedObjectMgrPtr =
  jmb<PointerSerializer<SharedObjectMgr<MyType>>(EParamIDs::kSharedObjectMgrPtr, STR16 ("Shared Mgr (ptr)"))
    .transient()
    .rtOwned()
    .shared()
    .add();

template<typename T>
class PointerSerializer : public IParamSerializer<T *>
{
public:
  using ParamType = T *;

  static_assert(sizeof(ParamType) <= sizeof(uint64), "Making sure that a pointer will fit");

  tresult readFromStream(IBStreamer &iStreamer, ParamType &oValue) const override
  {
    uint64 ptr;

    auto res = IBStreamHelper::readInt64u(iStreamer, ptr);
    if(res != kResultOk)
      return res;

    oValue = reinterpret_cast<ParamType>(ptr);

    return res;
  }

  tresult writeToStream(ParamType const &iValue, IBStreamer &oStreamer) const override
  {
    if(oStreamer.writeInt64u(reinterpret_cast<uint64>(iValue)))
      return kResultOk;
    else
      return kResultFalse;
  }
};

// definition (PluginRTState)
RTJmbInParam<int64> fUIToRTVersion;
RTJmbOutParam<int64> fRTToUIVersion;
RTJmbOutParam<SharedObjectMgr<MyType> *> fSharedObjectMgrPtr;

SharedObjectMgr<MyType> fSharedMgr{};
  
// Usage | sending the shared pointer to the UI
tresult SampleSplitterProcessor::setupProcessing(ProcessSetup &setup)
{
  // ...
  
  // sending the shared pointer to the UI
  fState.fSharedObjectMgrPtr.broadcast(&fState.fSharedMgr);
  
  // ...
}

// Usage | receiving a MyType from UI
tresult SampleSplitterProcessor::processInputs(ProcessData &data)
{
  // ...
  
  auto version = fState.fUIToRTVersion.pop();
  if(version)
  {
    auto myObject = fState.fSharedMgr.rtAdjustObjectFromUI(*version);

    if(myObject)
    {
      // store myObject.get() somewhere and use it in the rest of the code
    }

  }
  
  // ...
}

// Usage | updating MyType on the RT side
template<typename SampleType>
tresult SampleSplitterProcessor::genericProcessInputs(ProcessData &data)
{
  // ...
  
  auto myObject = std::make_shared<MyType>(...);
    
  // we store it in the mgr
  auto version = fState.fSharedMgr.rtSetObject(myObject);
  
  // and notify the UI of the new sample
  fState.fRTToUIVersion.broadcast(version);
  
  // store myObject.get() somewhere and use it in the rest of the code
  
  // ...
}

// definition
GUIJmbParam<int64> fUIToRTVersion;
GUIJmbParam<SharedObjectMgr<MyType> *> fSharedObjectMgrPtr;
// no need to define fRTToUIVersion as we can use the one in Parameters instead

// retrieving manager
SharedObjectMgr<MyType> *getSharedMgr()
{
  // ... see above for more complicated implementation accounting for
  // no RT or non deterministic messaging 
  return *fSharedObjectMgrPtr;
}

// Usage | updating MyType on the UI side (from some view, controller, or listener)
void myFunction()
{

  // ....
  auto myObject = std::make_shared<MyType>(...);
    
  // we store it in the mgr
  auto version = getSharedMgr()->uiSetObject(myObject);

  // we tell RT
  fUIToRTVersion.broadcast(version);

}

// Usage | receiving a MyType from RT
void XXXController::registerParameters()
{
  // ...
  
  registerCallback<int64>(fParams->fRTToUIVersion,
                         [this] (GUIJmbParam<int64> &iParam) {
                           auto version = *iParam;
                           
                           auto myObject = getSharedMgr()->uiAdjustObjectFromRT(version);

                           if(myObject)
                           {
                             // ...
                           }
                         });
  
  // ...
}