rangedObjType.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2001 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: rangedObjType.h,v $ $Revision: 1.5 $ $State: Exp $
*******************************************************************************/

#ifndef DtRangedObjectType_H_
#define DtRangedObjectType_H_

#include <vrfExtProtocol/objType.h>

#include <vector>
#include <stdlib.h>

// class DtRangedObjectType:
//
// Instances of DtRangedObjectType are object types that can have ranges specified for
// any of the elements.  Use the DtRangedObjectTypeIterator to iterate through all the
// different types.

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

   // default constructor
   DtRangedObjectType();

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

   DtRangedObjectType(int superType, const DtEntityType & entityType);

   DtRangedObjectType(const char* superType, const char* kind, const char* domain, const char* country, 
      const char* category, const char* subCategory, const char* specific, const char* extra);

   DtRangedObjectType(const char* superType, const DtEntityType & entityType);

   // destructor
   virtual ~DtRangedObjectType();

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

   // assignment operator
   DtRangedObjectType& operator=(const DtRangedObjectType& orig);
   DtRangedObjectType& operator=(const DtObjectType& orig);

   // set/get the super type field.  Enumerations for this field are found
   // in objTypeEnums.h.
   void setRangedSuperType(const char*);
   const char* rangedSuperType() const;

   void setRangedKind(const char*);
   const char* rangedKind() const;

   void setRangedDomain(const char*);
   const char* rangedDomain() const;

   void setRangedCountry(const char*);
   const char* rangedCountry() const;

   void setRangedCategory(const char*);
   const char* rangedCategory() const;

   void setRangedSubCategory(const char*);
   const char* rangedSubCategory() const;

   void setRangedSpecific(const char*);
   const char* rangedSpecific() const;

   void setRangedExtra(const char*);
   const char* rangedExtra() const;

   // Returns a string representation of the object type.
   virtual const char *string() 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;

   virtual bool isRange(const char*) const;

   virtual std::vector<int> parseRange(const char*) const;

   bool isRange(int) const;

   DtString operator[](int) const;
   void setValue(int i, const DtString& value);

protected:
   // Will have length and be set only if item is actually a range.  Ranges can be specified either
   // by - or , (i.e. 5-10 or 6,17,9)
   DtString myElements[8];

   // Elements are of the following type
   // myRangedSuperType;
   // myRangedKind;
   // myRangedDomain;
   // myRangedCountry;
   // myRangedCategory;
   // myRangedSubcategory;
   // myRangedSpecific;
   // myRangedExtra;
};

class DtRangedObjectIterator
{
public:
   DtRangedObjectIterator(const DtRangedObjectType*);

   DtObjectType current() const;

   DtObjectType operator++() { return next(); };
   DtObjectType next();
   bool atEnd() const;

   // Returns false if all combinations of offsets have been used
   bool increaseOffsetsFrom(int);

protected:
   void createElementsAndOffsets();

protected:
   const DtRangedObjectType*        myObject;
   std::vector<int>                 myOffsets;
   std::vector<std::vector<int> >   myElements;
   bool                             myIsRangedObject;
   bool                             myAtEnd;
};

inline void DtRangedObjectType::setRangedSuperType(const char* s)
{
   if (isRange(s))
   {
      myElements[7] = s;
   }
   else if (s)
   {
      setSuperType(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedSuperType() const
{
   return myElements[7];
}

inline void DtRangedObjectType::setRangedKind(const char* s)
{
   if (isRange(s))
   {
      myElements[0] = s;
   }
   else if (s)
   {
      setKind(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedKind() const
{
   return myElements[0];
}

inline void DtRangedObjectType::setRangedDomain(const char* s)
{
   if (isRange(s))
   {
      myElements[1] = s;
   }
   else if (s)
   {
      setDomain(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedDomain() const
{
   return myElements[1];
}

inline void DtRangedObjectType::setRangedCountry(const char* s)
{
   if (isRange(s))
   {
      myElements[2] = s;
   }
   else if (s)
   {
      setCountry(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedCountry() const
{
   return myElements[2];
}

inline void DtRangedObjectType::setRangedCategory(const char* s)
{
   if (isRange(s))
   {
      myElements[3] = s;
   }
   else
   {
      setCategory(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedCategory() const
{
   return myElements[3];
}

inline void DtRangedObjectType::setRangedSubCategory(const char* s)
{
   if (isRange(s))
   {
      myElements[4] = s;
   }
   else
   {
      setSubCategory(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedSubCategory() const
{
   return myElements[4];
}

inline void DtRangedObjectType::setRangedSpecific(const char* s)
{
   if (isRange(s))
   {
      myElements[5] = s;
   }
   else
   {
      setSpecific(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedSpecific() const
{
   return myElements[5];
}

inline void DtRangedObjectType::setRangedExtra(const char* s)
{
   if (isRange(s))
   {
      myElements[6] = s;
   }
   else
   {
      setExtra(s ? atoi(s) : -1);
   }
}

inline const char* DtRangedObjectType::rangedExtra() const
{
   return myElements[6];
}

#endif