ryzom/server/src/ai_service/alias_tree_owner.h

   1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17
  18
  19 #ifndef _ALIAS_TREE_OWNER_
  20 #define _ALIAS_TREE_OWNER_
  21
  22 #include "ai_share/ai_types.h"
  23 #include "ai_share/ai_alias_description_node.h"
  24 #include "nel/misc/smart_ptr.h"
  25
  26 extern NLLIGO::CLigoConfig LigoConfig;
  27 class CAliasTreeOwner;
  28
  29 //////////////////////////////////////////////////////////////////////////////
  30 // IAliasCont                                                               //
  31 //////////////////////////////////////////////////////////////////////////////
  32
  33 class IAliasCont
  34 {
  35 public:
  36         virtual uint32                          size() const = 0;
  37         virtual void                            removeChildByAlias      (uint32 alias) = 0;
  38         virtual void                            removeChildByIndex      (uint32 index) = 0;
  39         virtual CAliasTreeOwner*        getAliasChildByAlias(uint32 alias) const = 0;
  40         virtual CAliasTreeOwner*        addAliasChild           (CAliasTreeOwner* child) = 0;
  41         virtual CAliasTreeOwner*        addAliasChild           (CAliasTreeOwner* child, uint32 index) = 0;
  42
  43         virtual ~IAliasCont() { }
  44 };
  45
  46 //////////////////////////////////////////////////////////////////////////////
  47 // CAliasTreeOwner                                                          //
  48 //////////////////////////////////////////////////////////////////////////////
  49
  50 class CAliasTreeOwner;
  51
  52 class CAliasTreeOwnerLocator
  53 {
  54 public:
  55         static CAliasTreeOwnerLocator* getInstance();
  56 private:
  57         CAliasTreeOwnerLocator() {}
  58         static CAliasTreeOwnerLocator* _Instance;
  59
  60 public:
  61         CAliasTreeOwner* getEntity(uint32 const alias) const;
  62         CAliasTreeOwner* getEntity(std::string const& name) const;
  63         void addEntity(uint32 const alias, std::string const& name, CAliasTreeOwner* entity);
  64         void delEntity(uint32 const alias, std::string const& name, CAliasTreeOwner* entity);
  65 private:
  66         std::map<uint32, CAliasTreeOwner*> _EntitiesByAlias;
  67         std::map<std::string, CAliasTreeOwner*> _EntitiesByName;
  68 };
  69
  70 class CAliasTreeOwner
  71 : public NLMISC::CDbgRefCount<CAliasTreeOwner>
  72 {
  73 public:
  74         class CAliasDiff
  75         {
  76         public:
  77                 CAliasDiff(uint32 alias);
  78                 virtual ~CAliasDiff() { }
  79                 bool operator ()(CAliasTreeOwner const* other) const;
  80                 uint32 _Alias;
  81         };
  82
  83 public:
  84         explicit CAliasTreeOwner(CAIAliasDescriptionNode* aliasTree);
  85         explicit CAliasTreeOwner(uint32 alias, std::string const& name);
  86         virtual ~CAliasTreeOwner();
  87
  88         /// @name Virtual interface
  89         //@{
  90         // obtain the container associated with this type.
  91         virtual IAliasCont* getAliasCont(AITYPES::TAIType type);
  92         // create a child with the specified alias node.
  93         virtual CAliasTreeOwner* createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree);
  94         // done to allow postprocess dependencies updates.
  95         virtual void updateDependencies(CAIAliasDescriptionNode const& aliasTree, CAliasTreeOwner* aliasTreeOwner);
  96         //@}
  97
  98         CAIAliasDescriptionNode* getAliasNode() const;
  99
 100         uint32 getAlias() const;
 101         std::string getAliasString() const;
 102
 103         std::string const& getName() const;
 104
 105         void setName(std::string const& name);
 106
 107         std::string getAliasFullName() const;
 108
 109         void updateAliasTree(CAIAliasDescriptionNode const& newTree);
 110         bool getCont(CAliasTreeOwner*& childOwner, IAliasCont*& cont, AITYPES::TAIType _type);
 111
 112         void pushCurrentOwnerList() { _CurrentOwnerList.push_back(this); }
 113         void popCurrentOwnerList() { _CurrentOwnerList.pop_back(); }
 114
 115 private:
 116         uint32          _Alias;
 117         std::string     _Name;
 118
 119         NLMISC::CSmartPtr<CAIAliasDescriptionNode> _AliasTree;
 120
 121         static std::vector<NLMISC::CDbgPtr<CAliasTreeOwner> > _CurrentOwnerList;
 122 };
 123
 124 /****************************************************************************/
 125 /* Inlined methods                                                          */
 126 /****************************************************************************/
 127
 128 //////////////////////////////////////////////////////////////////////////////
 129 // CAliasTreeOwner                                                          //
 130 //////////////////////////////////////////////////////////////////////////////
 131
 132 inline
 133 CAliasTreeOwner::CAliasDiff::CAliasDiff(uint32 alias)
 134 : _Alias(alias)
 135 {
 136 }
 137
 138 inline
 139 bool CAliasTreeOwner::CAliasDiff::operator()(CAliasTreeOwner const* other) const
 140 {
 141         return other->getAlias()!=_Alias;
 142 }
 143
 144 inline
 145 CAliasTreeOwner::CAliasTreeOwner(CAIAliasDescriptionNode* aliasTree)
 146 : _Alias(0)
 147 , _Name(std::string())
 148 , _AliasTree(aliasTree)
 149 {
 150         if (aliasTree)
 151         {
 152                 CAliasTreeOwnerLocator::getInstance()->addEntity(aliasTree->getAlias(), aliasTree->getName(), this);
 153         }
 154         else
 155         {
 156                 //DEBUG_STOP;
 157         }
 158 }
 159
 160 inline
 161 CAliasTreeOwner::CAliasTreeOwner(uint32 alias, std::string const& name)
 162 : _Alias(alias)
 163 , _Name(name)
 164 , _AliasTree(NULL)
 165 {
 166         CAliasTreeOwnerLocator::getInstance()->addEntity(_Alias, _Name, this);
 167 }
 168
 169 inline
 170 CAliasTreeOwner::~CAliasTreeOwner()
 171 {
 172         CAliasTreeOwnerLocator::getInstance()->delEntity(getAlias(), getName(), this);
 173 }
 174
 175 inline
 176 CAIAliasDescriptionNode* CAliasTreeOwner::getAliasNode() const
 177 {
 178         return _AliasTree;
 179 }
 180
 181 inline
 182 uint32 CAliasTreeOwner::getAlias() const
 183 {
 184         if (_AliasTree)
 185                 return _AliasTree->getAlias();
 186
 187         return _Alias;
 188 }
 189
 190 inline
 191 std::string CAliasTreeOwner::getAliasString() const
 192 {
 193         if (_AliasTree)
 194                 return LigoConfig.aliasToString(_AliasTree->getAlias());
 195
 196         return LigoConfig.aliasToString(_Alias);
 197 }
 198
 199 inline
 200 std::string const& CAliasTreeOwner::getName() const
 201 {
 202         if (_AliasTree)
 203                 return _AliasTree->getName();
 204
 205         return _Name;
 206 }
 207
 208 inline
 209 void CAliasTreeOwner::setName(std::string const& name)
 210 {
 211         // should be able to change the alias tree node name?
 212         if (_AliasTree)
 213         {
 214                 DEBUG_STOP;
 215                 return;
 216         }
 217
 218         CAliasTreeOwnerLocator::getInstance()->delEntity(_Alias, _Name, this);
 219         _Name = name;
 220         CAliasTreeOwnerLocator::getInstance()->addEntity(_Alias, _Name, this);
 221 }
 222
 223 inline
 224 std::string CAliasTreeOwner::getAliasFullName() const
 225 {
 226         if (_AliasTree)
 227                 return _AliasTree->fullName();
 228
 229         return getName(); // to upgrade...
 230 }
 231
 232 inline
 233 IAliasCont* CAliasTreeOwner::getAliasCont(AITYPES::TAIType type)
 234 {
 235         return NULL;
 236 }
 237
 238 inline
 239 CAliasTreeOwner* CAliasTreeOwner::createChild(IAliasCont* cont, CAIAliasDescriptionNode* aliasTree)
 240 {
 241         return NULL;
 242 }
 243
 244 inline
 245 void CAliasTreeOwner::updateDependencies(CAIAliasDescriptionNode const& aliasTree, CAliasTreeOwner* aliasTreeOwner)
 246 {
 247 }
 248
 249 #endif