entityMapperKey.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 1997 MaK Technologies, Inc.
** All rights reserved.
*********************************************************************/
/*********************************************************************
** $RCSfile: entityMapperKey.h,v $ $Revision: 1.2 $ $State: Exp $
*********************************************************************/


#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfExtProtocol/objectType.h>
#include <vlpi/entityType.h>
#include <string>

class DtEntityType;

namespace makVrf
{
   class DT_DLL_VRFGUICORE DtEntityMapperKey : public DtEntityType
   {
   public:

      static const int DtAnyMatch;

      DtEntityMapperKey();

      DtEntityMapperKey(const char* p);

      DtEntityMapperKey(const DtEntityType&, int force = -1);

      DtEntityMapperKey
      (
         int force,
         int kind,
         int domain,
         int country,
         int category,
         int subcategory,
         int specific,
         int extra
      );

      DtEntityMapperKey(int force, const DtEntityType&);

      DtEntityMapperKey(const DtEntityMapperKey& orig);

      virtual ~DtEntityMapperKey();

      DtEntityMapperKey& operator=(const DtEntityMapperKey& rhs);

      DtEntityMapperKey& operator=(const char* rhs);

      const std::string& string() const;

      int force() const {return myForce;}
      void setForce(int force){myForce = force;}

      static bool isIed(const DtEntityType& t) { return t.matchPattern(DtEntityType(2,2,0,3,1,1,-1)); };


      bool operator==(const DtEntityMapperKey& rhs) const;
      virtual bool matchPattern(const DtEntityMapperKey &pat) const;


      bool operator!=(const DtEntityMapperKey& rhs) const;


      bool operator<(const DtEntityMapperKey& rhs) const;


      bool operator>(const DtEntityMapperKey& rhs) const;

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

      operator DtObjectType() const;

      virtual bool exactMatch(const DtEntityMapperKey&) const;

   protected:

      mutable std::string myStringRep;
      int myForce;
   };

   inline int& DtEntityMapperKey::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 myForce;
      }

      return myForce;
   }

   inline const int DtEntityMapperKey::operator[](int i) const
   {
      switch (i)
      {
         case 0:
            return kind();
         case 1:
            return domain();
         case 2:
            return country();
         case 3:
            return category();
         case 4:
            return subCategory();
         case 5:
            return specific();
         case 6:
            return extra();
         case 7:
            return force();
      }

      return force();
   }
}