IpcChannel.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Communication/RemoteInterface.h>
#include <Foundation/Threading/ThreadSignal.h>
#include <Foundation/Types/UniquePtr.h>
 
class plIpcChannel;
class plMessageLoop;
 
struct PL_FOUNDATION_DLL plIpcChannelEvent
{
  enum Type
  {
    Disconnected, 
    Connecting,   
    Connected,    
    NewMessages,  
  };
 
  plIpcChannelEvent() = default;
 
  plIpcChannelEvent(Type type, plIpcChannel* pChannel)
    : m_Type(type)
    , m_pChannel(pChannel)
  {
  }
 
  Type m_Type = NewMessages;
  plIpcChannel* m_pChannel = nullptr;
};
 
 
 
class PL_FOUNDATION_DLL plIpcChannel
{
public:
  struct Mode
  {
    using StorageType = plUInt8;
    enum Enum
    {
      Server,
      Client,
      Default = Server
    };
  };
 
  struct ConnectionState
  {
    using StorageType = plUInt8;
    enum Enum
    {
      Disconnected,
      Connecting, 
      Connected,
      Default = Disconnected
    };
  };
 
  virtual ~plIpcChannel();
 
  static plInternal::NewInstance<plIpcChannel> CreatePipeChannel(plStringView sAddress, Mode::Enum mode);
 
  static plInternal::NewInstance<plIpcChannel> CreateNetworkChannel(plStringView sAddress, Mode::Enum mode);
 
 
  void Connect();
  void Disconnect();
  bool IsConnected() const { return m_iConnectionState == ConnectionState::Connected; }
  plEnum<ConnectionState> GetConnectionState() const { return plEnum<ConnectionState>(m_iConnectionState); }
 
  bool Send(plArrayPtr<const plUInt8> data);
 
  using ReceiveCallback = plDelegate<void(plArrayPtr<const plUInt8> message)>;
  void SetReceiveCallback(ReceiveCallback callback);
 
  plResult WaitForMessages(plTime timeout);
 
public:
  plEvent<const plIpcChannelEvent&, plMutex> m_Events; 
 
protected:
  plIpcChannel(plStringView sAddress, Mode::Enum mode);
 
  virtual bool RequiresRegularTick() { return false; }
  virtual void Tick() {}
 
  virtual void InternalConnect() = 0;
  virtual void InternalDisconnect() = 0;
  virtual void InternalSend() = 0;
  virtual bool NeedWakeup() const = 0;
 
  void SetConnectionState(plEnum<ConnectionState> state);
  void ReceiveData(plArrayPtr<const plUInt8> data);
  void FlushPendingOperations();
 
private:
protected:
  enum Constants : plUInt32
  {
    HEADER_SIZE = 8,                     
    MAGIC_VALUE = 'USED',                
    MAX_MESSAGE_SIZE = 1024 * 1024 * 16, 
  };
 
  friend class plMessageLoop;
  plThreadID m_ThreadId = 0;
 
  plAtomicInteger<ConnectionState::Enum> m_iConnectionState = ConnectionState::Disconnected;
 
  // Setup in ctor
  plString m_sAddress;
  const plEnum<Mode> m_Mode;
  plMessageLoop* m_pOwner = nullptr;
 
  // Mutex locked
  plMutex m_OutputQueueMutex;
  plDeque<plContiguousMemoryStreamStorage> m_OutputQueue;
 
  // Only accessed from worker thread
  plDynamicArray<plUInt8> m_MessageAccumulator; 
 
  // Mutex locked
  plMutex m_ReceiveCallbackMutex;
  ReceiveCallback m_ReceiveCallback;
  plThreadSignal m_IncomingMessages;
};