rangeItem.h

Go to the documentation of this file.

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

#pragma once

#include <vlpi/netStructs.h>
#include <vector>

// class DtRangeItem:
//
// Item that will define a range object used in the system

const int RangeItemUnknown = 0;
const int RangeItemBallisticGun = 1;
const int RangeItemIndirectFire = 2;
const int RangeItemMissileSystem = 3;
const int RangeItemRangeProperty = 4;
const int RangeItemSensorRange = 5;
const int RangeItemMaximumSensorRange = 6;
const int RangeItemGeneric = 7;

const int RangeRingVersion_V1 = 0;
const int RangeRingVersion_V2 = 100;
const int RangeRingVersion_V3 = 200;
const int RangeRingVersion = RangeRingVersion_V3; // current version
// const int RangeRingVersion = 300; // Future expansion

#include <vrfExtProtocol/vrfExtProtocolDefines.h>

// This corresponds to version 000
class DT_DLL_vrfExtProtocol DtRangeItem_V1
{
public:

   // default constructor
   DtRangeItem_V1();

   // destructor
   virtual ~DtRangeItem_V1();

   // copy constructor
   DtRangeItem_V1(const DtRangeItem_V1& orig);

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

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

   virtual int netRepSize() const;

   bool operator==(const DtRangeItem_V1& rhs) const
   {
      return ((myRange == rhs.myRange) &&
              (myType == rhs.myType) &&
              (myName == rhs.myName) &&
              (myOffsetPosition[0] == rhs.myOffsetPosition[0]) &&
              (myOffsetPosition[1] == rhs.myOffsetPosition[1]) &&
              (myOffsetPosition[2] == rhs.myOffsetPosition[2]));
   }

   DtNetFloat32 myRange;
   DtNetInt32 myType;
   DtNet64Vector myOffsetPosition;
   DtString myName;
};

// This corresponds to version 000
class DT_DLL_vrfExtProtocol DtRangeItems_V1
{
public:
   virtual ~DtRangeItems_V1();

   virtual int netRepSize() const;
   virtual char* setFromNet(const char* buffer);
   virtual char* setToNet(char* buffer) const;
 
   typedef std::vector<DtRangeItem_V1> RangeItems;

   RangeItems myRangeItems;
};

// This corresponds to version 100
class DT_DLL_vrfExtProtocol DtRangeItem_V2
{
public:

   // default constructor
   DtRangeItem_V2();

   // destructor
   virtual ~DtRangeItem_V2();

   // copy constructor
   DtRangeItem_V2(const DtRangeItem_V2& orig);
   DtRangeItem_V2(const DtRangeItem_V1& orig);

   // assignment operator
   DtRangeItem_V2& operator=(const DtRangeItem_V2& orig);
   DtRangeItem_V2& operator=(const DtRangeItem_V1& orig);

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

   virtual int netRepSize() const;

   bool operator==(const DtRangeItem_V2& rhs) const
   {
      return ((myRange == rhs.myRange) &&
              (myType == rhs.myType) &&
              (myName == rhs.myName) &&
              (myColor == rhs.myColor) &&
              (myWedgeSizes == rhs.myWedgeSizes) &&
              (myOffsetPosition[0] == rhs.myOffsetPosition[0]) &&
              (myOffsetPosition[1] == rhs.myOffsetPosition[1]) &&
              (myOffsetPosition[2] == rhs.myOffsetPosition[2]));
   }

   DtNetFloat32 myRange;
   DtNetInt32 myType;
   DtNet64Vector myOffsetPosition;
   DtString myName;

   DtNetInt32 myColor;
   std::vector<DtNetFloat32> myWedgeSizes;
};

// This corresponds to version 100
class DT_DLL_vrfExtProtocol DtRangeItems_V2
{
public:
   virtual ~DtRangeItems_V2();

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

   typedef std::vector<DtRangeItem_V2> RangeItems;

   RangeItems myRangeItems;
};

class DT_DLL_vrfExtProtocol DtRangeItem
{
public:

   // default constructor
   DtRangeItem();

   // destructor
   virtual ~DtRangeItem();

   // copy constructor
   DtRangeItem(const DtRangeItem& orig);
   DtRangeItem(const DtRangeItem_V2& orig);
   DtRangeItem(const DtRangeItem_V1& orig);

   // assignment operator
   DtRangeItem& operator=(const DtRangeItem& orig);
   DtRangeItem& operator=(const DtRangeItem_V2& orig);
   DtRangeItem& operator=(const DtRangeItem_V1& orig);

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

   virtual int netRepSize() const;

   bool operator==(const DtRangeItem& rhs) const
   {
      return ((myRange == rhs.myRange) &&
         (myType == rhs.myType) &&
         (myId == rhs.myId) &&
         (myColor == rhs.myColor) &&
         (myWedgeSizes == rhs.myWedgeSizes));
   }

   DtNetFloat32 myRange;
   DtNetInt16 myType;
   DtNetInt16 myId;

   DtNetInt32 myColor;
   std::vector<DtNetFloat32> myWedgeSizes;

   DtString myName;

   // Future expansion
   /*
   DtNetFloat32 myAzimuthCenter;
   DtNetFloat32 myAzimuthSweep;

   DtNetFloat32 myElevationCenter;
   DtNetFloat32 myElevationSweep;
   */
};

class DT_DLL_vrfExtProtocol DtRangeItems
{
public:
   virtual ~DtRangeItems();

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

   typedef std::vector<DtRangeItem> RangeItems;

   RangeItems myRangeItems;
};