resupplyReceiverController.h

Go to the documentation of this file.

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



#pragma once

#include <vrfMsgTransport/events.h>

#include "vrfobjcore/singleTaskControllerComponent.h"
#include "vrfobjcore/resupplyReceiverControllerPSR.h"
#include <vrfMsgTransport/serviceRequestEvent.h>
#include <vrfMsgTransport/resupplyOfferEvent.h>
#include <vrfMsgTransport/resupplyReceivedEvent.h>
#include <vrfMsgTransport/resupplyCancelEvent.h>

#include "vrfmodel/resupplyReceiverStateData.h"
#include "vrfmodel/vrfmodelDefines.h"

#include <boost/signals2.hpp>

class DtResupplyReceiverControllerDescriptor;
class DtTransferSuppliesTask;

class DT_DLL_vrfmodel DtResupplyReceiverController : public DtSingleTaskControllerComponent
{
public:

   DtResupplyReceiverController(const DtString& name, DtLocalObject* owner,
      DtSimulationServices* simManager, 
      DtComponentDescriptor* compDesc = 0,
      DtReaderWriterRegistry* parentRegistry = 0);

   virtual ~DtResupplyReceiverController();

   virtual const char* type() const;

   virtual bool postAddComponentsInit();

   virtual bool init();

   static void setSupplyingCallback(DtSimMessage * msg, void * usr);

   virtual void processSetSupplying(DtSimMessage * msg);

   virtual void addSetDataCallbacks();

   void removeSetDataCallbacks();

   virtual void preFirstTickInit();

   virtual void tick();

   static DtSimComponent* creator(const DtString& name,
      DtLocalObject* owner,
      DtSimulationServices* simManager,
      DtComponentDescriptor* desc,
      DtReaderWriterRegistry* parentRegistry);

   static void transferSuppliesTaskCallback(DtSimMessage* msg, void* usr);


   static void supplyListRequestCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processSupplyListRequest(const DtVrfObjectMessage* msg);

protected:
   virtual DtResupplyReceiverControllerPSR* createPSR();

   virtual const DtResupplyReceiverControllerDescriptor* getDescriptor();


   virtual void resupplyOfferEvent(const makVrfEvents::DtEvent&);
   virtual void processResupplyOffer(const makVrfEvents::DtResupplyOfferEvent& resupplyOffer);


   virtual void resupplyCancelEvent(const makVrfEvents::DtEvent&);
   virtual void processResupplyCancel(const makVrfEvents::DtResupplyCancelEvent& resupplyCancel);


   virtual makVrfEvents::DtServiceRequestEvent createServiceRequestInteraction();

   virtual void sendServiceRequestInteraction(const makVrfEvents::DtServiceRequestEvent& serviceRequest);
   virtual makVrfEvents::DtResupplyReceivedEvent createResupplyReceivedInteraction();
   virtual void sendResupplyReceivedInteraction(const makVrfEvents::DtResupplyReceivedEvent& resupplyReceived);

   virtual makVrfEvents::DtResupplyCancelEvent createResupplyCancelInteraction();
   virtual void sendResupplyCancelInteraction(const makVrfEvents::DtResupplyCancelEvent& resupplyCancel);

protected:
   virtual void processTransferSuppliesTask(DtSimMessage* msg);
   virtual void processTransferSuppliesTaskPSR();

   virtual void retrieveTransferSuppliesTaskParams(const DtTransferSuppliesTask* transferSuppliesTask,
                                                   DtEntityType & supplyType,
                                                   double & quantityRequestedTotal,
                                                   double & rate,
                                                   DtSimObjectReference & supplier);

   virtual void retrieveTransferSuppliesTaskParamsPSR(const DtTransferSuppliesTask* transferSuppliesTask,
                                                      std::map<DtString, double> & supplies,
                                                      std::map<DtString, double> & suppliesRate,
                                                      DtSimObjectReference & supplier);

   virtual bool verifyTransferSuppliesTaskParams(double amount, double rate);

   virtual void transferSupplies();
   virtual void processReadyState();
   virtual void processRequestingState();
   virtual void processReceivingState();

   virtual void updateTaskedSupplies(const DtEntityType& supplyType,
                                     double quantityRequestedTotal,
                                     double rate,
                                     DtSimObjectReference supplier);
   virtual void updateTaskedSuppliesPSR(const std::map<DtString, double>& supplies,
                                        std::map<DtString, double> & suppliesRate,
                                        DtSimObjectReference supplier);
   virtual void updateOfferedSupplies(const makVrfEvents::DtResupplyOfferEvent& resupplyOffer);
   virtual void updateReceivedSupplies(DtTime interval);
   virtual void removeReceivedSupplies();
   virtual bool checkResourceAvailable(DtEntityType type);
   virtual double resourceAvailable(DtEntityType type);
   virtual void updateResource(DtEntityType type, double quantity);
   virtual void updatePSR();

   virtual const DtString lookUpSupplyType(const DtEntityType& type) const;
   virtual const DtEntityType lookupSupplyName(const DtString& name) const;

   virtual double lookupMaxRate(const DtEntityType& type);

   virtual double calculateQuantityRequested(double quantityRequestedTotal);
   virtual DtTime calculateReceivingStateTimeout(double quantityRequestedTotal,
                                                 double quantityReceivedTotal,
                                                 double quantityRequested,
                                                 double quantityOffered,
                                                 double rate);
   virtual DtTime determineTimer2Period();

   virtual DtTime currentSimTime();

protected:
   DtResupplyReceiverControllerPSR* myProcessState;

   const DtResupplyReceiverControllerDescriptor* myResupplyReceiverDesc;

   DtResupplyReceiverStateData myReceiverStateData;

protected:
   const DtTime theRequestingStateDefaultTimeout = 30.0;

   const double theReceivingStateTimeoutPercentage = 0.95;

   const double theTotalReceivedAmountCompletePercentage = 0.999;

   const int theNumTransferSessions = 10;

   boost::signals2::scoped_connection myResupplyOfferEventConnection;
   boost::signals2::scoped_connection myResupplyCancelEventConnection;
};