ownershipManager.h

Go to the documentation of this file.

/*********************************************************************************
** Copyright (c) 2020 MAK Technologies, Inc.
** All rights reserved.
*********************************************************************************/

#pragma once

#include "legionNet/export.h"

#include "legionDataStore/callback.h"
#include "legionDataStore/callbackList.h"
#include "legionDataStore/dataTypes.h"
#include "legionDataStore/span.h"

#include "legionDataStoreImpl/c_api.h"

#include <vector>

namespace Legion
{
   class Connection;

   typedef UInt64 OwnershipManagerHandle;



   enum InitiateAcquisitionResult
   {
      InitiateRejected,
      AcquisitionRejected,
      OwnershipAcquired,
      AcquireException  // Received ownership acquire callback but had problems with private data or creating write repository, etc.
   };

   typedef Callback < void(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, Span<char> privateData)> DivestitureRequestCallback;
   typedef Callback<void(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, Span<char> privateData)> RequestRejectedCallback;
   typedef Callback < void(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, Span<char> privateData)> AcquiredCallback;
   typedef Callback <void(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, Span<char> privateData)> InitiateAcquisitionRequestCallback;
   typedef Callback<void(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, InitiateAcquisitionResult result,
      const std::string exceptionDescription)> InitiateAcquisitionResultCallback;

   class LEGIONNET_DLL OwnershipManager
   {

   public:

      virtual OwnershipManagerHandle handle() const;


      virtual UInt64 requestAcquisition(Span<GlobalIdentifier> globalIds, Span<char> privateData,
         TransactionIdentifier transactionId = 0);

      virtual void rejectDivestitureRequest(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds,
         Span<char> privateData);

      virtual void divest(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds, Span<char> privateData);


      virtual UInt64 requestInitiateAcquisition(ClientIdentifier acquiringClientId, Span<GlobalIdentifier> globalIds,
         Span<char> privateData);

      virtual void  initateAcquisitionRequestResponse(TransactionIdentifier transactionId, Span<GlobalIdentifier> globalIds,
         InitiateAcquisitionResult result, std::string exceptionDescription="");


      virtual UInt32 addDivestitureRequestCallback(DivestitureRequestCallback callback);
      virtual bool removeDivestitureRequestCallback(UInt32 callbackHandle);
      virtual UInt32 addRequestRejectedCallback(RequestRejectedCallback callback);
      virtual bool removeRequestRejectedCallback(UInt32 callbackHandle);
      virtual UInt32 addAcquiredCallback(AcquiredCallback callback);
      virtual bool removeAcquiredCallback(UInt32 callbackHandle);
      virtual UInt32 addInitiateAcquisitionRequestCallback(InitiateAcquisitionRequestCallback callback);
      virtual bool removeInitiateAcquisitionRequestCallback(UInt32 callbackHandle);
      virtual UInt32 addInitiateAcquisitionResultCallback(InitiateAcquisitionResultCallback callback);
      virtual bool removeInitiateAcquisitionResultCallback(UInt32 callbackHandle);

   protected:

      OwnershipManager(OwnershipManagerHandle ownershipHandle, DatabaseHandle databaseHandle);

      virtual ~OwnershipManager();

      struct CallbackData;
      virtual CallbackData* removeCallback(std::vector<CallbackData*>& callbackList, UInt32 callbackHandle);

#define divestitureRequestCallbackParameters TransactionId transactionId, const GlobalId* globalIds, UInt32 idCount, \
                                             const char* privateData, UInt32 dataSize
static void divestitureRequestCallback(void* usr, divestitureRequestCallbackParameters);

#define requestRejectedCallbackParameters TransactionId transactionId, const GlobalId* globalIds, UInt32 idCount, \
                                          const char* privateData, UInt32 dataSize
static void requestRejectedCallback(void* usr, requestRejectedCallbackParameters);

#define acquiredCallbackParameters TransactionId transactionId, const GlobalId* globalIds, UInt32 idCount, \
                                   const char* privateData, UInt32 dataSize
static void acquiredCallback(void* usr, acquiredCallbackParameters);

#define initiateAcquisitionRequestCallbackParameters TransactionId transactionId, const GlobalId* globalIds, UInt32 idCount, \
                                                     const char* privateData, UInt32 dataSize
static void initiateAcquisitionRequestCallback(void* usr, initiateAcquisitionRequestCallbackParameters);

#define initiateAcquisitionResultCallbackParameters TransactionId transactionId, const GlobalId* globalIds, UInt32 idCount, \
                                                    unsigned int result, const char* exceptionDescription
static void initiateAcquisitionResultCallback(void* usr, initiateAcquisitionResultCallbackParameters);

   protected:

      friend class Connection;

      OwnershipManagerHandle myHandle;
      DatabaseHandle myDatabaseHandle;

      struct CallbackData
      {
         UInt32 handle;
      };

      struct DivestitureRequestCallbackData : public CallbackData
      {
         std::function<void(divestitureRequestCallbackParameters)> convertAndExecute;
      };
      std::vector<CallbackData*> myDivestitureRequestCallbacks;

      struct RequestRejectedCallbackData : public CallbackData
      {
         std::function<void(requestRejectedCallbackParameters)> convertAndExecute;
      };
      std::vector<CallbackData*> myRequestRejectedCallbacks;

      struct AcquiredCallbackData : public CallbackData
      {
         std::function<void(acquiredCallbackParameters)> convertAndExecute;
      };
      std::vector<CallbackData*> myAcquiredCallbacks;

      struct InitiateAcquisitionRequestCallbackData : public CallbackData
      {
         std::function<void(initiateAcquisitionRequestCallbackParameters)> convertAndExecute;
      };
      std::vector<CallbackData*> myInitiateAcquisitionRequestCallbacks;

      struct InitiateAcquisitionResultCallbackData : public CallbackData
      {
         std::function<void(initiateAcquisitionResultCallbackParameters)> convertAndExecute;
      };
      std::vector<CallbackData*> myInitiateAcquisitionResultCallbacks;

   };

}