ryzom/client/src/r2/dmc/property_accessor.cpp

   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 #include "stdpch.h"
  18
  19 #include "property_accessor.h"
  20 #include "dmc.h"
  21 #include "game_share/object.h"
  22
  23 #include <assert.h>
  24
  25 #ifdef DEBUG_NEW
  26 #define new DEBUG_NEW
  27 #endif
  28
  29 using namespace R2;
  30
  31
  32
  33 CPropertyAccessor::~CPropertyAccessor()
  34 {
  35         purgeShadowedValues();
  36 }
  37
  38
  39 CObject* CPropertyAccessor::getPropertyValue(CObject* component, const std::string& attrName)
  40 {
  41         //H_AUTO(R2_CPropertyAccessor_getPropertyValue)
  42         return const_cast<CObject*>(getPropertyValue((const CObject *) component, attrName));
  43 }
  44
  45
  46 double CPropertyAccessor::getValueAsNumber(CObject* component, const std::string& attrName) const
  47 {
  48         //H_AUTO(R2_CPropertyAccessor_getValueAsNumber)
  49         const CObject* object=getPropertyValue((const CObject *) component, attrName);
  50         if (!object || !object->isNumber()) { return 0; }
  51         return object->toNumber();
  52 }
  53
  54 sint64 CPropertyAccessor::getValueAsInteger(CObject* component, const std::string& attrName) const
  55 {
  56         //H_AUTO(R2_CPropertyAccessor_getValueAsInteger)
  57         const CObject* object=getPropertyValue((const CObject *) component, attrName);
  58         if (!object || !object->isInteger()) { return 0; }
  59         return object->toInteger();
  60 }
  61
  62 bool CPropertyAccessor::hasValueInBase(CObject *component, const std::string& attrName)
  63 {
  64         //H_AUTO(R2_CPropertyAccessor_hasValueInBase)
  65         nlassert(component);
  66         if (attrName.empty()) return false;
  67         while (component)
  68         {
  69                 CObject *base = component->getAttr("Base");
  70                 if (!(base && base->isString())) break;
  71                 std::string strBase = base->toString();
  72                 component = _Client->getPaletteElement(strBase);
  73                 if (!component)
  74                 {
  75                         nlwarning("Can't find base palette element : name = %s", strBase.c_str());
  76                         break;
  77                 }
  78                 if (component->getAttr(attrName)) return true;
  79         }
  80         return false;
  81 }
  82
  83 const CObject *CPropertyAccessor::getPropertyValue(const CObject* componentParam, const std::string& attrName) const
  84 {
  85         //H_AUTO(R2_CPropertyAccessor_getPropertyValue)
  86         const CObject* component = componentParam;
  87         nlassert(component);
  88         const CObject* toRet = 0;
  89         const CObject* base = 0;
  90         const CObject* propClass = 0;
  91         const CObject* baseElement = 0;
  92         toRet = component->getAttr(attrName);
  93
  94
  95         // First look in base and in the base of its base and so and so
  96         baseElement = component;
  97         while (!toRet )
  98         {
  99
 100                 base = baseElement->getAttr("Base");
 101
 102                 if (base && base->isString())
 103                 {
 104
 105                         std::string strBase = base->toString();
 106
 107                         baseElement = _Client->getPaletteElement(strBase);
 108                         if (!baseElement)
 109                         {
 110                                 nlwarning("Can't find base palette element : name = %s", strBase.c_str());
 111                                 return NULL;
 112                         }
 113                         toRet = baseElement->getAttr(attrName);
 114                 }
 115                 else
 116                 {
 117                         break;  // no more base
 118                 }
 119
 120         }
 121
 122         // Look in baseClass then in baseClass of its BaseClass
 123
 124         baseElement = component;
 125         if (!toRet)
 126         {
 127                 propClass = baseElement->getAttr("Class");
 128                 if (propClass && propClass->isString())
 129                 {
 130                         std::string str = propClass->toString();
 131
 132
 133                         while (!toRet && !str.empty())
 134                         {
 135                                 CObjectGenerator* generator = _Factory->getGenerator(str);
 136
 137                                 if (!generator)
 138                                 {
 139                                         nlwarning("Can't find type : name = %s", str.c_str());
 140                                         return NULL;
 141                                 }
 142                                 toRet = generator->getDefaultValue(attrName);
 143                                 if (!toRet)
 144                                 {
 145                                         str = generator->getBaseClass();
 146                                 }
 147                                 else
 148                                 {
 149                                         str.clear();
 150                                 }
 151
 152                         }
 153                 }
 154         }
 155
 156
 157         if (toRet)
 158         {
 159                 // see if value is currently shadowed
 160                 for(std::vector<CShadowedValue>::const_iterator it = _ShadowedValues.begin(); it != _ShadowedValues.end(); ++it)
 161                 {
 162                         if (it->ShadowedValue == toRet)
 163                         {
 164                                 return it->LocalValue;
 165                         }
 166                 }
 167         }
 168         return toRet;
 169 }
 170
 171
 172 void CPropertyAccessor::getPropertyList(CObject* component, std::list<std::string>& propertyList)
 173 {
 174         //H_AUTO(R2_CPropertyAccessor_getPropertyList)
 175         std::list<std::string> sublist;
 176
 177         while (component)
 178         {
 179                 uint32 first = 0;
 180                 uint32 last = component->getSize();
 181
 182                 for ( ; first != last ; ++first)
 183                 {
 184                         std::list<std::string> props;
 185                         std::string key = component->getKey(first);
 186                         props.push_back(key);
 187                 }
 188                 propertyList.insert(sublist.begin(), sublist.end(), propertyList.begin());
 189
 190                 CObject* base = component->getAttr("base");
 191
 192                 if (base && base->isString())
 193                 {
 194                         component = _Client->getPaletteElement(base->toString());
 195                 }
 196                 else
 197                 {
 198                         component = 0;
 199                 }
 200         }
 201 }
 202
 203 void CPropertyAccessor::shadowValue(CObject *shadowedValue, CObject *localValue)
 204 {
 205         //H_AUTO(R2_CPropertyAccessor_shadowValue)
 206         if (!shadowedValue) return;
 207         purgeShadowedValues();
 208         for(uint k = 0; k < _ShadowedValues.size(); ++k)
 209         {
 210                 if (_ShadowedValues[k].ShadowedValue == shadowedValue)
 211                 {
 212                         // just replacing value for an already shadowed value
 213                         if (localValue != _ShadowedValues[k].LocalValue)
 214                         {
 215                                 delete _ShadowedValues[k].LocalValue;
 216                                 _ShadowedValues[k].LocalValue = localValue;
 217                         }
 218                         return;
 219                 }
 220         }
 221         // ... this is a new shadowed value
 222         CShadowedValue sv;
 223         sv.ShadowedValue = shadowedValue;
 224         sv.LocalValue = localValue;
 225         _ShadowedValues.push_back(sv);
 226 }
 227
 228 CObject *CPropertyAccessor::getShadowingValue(CObject *shadowedValue)
 229 {
 230         //H_AUTO(R2_CPropertyAccessor_getShadowingValue)
 231         if (!shadowedValue) return NULL;
 232         purgeShadowedValues();
 233         for(uint k = 0; k < _ShadowedValues.size(); ++k)
 234         {
 235                 if (_ShadowedValues[k].ShadowedValue == shadowedValue)
 236                 {
 237                         return _ShadowedValues[k].LocalValue;
 238                 }
 239         }
 240         return NULL;
 241 }
 242
 243
 244 void CPropertyAccessor::commitValue(CObject *shadowedValue)
 245 {
 246         //H_AUTO(R2_CPropertyAccessor_commitValue)
 247         for(uint k = 0; k < _ShadowedValues.size(); ++k)
 248         {
 249                 if (_ShadowedValues[k].ShadowedValue == shadowedValue)
 250                 {
 251                         // NB Nico : removed the local copy below because of the new 'instant feddback' mechanism
 252                         // plus, this introduced a bug where the server command was not sent (because new value & local
 253                         // value were equal)
 254
 255                         // copy local value to shadowed value
 256                         //_ShadowedValues[k].ShadowedValue->inPlaceCopy(*_ShadowedValues[k].LocalValue);
 257                         _ShadowedValues[k].ShadowedValue = NULL; // delete job done by purgeShadowedValues
 258                         break;
 259                 }
 260         }
 261         purgeShadowedValues();
 262 }
 263
 264 void CPropertyAccessor::rollbackValue(CObject *shadowedValue)
 265 {
 266         //H_AUTO(R2_CPropertyAccessor_rollbackValue)
 267         for(uint k = 0; k < _ShadowedValues.size(); ++k)
 268         {
 269                 if (_ShadowedValues[k].ShadowedValue == shadowedValue)
 270                 {
 271                         _ShadowedValues[k].ShadowedValue = NULL; // delete job done by purgeShadowedValues
 272                         break;
 273                 }
 274         }
 275         purgeShadowedValues();
 276 }
 277
 278
 279 struct CDeadShadowedObjectReferenceTest
 280 {
 281         bool operator()(const CPropertyAccessor::CShadowedValue &sw) const { return sw.ShadowedValue == NULL; }
 282 };
 283
 284 void CPropertyAccessor::purgeShadowedValues()
 285 {
 286         //H_AUTO(R2_CPropertyAccessor_purgeShadowedValues)
 287         for(uint k = 0; k < _ShadowedValues.size(); ++k)
 288         {
 289                 if (!_ShadowedValues[k].ShadowedValue)
 290                 {
 291                         delete _ShadowedValues[k].LocalValue;
 292                         _ShadowedValues[k].LocalValue = NULL;
 293                 }
 294         }
 295         _ShadowedValues.erase(std::remove_if(_ShadowedValues.begin(),   _ShadowedValues.end(), CDeadShadowedObjectReferenceTest()), _ShadowedValues.end());
 296 }
 297
 298
 299
 300
 301