object_provider.h

Go to the documentation of this file.

// === object_provider.h ===============================================================================================
//                                               Sen Infrastructure
//                   Released under the Apache License v2.0 (SPDX-License-Identifier Apache-2.0).
//                                    See the LICENSE.txt file for more information.
//                   © Airbus SAS, Airbus Helicopters, and Airbus Defence and Space SAU/GmbH/SAS.
// =====================================================================================================================
 
#ifndef SEN_CORE_OBJ_OBJECT_PROVIDER_H
#define SEN_CORE_OBJ_OBJECT_PROVIDER_H
 
// sen
#include "sen/core/base/compiler_macros.h"
#include "sen/core/meta/type.h"
#include "sen/core/obj/detail/proxy_object.h"
#include "sen/core/obj/detail/work_queue.h"
#include "sen/core/obj/interest.h"
#include "sen/core/obj/object.h"
 
// std
#include <functional>
#include <memory>
#include <variant>
 
namespace sen
{

 
// Forward declarations
class ObjectProvider;

SEN_STRONG_TYPE(ObjectOwnerId, uint32_t)
 
template <>
struct ShouldBePassedByValue<ObjectOwnerId>: std::true_type
{
};

struct ObjectInstanceDiscovery
{
  std::shared_ptr<Object> instance;
  ObjectId id;
  InterestId interestId;
  ObjectOwnerId ownerId;
};

struct RemoteObjectDiscovery
{
  ObjectId id;
  std::string name;
  ConstTypeHandle<ClassType> type;
  std::function<std::shared_ptr<impl::ProxyObject>(impl::WorkQueue*, const std::string&, ObjectOwnerId)> proxyMaker;
  InterestId interestId;
  ObjectOwnerId ownerId;
};

using ObjectAddition = std::variant<ObjectInstanceDiscovery, RemoteObjectDiscovery>;

struct ObjectRemoval
{
  InterestId interestId;
  ObjectId objectid;
  ObjectOwnerId ownerId;
};

using ObjectAdditionList = std::vector<ObjectAddition>;

using ObjectRemovalList = std::vector<ObjectRemoval>;
 
// Helpers to extract information out of the previous containers
[[nodiscard]] inline ObjectId getObjectId(const ObjectAddition& discovery)
{
  return std::holds_alternative<ObjectInstanceDiscovery>(discovery) ? std::get<ObjectInstanceDiscovery>(discovery).id
                                                                    : std::get<RemoteObjectDiscovery>(discovery).id;
}
 
[[nodiscard]] inline ObjectOwnerId getObjectOwnerId(const ObjectAddition& discovery)
{
  return std::holds_alternative<ObjectInstanceDiscovery>(discovery)
           ? std::get<ObjectInstanceDiscovery>(discovery).ownerId
           : std::get<RemoteObjectDiscovery>(discovery).ownerId;
}
 
[[nodiscard]] inline InterestId getInterestId(const ObjectAddition& discovery)
{
  return std::holds_alternative<ObjectInstanceDiscovery>(discovery)
           ? std::get<ObjectInstanceDiscovery>(discovery).interestId
           : std::get<RemoteObjectDiscovery>(discovery).interestId;
}
 
[[nodiscard]] inline Object* getObjectInstance(const ObjectAddition& discovery)
{
  return std::holds_alternative<ObjectInstanceDiscovery>(discovery)
           ? std::get<ObjectInstanceDiscovery>(discovery).instance.get()
           : nullptr;
}
 
[[nodiscard]] ObjectRemoval makeRemoval(const ObjectAddition& discovery);

class ObjectProviderListener
{
public:
  ObjectProviderListener();
  virtual ~ObjectProviderListener();
 
