ifIntersectionInformationResponse.h

Go to the documentation of this file.

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


#pragma once

#include <vrfExtProtocol/simInterfaceContent.h>
#include "vrfmsgs/vrfmsgsDefines.h"
#include "vrfmsgs/messageTypes.h"
#include "vrfutil/rwUUID.h"

#include <matrix/vlVector.h>


class DT_DLL_vrfmsgs DtIntersectionInformation
{
public:
   DtIntersectionInformation();

   DtIntersectionInformation(const DtIntersectionInformation&);

   virtual ~DtIntersectionInformation();

   DtIntersectionInformation& operator=(const DtIntersectionInformation&);

   virtual void setIntersectionPoint(const DtVector&);
   const DtVector& intersectionPoint() const
   {
      return myIntersectionPoint;
   }

   virtual void setIntersectionTime(double);
   double intersectionTime() const
   {
      return myIntersectionTime;
   }

   virtual void setSoilType(int mySoilType);
   bool soilTypeDefined() const
   {
      return mySoilTypeDefined;
   }

   int soilType() const
   {
      return mySoilType;
   }

   virtual void setEntityIntersected(const DtUUID&);
   const DtUUID& entityIntersected() const
   {
      return myEntityIntersected;
   }

   virtual void setStartPoint(const DtVector&);
   const DtVector& startPoint() const
   {
      return myStartPoint;
   }

   virtual void setEndPoint(const DtVector&);
   const DtVector& endPoint() const
   {
      return myEndPoint;
   }

   virtual void setUserData(const DtString&);
   const DtString& userData() const
   {
      return myUserData;
   }

   virtual char* setToNet(char* buffer) const;
   virtual const char* setFromNet(const char* buffer);
   virtual int netRepSize() const;

protected:
   DtVector myIntersectionPoint;
   DtVector myStartPoint;
   DtVector myEndPoint;
   DtString myUserData;
   double myIntersectionTime;
   bool mySoilTypeDefined;
   int mySoilType;      
   DtUUID myEntityIntersected;
};

namespace DtBufferSerialize
{
   DT_DLL_vrfmsgs int getSize(const DtIntersectionInformation&);
   DT_DLL_vrfmsgs const char* decode (DtIntersectionInformation&, const char*);
   DT_DLL_vrfmsgs char* encode(const DtIntersectionInformation&, char*);
}

class DT_DLL_vrfmsgs DtIfIntersectionInformationResponse : public DtSimInterfaceContent
{
public:
   typedef std::vector<DtIntersectionInformation> IntersectionInformation;
   typedef std::vector<IntersectionInformation> IntersectionPairInformation;

   DtIfIntersectionInformationResponse();

   DtIfIntersectionInformationResponse(const DtIfIntersectionInformationResponse & orig);

   const DtIfIntersectionInformationResponse & operator=(const DtIfIntersectionInformationResponse & orig);

   virtual ~DtIfIntersectionInformationResponse();

   virtual int type() const;

   virtual DtSimInterfaceContent* clone() const;

   virtual void printDataToString(DtString& str);

   static DtSimInterfaceContent* creator();

   virtual void setResponseId(unsigned long);
   unsigned long responseId() const
   {
      return myResponseId;
   }

   virtual void addIntersectionFor(int intersectionPairIndex, const DtIntersectionInformation&);
   virtual IntersectionInformation intersectionsFor(int intersectionPairIndex);
   int numResponses() const
   {
      return myIntersectionPairInformation.size();
   }

   virtual void setComplete(bool);
   bool complete() const
   {
      return myComplete;
   }

   virtual void setResponseSetSize(int size);

   const IntersectionPairInformation& intersectionPairInformation() const
   {
      return myIntersectionPairInformation;
   }

   IntersectionPairInformation& intersectionPairInformation()
   {
      return myIntersectionPairInformation;
   }

   virtual int netRepSize() const;
   virtual bool setFromNet(const char* contentBuffer, 
      unsigned contentSize);
   virtual bool setToNet();

protected:

   virtual int sizeOfContent() const;
   virtual char* setUncompressedToNet(char* buffer) const;
   virtual const char* setUncompressedFromNet(const char* contentBuffer);

protected:
   DtU32 myResponseId;
   IntersectionPairInformation myIntersectionPairInformation;
   bool myComplete;

   mutable DtU32 myUncompressedSize;
   mutable DtU32 myCompressedSize;
   mutable bool myCompressed;
   mutable const char* myCompressedBuffer;
};