Set Encumbrance Request

The DtSetEncumbranceRequest is a new class that can be used to send an encumbrance value to DtManualRotaryWingEncumberedFlightActuator.

---

Header file:

/*******************************************************************************
** Copyright (c) 2016 VT MAK, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrftasks/setDataRequest.h"
#include <vlpi/netStructs.h>
#include <readerWriter/rwReal.h>
#include "vrftasks/radioMessageTypes.h"

namespace vrfAddSetEncumbranceExample
{
   //class DtSetEncumbranceRequest:
   //
   //Instances of DtSetEncumbrance send a payload mass value to DtManualRotaryWingEncumberedFlightActuator.

   //DtSetEncumbranceString must be a unique string representing the set 
   //(existing string types are defined in msgTypes.h).
   const DtSetMessageType DtSetEncumbranceType("set-encumbrance");

   //DtSetEncumbranceMenuItemIdName must be a unique string identifying the 
   //DtSetEncumbranceMenuItem object, which inherits from DtVrfTaskSetMenuItem
   const char DtSetEncumbranceMenuItemIdName[] = "DtSetEncumbranceMenuItem";

   class DtSetEncumbranceRequest : public DtSetDataRequest
   {

   public:

         //default constructor
      DtSetEncumbranceRequest();

         //constructor; 
         //If you have a request 'put' itself, the writeName will preface it.
      DtSetEncumbranceRequest(const DtString & writeName, 
         DtReaderWriterRegistry * parentRegistry = 0);

         //copy constructor
      DtSetEncumbranceRequest(const DtString & writeName, const DtSetEncumbranceRequest &
         orig, DtReaderWriterRegistry * parentRegistry = 0);

         //assignment operator
      const DtSetEncumbranceRequest & operator=(const DtSetEncumbranceRequest & orig);

      virtual ~DtSetEncumbranceRequest();

         //Returns DtSetEncumbranceRequestType.
      virtual const DtSetMessageType& type() const;

         //Creates a copy of the request.
      virtual DtSetDataRequest * clone(const DtString & name, 
         DtReaderWriterRegistry * parentRegistry = 0) const;

         //Get a readable string representation of this setDataRequest.
      virtual DtString stringRep() const;

      virtual DtReal encumbrance() const;
      virtual void setEncumbrance(DtReal kgs);

      //Returns the size of the full network representation 
      //padded to an 8-byte boundary.
      virtual int netRepSize() const;

      //Fills in the task from the network buffer.
      virtual bool setFromNet(const char* contentBuffer, 
         unsigned contentSize);

      //Fills in the network buffer (created by base class setDataRequest) with 
      //the set data request contents.
      virtual bool setToNet();

      static DtSetDataRequest * creator();

   protected:

      DtRwReal myEncumbrance;
   };
}

---

Implementation:

/*******************************************************************************
** Copyright (c) 2016 VT MAK, Inc.
** All rights reserved.
*******************************************************************************/



#include <math.h>
#include <readerWriter/bufferSerialize.h>
#include "../addSetEncumbranceSim/setEncumbranceRequest.h"

namespace vrfAddSetEncumbranceExample
{
   //default constructor
   DtSetEncumbranceRequest::DtSetEncumbranceRequest()
   : DtSetDataRequest()
   , myEncumbrance("encumbrance", &myRegistry)
   {
      myEncumbrance = 0.0;
   }

   //constructor
   //if you have a task 'put' itself, the writeName will preface the task.
   DtSetEncumbranceRequest::DtSetEncumbranceRequest(const DtString & writeName, 
      DtReaderWriterRegistry * parentRegistry) 
   : DtSetDataRequest(writeName, parentRegistry)
   , myEncumbrance("encumbrance", &myRegistry)
   {
      myEncumbrance = 0.0;
   }

   //copy constructor
   DtSetEncumbranceRequest::DtSetEncumbranceRequest(const DtString & writeName, const 
   DtSetEncumbranceRequest & orig, DtReaderWriterRegistry * parentRegistry) 
   : DtSetDataRequest(writeName, orig, parentRegistry)
   , myEncumbrance(orig.myEncumbrance.name(), &myRegistry)
   {
      myEncumbrance = orig.myEncumbrance;
   }

   //assignment operator
   const DtSetEncumbranceRequest & DtSetEncumbranceRequest::operator=(const DtSetEncumbranceRequest & orig)
   {
      if (this == & orig)
      {
         return *this;
      }

      myEncumbrance = orig.myEncumbrance;

      return *this;
   }

   DtSetEncumbranceRequest::~DtSetEncumbranceRequest()
   {
   }

   const DtSetMessageType& DtSetEncumbranceRequest::type() const
   {
      return DtSetEncumbranceType;
   }

   DtSetDataRequest * DtSetEncumbranceRequest::clone(const DtString & name, 
      DtReaderWriterRegistry * parentRegistry) const
   {
      return new DtSetEncumbranceRequest(name, *this, parentRegistry);
   }

   //Get a readable string representation of this setDataRequest.
   DtString DtSetEncumbranceRequest::stringRep() const
   {
      DtString str = trUtf8("Set Encumbrance=", "DtSetEncumbranceRequest");
      char valueBuff[128];
      sprintf(valueBuff, "%g kg", myEncumbrance.value());

      str += valueBuff;

      return str;
   }

   DtReal DtSetEncumbranceRequest::encumbrance() const
   {
      return myEncumbrance;
   }

   void DtSetEncumbranceRequest::setEncumbrance(DtReal kgs)
   {
      myEncumbrance = kgs;
   }

   DtSetDataRequest * DtSetEncumbranceRequest::creator()
   {
      return new DtSetEncumbranceRequest();
   }

   //returns the size of the full network representation (control object name
   //included) padded to an 8-byte boundary.
   int DtSetEncumbranceRequest::netRepSize() const
   {
      int size = 0;
      size += DtBufferSerialize::getSize(myEncumbrance);
      return size;
   }

   //Fills in the task from the network buffer
   bool DtSetEncumbranceRequest::setFromNet(const char* contentBuffer, 
   unsigned contentSize)
   {
      contentBuffer = DtBufferSerialize::decode(myEncumbrance, contentBuffer);
      return true;
   }

   //Fills in the network buffer (created by base class simTask) with the
   //task contents.
   bool DtSetEncumbranceRequest::setToNet()
   {
      if (!netRep())
      {
         return false;
      }
      char* contentBuffer = netRep();
      contentBuffer = DtBufferSerialize::encode(myEncumbrance, contentBuffer);
      return true;
   }
}