WsfPlatformPart.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFPLATFORMPART_HPP
#define WSFPLATFORMPART_HPP
 
#include "wsf_export.h"
 
#include <mutex>
#include <queue>
 
#include "WsfAuxDataEnabled.hpp"
#include "WsfCategoryList.hpp"
#include "WsfComponent.hpp"
class WsfGroup;
#include "WsfGroupList.hpp"
#include "WsfInternalLinks.hpp"
#include "WsfObject.hpp"
class WsfPlatform;
class WsfScenario;
class WsfSimulation;
#include "WsfTypes.hpp"
#include "WsfUniqueId.hpp"
#include "WsfVariable.hpp"

class WSF_EXPORT WsfPlatformPart : public WsfObject, public WsfPlatformComponent, public WsfUniqueId, public WsfAuxDataEnabled
{
public:
   enum
   {
      cLEVEL_ONE_DEBUG = 0x00000001, 
      cLEVEL_TWO_DEBUG = 0x00000002  
   };
 
   using InternalMessageQueue  = std::queue<WsfMessage*>;
   using RecipientMessageQueue = std::queue<std::pair<WsfPlatformPart*, WsfMessage*>>;
 
   WsfPlatformPart(const WsfScenario& aScenario, int aPartType);
   WsfPlatformPart& operator=(const WsfPlatformPart& aRhs) = delete;
   ~WsfPlatformPart() override;
 
   const int* GetComponentRoles() const override;
   void*      QueryInterface(int aRole) override;


   WsfStringId GetComponentName() const override { return GetNameId(); }
   void        ComponentParentChanged(WsfPlatform* aPlatformPtr) override
   {
      // Set the pointer AND call the SetPlatform. Some classes define SetPlatform so they get control
      // when ever the attachment is made. In particular, some of the script stuff needs to be set
      // as soon as possible so script compiles work. SetPlatform *should* set the pointer, but we do
      // it here just in case a derived method fails to call the base class version as they should.
      SetPlatform(aPlatformPtr);
      mPlatformPtr = aPlatformPtr;
   }



   bool         Initialize(double aSimTime) override;
   bool         Initialize2(double aSimTime) override;
   bool         ProcessInput(UtInput& aInput) override;
   virtual void Update(double aSimTime);



   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   virtual void SetPlatform(WsfPlatform* aPlatformPtr) { mPlatformPtr = aPlatformPtr; }


   virtual void PlatformAdded(double aSimTime, WsfPlatform* aPlatformPtr);
 
   virtual void PlatformDeleted(WsfPlatform* aPlatformPtr);



   double GetLastStatusChangeTime() const { return mLastStatusChangeTime; }

   void SetLastStatusChangeTime(double aSimTime) { mLastStatusChangeTime = aSimTime; }

   bool CanBeMadeOperational() const
   {
      return (!mIsOperational) && (mDamageFactor < 1.0) && (!mIsExternallyControlled);
   }

   bool CanBeMadeNonOperational() const { return mIsOperational && (!mIsExternallyControlled); }

   bool CanBeTurnedOn() const { return mIsOperational && (!mIsTurnedOn) && (!mIsExternallyControlled); }

   bool CanBeTurnedOff() const { return mIsTurnedOn && (!mIsExternallyControlled); }

   bool IsTurnedOn() const { return mIsTurnedOn; }

   bool InitiallyTurnedOn() const { return mInitiallyTurnedOn; }

   void SetInitiallyTurnedOn(bool aInitiallyTurnedOn) { mInitiallyTurnedOn = aInitiallyTurnedOn; }
 
   virtual void TurnOff(double aSimTime);
 
   virtual void TurnOn(double aSimTime);
 
   virtual void SetOperational(double aSimTime);
 
   virtual void SetNonOperational(double aSimTime);
 
   virtual void PartBroken(double aSimTime);
 
   virtual void Restore(double aSimTime);



   bool IsOperational() const { return mIsOperational; }
 
   bool SetOperational(double aSimTime, bool aMakeOperational);