  // Force Move-Only behavior here (macro does not work because of the pimpl of the ConcurrentProviderList)
  ObjectProviderListener(const ObjectProviderListener&) = delete;
  ObjectProviderListener& operator=(const ObjectProviderListener&) = delete;
  ObjectProviderListener(ObjectProviderListener&& other) noexcept;
  ObjectProviderListener& operator=(ObjectProviderListener&& other) noexcept;
 
public:  // implementation & optimization-related (they return nullptr by default)
  [[nodiscard]] virtual kernel::impl::RemoteParticipant* isRemoteParticipant() noexcept;
  [[nodiscard]] virtual kernel::impl::LocalParticipant* isLocalParticipant() noexcept;
 
protected:
  virtual void onObjectsAdded(const ObjectAdditionList& additions) = 0;

  virtual void onObjectsRemoved(const ObjectRemovalList& removals) = 0;
 
private:
  friend class ObjectProvider;
  void addProvider(ObjectProvider* provider);
  void removeProvider(ObjectProvider* provider);
 
private:
  struct ConcurrentProviderList;
  std::unique_ptr<ConcurrentProviderList> providers_;
};

class ObjectProvider: public std::enable_shared_from_this<ObjectProvider>
{
  SEN_NOCOPY_NOMOVE(ObjectProvider)
 
public:
  ObjectProvider();
  virtual ~ObjectProvider();
 
public:
  virtual void addListener(ObjectProviderListener* listener, bool notifyAboutExistingObjects);

  virtual void removeListener(ObjectProviderListener* listener, bool notifyAboutExistingObjects);

  virtual void replaceListener(ObjectProviderListener* oldListener, ObjectProviderListener* newListener);

  [[nodiscard]] virtual bool hasListener(ObjectProviderListener* listener) const noexcept;

  [[nodiscard]] virtual bool hasListeners() const noexcept;
 
protected:
  friend class ObjectFilter;

  virtual void notifyObjectsAdded(const ObjectAdditionList& additions);

  virtual void notifyObjectsRemoved(const ObjectRemovalList& removals);

  virtual void listenerAdded(ObjectProviderListener* listener, bool notifyAboutExistingObjects);

  virtual void listenerRemoved(ObjectProviderListener* listener, bool notifyAboutExistingObjects);
 
protected:
  virtual void notifyAddedOnExistingObjects(ObjectProviderListener* listener) = 0;

  virtual void notifyRemovedOnExistingObjects(ObjectProviderListener* listener) = 0;

  void notifyRemovedOnExistingObjectsForAllListeners();
 
protected:  // helpers for subclasses
  void forEachListener(const std::function<void(ObjectProviderListener*)>& callback) const;
 
  void callOnObjectsAdded(ObjectProviderListener* listener, const ObjectAdditionList& additions) const;
  void callOnObjectsRemoved(ObjectProviderListener* listener, const ObjectRemovalList& removals) const;
 
private:
  friend ObjectProviderListener;
  void listenerDeleted(ObjectProviderListener* listener);
 
private:
  struct ConcurrentListenerList;
  std::unique_ptr<ConcurrentListenerList> listeners_;
};

 
//----------------------------------------------------------------------------------------------------------------------
// Inline implementation
//----------------------------------------------------------------------------------------------------------------------
 
inline ObjectRemoval makeRemoval(const ObjectAddition& discovery)
{
  if (std::holds_alternative<ObjectInstanceDiscovery>(discovery))
  {
    const auto& instanceDiscovery = std::get<ObjectInstanceDiscovery>(discovery);
    return {instanceDiscovery.interestId, instanceDiscovery.id, instanceDiscovery.ownerId};
  }
 
  const auto& remoteObjectDiscovery = std::get<RemoteObjectDiscovery>(discovery);
  return {remoteObjectDiscovery.interestId, remoteObjectDiscovery.id, remoteObjectDiscovery.ownerId};
}
 
}  // namespace sen
 
SEN_STRONG_TYPE_HASHABLE(::sen::ObjectOwnerId)
 
#endif  // SEN_CORE_OBJ_OBJECT_PROVIDER_H