objectType.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2013 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
#pragma once

#include <vlpi/entityType.h>

// class DtObjectType:
//
// Instances of DtObjectType are an extended form of DtEntityType objects.
// They extend the DIS/RPR entity type by having an additional enumerated
// field.  The new field represents a super-set of object types, e.g.
// individual, pseudo-aggregate, true-aggregate.  The remaining fields
// (kind, domain, country, category, subcateogy, specific, and extra) are
// unchanged.  In terms of comparisons and sorting, the most significant field
// is the the new field (super type).  The order of significance (in
// descreasing order) is as follows:
//
// <super type, kind, domain, country, category, subcategory, specific, extra>
//
// The standard wildcard value (-1, indicating a match of any) applies to the
// new field in the same way as for the fields in a standard entity type.
// Enumerations for the super type are found in objTypeEnums.h.

#include <vrfExtProtocol/vrfExtProtocolDefines.h>
class DT_DLL_vrfExtProtocol DtObjectType : public DtEntityType
{
public:

   // default constructor
   DtObjectType();

   DtObjectType(int superType, int kind, int domain, int country, 
      int category, int subCategory, int specific, int extra);

   DtObjectType(int superType, const DtEntityType & entityType);

   // destructor
   virtual ~DtObjectType();

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

   // assignment operator
   DtObjectType& operator=(const DtObjectType& orig);
   DtObjectType& operator=(const char* orig);

   // set/get the super type field.  Enumerations for this field are found
   // in objTypeEnums.h.
   virtual void setSuperType(int type);
   virtual int superType() const;

   // Returns a string representation of the object type.
   virtual const char *string(char sep = ':') const;

   // Returns 1 if object is prior to specified argument when in sorted 
   // order; returns false otherwise. Sorting is on multiple keys --
   // super type, kind, domain,  country, category, subcategory, specific, and 
   // extra, in that order.*/
   virtual int operator <(const DtObjectType &type) const;

   // Returns true if all fields either match exactly or with -1's.
   virtual bool matchPattern(const DtObjectType &pat) const;

   // == returns 1 if all fields are exactly equal, 0 if they are not equal 
   virtual int match(const DtObjectType &type) const;

   // == returns 1 if all fields are exactly equal, 0 if they are not equal 
   virtual int operator==(const DtObjectType &type) const;

   // != returns 0 if they are equal, nonzero if they are not equal 
   virtual int operator!=(const DtObjectType &type) const;

   int& operator[](int);
   const int operator[](int) const;

   bool hasWildCard() const;

public:


   //
   // Basic Types
   //

   // Returns a type consisting of fields set all to zeros.
   static const DtObjectType & nullType();

   // Returns a type consisting of fields set all to -1s.
   static const DtObjectType & anyType();

   // Returns a type representing an generic individual object
   static const DtObjectType & individualType();

   // Returns a type representing an generic aggregate object
   static const DtObjectType & aggregateType();

   // Returns a type representing an generic pseudo-aggregate object
   static const DtObjectType & pseudoAggregateType();

   // Returns a type representing an generic individual lifeform object
   static const DtObjectType & individualLifeformType();

   // Returns a type representing an individual platform object
   static const DtObjectType & individualPlatformType();

   // Returns a type representing an individual cultural feature object
   static const DtObjectType & individualCulturalFeatureType();

   // Returns a type representing an individual munition object
   static const DtObjectType & individualMunitionType();
  

   //
   // Graphic Object / Control Object Types
   //

   // Returns a type representing a text object
   static const DtObjectType & textType();
   
   // Returns a type representing a marker object
   static const DtObjectType & markerType();

   // Returns a type representing an control point object
   static const DtObjectType & controlPointType();

   // Returns a type representing a route object
   static const DtObjectType & routeType();
   
   // Returns a type representing a control area object
   static const DtObjectType & controlAreaType();
   
   // Returns a type representing a obstacle object
   static const DtObjectType & obstacleType();
   
   // Returns a type representing a disaggregation area object
   static const DtObjectType & disaggregationAreaType();

   // Returns a type representing a phase line object
   static const DtObjectType & phaseLineType();
   
protected:

   int mySuperType;
};


inline int& DtObjectType::operator[](int i)
{
   switch (i)
   {
      case 0:
         return DtEntityKind;
      case 1:
         return DtDomain;
      case 2:
         return DtCountry;
      case 3:
         return DtCategory;
      case 4:
         return DtSubCategory;
      case 5:
         return DtSpecific;
      case 6:
         return DtExtra;
      case 7:
         return mySuperType;
   }

   return mySuperType;
}

inline bool DtObjectType::hasWildCard() const
{
   for (int i = 0; i < 7; i++)
   {
      if ((*this)[i] == -1)
      {
         return true;
      }
   }

   return false;
}

inline const int DtObjectType::operator[](int i) const
{
   switch (i)
   {
      case 0:
         return DtEntityKind;
      case 1:
         return DtDomain;
      case 2:
         return DtCountry;
      case 3:
         return DtCategory;
      case 4:
         return DtSubCategory;
      case 5:
         return DtSpecific;
      case 6:
         return DtExtra;
      case 7:
         return mySuperType;
   }

   return mySuperType;
}