   double GetDamageFactor() const { return mDamageFactor; }
 
   bool SetDamageFactor(double aSimTime, double aDamageFactor);

   bool IsCritical() const { return mIsCritical; }
 
   void SetCritical(bool aValue) { mIsCritical = aValue; }

   virtual void OnPlatformBrokenEvent(double aSimTime);

   bool IsBroken() const { return (mDamageFactor == 1.0) && (!mIsRestorable); }




   WsfInternalLinks& GetInternalLinks() { return mInternalLinks; }

   virtual bool HasInternalLinks() const { return mInternalLinks.HasLinks(); }
 
   virtual bool ProcessMessage(double aSimTime, const WsfMessage& aMessage);
 
   virtual bool ReceiveMessage(double aSimTime, const WsfMessage& aMessage);
 
#undef SendMessage // Avoid conflict with Windows macro
   virtual void SendMessage(double aSimTime, const WsfMessage& aMessage);


   virtual void SendMessageTo(double aSimTime, const WsfMessage& aMessage, WsfStringId aRecipientId);
 
   void SendMessageToProcessor(double aSimTime, const WsfMessage& aMessage, WsfStringId aRecipientId);
 
   virtual void SendQueuedMessages(double aSimTime);



   const WsfCategoryList& GetCategories() const { return mCategories; }

   void AddCategory(WsfStringId aCategoryId) { mCategories.JoinCategory(aCategoryId); }

   bool IsCategoryMember(WsfStringId aCategoryId) const { return mCategories.IsCategoryMember(aCategoryId); }



   const WsfGroupList& GetGroups() const { return mGroups; }
   void                JoinGroup(WsfGroup* aGroupPtr);
   void                LeaveGroup(WsfGroup* aGroupPtr);
   bool                IsGroupMember(WsfStringId aGroupId);



   virtual double GetUpdateInterval() const = 0;

   //{@
   virtual void SetUpdateInterval(double aUpdateInterval) = 0;

   unsigned int GetUpdateEventEpoch() const { return mUpdateEventEpoch; }

   void IncrementUpdateEventEpoch() { ++mUpdateEventEpoch; }

   bool UpdateEventActive() const { return mUpdateEventActive; }

   void SetUpdateEventActive(bool aUpdateEventActive) { mUpdateEventActive = aUpdateEventActive; }



   bool DebugEnabled() const { return mDebugEnabled; }
 
   void SetDebugEnabled(bool aDebugEnabled) { mDebugEnabled = aDebugEnabled; }
 
   unsigned int GetDebugMask() { return mDebugMask; }
 
   bool IsExternallyControlled() const { return mIsExternallyControlled; }
 
   virtual void SetExternallyControlled(double aSimTime, bool aIsExternallyControlled);
 
   int GetPartType() const { return mPartType; }
 
   const char* GetScriptClassName() const override;
 
   WsfSimulation* GetSimulation() const;
 
   const WsfScenario& GetScenario() const { return mScenario; }
 
protected:
   WsfPlatformPart(const WsfPlatformPart& aSrc);
 
private:
   int mPartType;

   const WsfScenario& mScenario;

   WsfPlatform* mPlatformPtr;

   WsfInternalLinks mInternalLinks;

   WsfCategoryList mCategories;

   WsfGroupList mGroups;

   double mLastStatusChangeTime;

   double mAutomaticRecoveryTime;

   double mDamageFactor;

   bool mIsCritical;

   bool mIsTurnedOn;

   bool mInitiallyTurnedOn;

   bool mIsOperational;

   bool mIsRestorable;

   bool mDebugEnabled;

   bool mIsExternallyControlled;

   bool mUpdateEventActive;

   unsigned int mDebugMask;

   unsigned int mUpdateEventEpoch;

   InternalMessageQueue mInternalMessageQueue;

   RecipientMessageQueue mRecipientMessageQueue;
 
   std::recursive_mutex mMutex;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfPlatformPart, cWSF_COMPONENT_PLATFORM_PART)
 
#endif