Code/CryEngine/CrySchematyc2/Env/EnvRegistry.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 // #SchematycTODO : Replace CRY_ASSERT with SCHEMATYC2_SYSTEM_ASSERT.
   4
   5 #include "StdAfx.h"
   6 #include "EnvRegistry.h"
   7
   8 #include <CrySerialization/IArchiveHost.h>
   9 #include <CrySchematyc2/IActionFactory.h>
  10 #include <CrySchematyc2/IComponentFactory.h>
  11 #include <CrySchematyc2/EnvTypeDesc.h>
  12 #include <CrySchematyc2/Deprecated/IGlobalFunction.h>
  13 #include <CrySchematyc2/Env/IEnvFunctionDescriptor.h>
  14
  15 #include "AbstractInterface.h"
  16 #include "Foundation.h"
  17 #include "Signal.h"
  18
  19 namespace Schematyc2
  20 {
  21         //////////////////////////////////////////////////////////////////////////
  22         bool CEnvRegistry::RegisterTypeDesc(const IEnvTypeDescPtr& pTypeDesc)
  23         {
  24                 CRY_ASSERT(pTypeDesc);
  25                 if(pTypeDesc)
  26                 {
  27                         const EnvTypeId id = pTypeDesc->GetEnvTypeId();
  28                         const SGUID     guid = pTypeDesc->GetGUID();
  29                         CRY_ASSERT((id != GetEnvTypeId<void>()) && guid);
  30                         if((id != GetEnvTypeId<void>()) && guid)
  31                         {
  32                                 if(!GetTypeDesc(id) && !GetTypeDesc(guid))
  33                                 {
  34                                         m_typeDescsById.insert(TypeDescByIdMap::value_type(id, pTypeDesc));
  35                                         m_typeDescsByGUID.insert(TypeDescByGUIDMap::value_type(guid, pTypeDesc));
  36                                         return true;
  37                                 }
  38                         }
  39                 }
  40                 return false;
  41         }
  42
  43         //////////////////////////////////////////////////////////////////////////
  44         const IEnvTypeDesc* CEnvRegistry::GetTypeDesc(const EnvTypeId& id) const
  45         {
  46                 TypeDescByIdMap::const_iterator itTypeDesc = m_typeDescsById.find(id);
  47                 return itTypeDesc != m_typeDescsById.end() ? itTypeDesc->second.get() : nullptr;
  48         }
  49
  50         //////////////////////////////////////////////////////////////////////////
  51         const IEnvTypeDesc* CEnvRegistry::GetTypeDesc(const SGUID& guid) const
  52         {
  53                 TypeDescByGUIDMap::const_iterator itTypeDesc = m_typeDescsByGUID.find(guid);
  54                 return itTypeDesc != m_typeDescsByGUID.end() ? itTypeDesc->second.get() : nullptr;
  55         }
  56
  57         //////////////////////////////////////////////////////////////////////////
  58         void CEnvRegistry::VisitTypeDescs(const EnvTypeDescVisitor& visitor) const
  59         {
  60                 CRY_ASSERT(visitor);
  61                 if(visitor)
  62                 {
  63                         for(const TypeDescByIdMap::value_type& typeDesc : m_typeDescsById)
  64                         {
  65                                 if(visitor(*typeDesc.second) != EVisitStatus::Continue)
  66                                 {
  67                                         break;
  68                                 }
  69                         }
  70                 }
  71         }
  72
  73         //////////////////////////////////////////////////////////////////////////
  74         ISignalPtr CEnvRegistry::CreateSignal(const SGUID& guid)
  75         {
  76                 if(GetSignal(guid) == NULL)
  77                 {
  78                         ISignalPtr      pSignal(new CSignal(guid));
  79                         m_signals.insert(TSignalMap::value_type(guid, pSignal));
  80                         return pSignal;
  81                 }
  82                 return ISignalPtr();
  83         }
  84
  85         //////////////////////////////////////////////////////////////////////////
  86         ISignalConstPtr CEnvRegistry::GetSignal(const SGUID& guid) const
  87         {
  88                 TSignalMap::const_iterator      iSignal = m_signals.find(guid);
  89                 return iSignal != m_signals.end() ? iSignal->second : ISignalConstPtr();
  90         }
  91
  92         //////////////////////////////////////////////////////////////////////////
  93         void CEnvRegistry::VisitSignals(const EnvSignalVisitor& visitor) const
  94         {
  95                 CRY_ASSERT(visitor);
  96                 if(visitor)
  97                 {
  98                         for(TSignalMap::const_iterator iSignal = m_signals.begin(), iEndSignal = m_signals.end(); iSignal != iEndSignal; ++ iSignal)
  99                         {
 100                                 if(visitor(iSignal->second) != EVisitStatus::Continue)
 101                                 {
 102                                         break;
 103                                 }
 104                         }
 105                 }
 106         }
 107
 108         //////////////////////////////////////////////////////////////////////////
 109         bool CEnvRegistry::RegisterGlobalFunction(const IGlobalFunctionPtr& pFunction)
 110         {
 111                 CRY_ASSERT(pFunction != NULL);
 112                 if(pFunction != NULL)
 113                 {
 114                         const SGUID     guid = pFunction->GetGUID();
 115                         CRY_ASSERT(guid);
 116                         if(guid && !GetGlobalFunction(guid))
 117                         {
 118                                 m_globalFunctions.insert(TGlobalFunctionMap::value_type(guid, pFunction));
 119                                 return true;
 120                         }
 121                 }
 122                 return false;
 123         }
 124
 125         //////////////////////////////////////////////////////////////////////////
 126         IGlobalFunctionConstPtr CEnvRegistry::GetGlobalFunction(const SGUID& guid) const
 127         {
 128                 TGlobalFunctionMap::const_iterator      iGlobalFunction = m_globalFunctions.find(guid);
 129                 return iGlobalFunction != m_globalFunctions.end() ? iGlobalFunction->second : IGlobalFunctionConstPtr();
 130         }
 131
 132         //////////////////////////////////////////////////////////////////////////
 133         void CEnvRegistry::VisitGlobalFunctions(const EnvGlobalFunctionVisitor& visitor) const
 134         {
 135                 CRY_ASSERT(visitor);
 136                 if(visitor)
 137                 {
 138                         for(TGlobalFunctionMap::const_iterator iGlobalFunction = m_globalFunctions.begin(), iEndGlobalFunction = m_globalFunctions.end(); iGlobalFunction != iEndGlobalFunction; ++ iGlobalFunction)
 139                         {
 140                                 if(visitor(iGlobalFunction->second) != EVisitStatus::Continue)
 141                                 {
 142                                         break;
 143                                 }
 144                         }
 145                 }
 146         }
 147
 148         //////////////////////////////////////////////////////////////////////////
 149         void CEnvRegistry::RegisterFunction(const IEnvFunctionDescriptorPtr& pFunctionDescriptor)
 150         {
 151                 SCHEMATYC2_SYSTEM_ASSERT_FATAL(pFunctionDescriptor);
 152                 const SGUID guid = pFunctionDescriptor->GetGUID();
 153                 SCHEMATYC2_SYSTEM_ASSERT_FATAL(!GetFunction(guid));
 154                 m_functions.insert(Functions::value_type(guid, pFunctionDescriptor));
 155         }
 156
 157         //////////////////////////////////////////////////////////////////////////
 158         const IEnvFunctionDescriptor* CEnvRegistry::GetFunction(const SGUID& guid) const
 159         {
 160                 Functions::const_iterator itFunction = m_functions.find(guid);
 161                 return itFunction != m_functions.end() ? itFunction->second.get() : nullptr;
 162         }
 163
 164         //////////////////////////////////////////////////////////////////////////
 165         void CEnvRegistry::VisitFunctions(const EnvFunctionVisitor& visitor) const
 166         {
 167                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 168                 if(visitor)
 169                 {
 170                         for(const Functions::value_type& function : m_functions)
 171                         {
 172                                 if(visitor(*function.second) != EVisitStatus::Continue)
 173                                 {
 174                                         break;
 175                                 }
 176                         }
 177                 }
 178         }
 179
 180         //////////////////////////////////////////////////////////////////////////
 181         IFoundationPtr CEnvRegistry::CreateFoundation(const SGUID& guid, const char* name)
 182         {
 183                 if(GetFoundation(guid) == NULL)
 184                 {
 185                         IFoundationPtr  pFoundation(new CFoundation(guid, name));
 186                         m_foundations.insert(TFoundationMap::value_type(guid, pFoundation));
 187                         return pFoundation;
 188                 }
 189                 return IFoundationPtr();
 190         }
 191
 192         //////////////////////////////////////////////////////////////////////////
 193         IFoundationConstPtr CEnvRegistry::GetFoundation(const SGUID& guid) const
 194         {
 195                 TFoundationMap::const_iterator itFoundation = m_foundations.find(guid);
 196                 return itFoundation != m_foundations.end() ? itFoundation->second : IFoundationConstPtr();
 197         }
 198
 199         //////////////////////////////////////////////////////////////////////////
 200         void CEnvRegistry::VisitFoundations(const EnvFoundationVisitor& visitor, EVisitFlags flags) const
 201         {
 202                 SCHEMATYC2_SYSTEM_ASSERT(visitor);
 203                 if(visitor)
 204                 {
 205                         for(const TFoundationMap::value_type& foundation : m_foundations)
 206                         {
 207                                 if(((flags & EVisitFlags::IgnoreBlacklist) != 0) || !IsBlacklistedElement(foundation.first))
 208                                 {
 209                                         if(visitor(foundation.second) != EVisitStatus::Continue)
 210                                         {
 211                                                 break;
 212                                         }
 213                                 }
 214                         }
 215                 }
 216         }
 217
 218         //////////////////////////////////////////////////////////////////////////
 219         IAbstractInterfacePtr CEnvRegistry::CreateAbstractInterface(const SGUID& guid)
 220         {
 221                 return IAbstractInterfacePtr(new CAbstractInterface(guid));
 222         }
 223
 224         //////////////////////////////////////////////////////////////////////////
 225         bool CEnvRegistry::RegisterAbstractInterface(const IAbstractInterfacePtr& pAbstractInterface)
 226         {
 227                 CRY_ASSERT(pAbstractInterface);
 228                 if(pAbstractInterface)
 229                 {
 230                         const SGUID     guid = pAbstractInterface->GetGUID();
 231                         CRY_ASSERT(guid);
 232                         if(guid && !GetAbstractInterface(guid))
 233                         {
 234                                 bool                                    error = false;
 235                                 const size_t    functionCount = pAbstractInterface->GetFunctionCount();
 236                                 for(size_t iFunction = 0; iFunction < functionCount; ++ iFunction)
 237                                 {
 238                                         IAbstractInterfaceFunctionConstPtr      pFunction = pAbstractInterface->GetFunction(iFunction);
 239                                         if(!pFunction || GetAbstractInterfaceFunction(pAbstractInterface->GetFunction(iFunction)->GetGUID()) || (pFunction->GetOwnerGUID() != guid))
 240                                         {
 241                                                 error = true;
 242                                                 break;
 243                                         }
 244                                 }
 245                                 if(!error)
 246                                 {
 247                                         m_abstractInterfaces.insert(TAbstractInterfaceMap::value_type(guid, pAbstractInterface));
 248                                         for(size_t iFunction = 0; iFunction < functionCount; ++ iFunction)
 249                                         {
 250                                                 IAbstractInterfaceFunctionConstPtr      pFunction = pAbstractInterface->GetFunction(iFunction);
 251                                                 m_abstractInterfaceFunctions.insert(TAbstractInterfaceFunctionMap::value_type(pFunction->GetGUID(), pFunction));
 252                                         }
 253                                         return true;
 254                                 }
 255                         }
 256                 }
 257                 return false;
 258         }
 259
 260         //////////////////////////////////////////////////////////////////////////
 261         IAbstractInterfaceConstPtr CEnvRegistry::GetAbstractInterface(const SGUID& guid) const
 262         {
 263                 TAbstractInterfaceMap::const_iterator   iAbstractInterface = m_abstractInterfaces.find(guid);
 264                 return iAbstractInterface != m_abstractInterfaces.end() ? iAbstractInterface->second : IAbstractInterfaceConstPtr();
 265         }
 266
 267         //////////////////////////////////////////////////////////////////////////
 268         void CEnvRegistry::VisitAbstractInterfaces(const EnvAbstractInterfaceVisitor& visitor) const
 269         {
 270                 CRY_ASSERT(visitor);
 271                 if(visitor)
 272                 {
 273                         for(TAbstractInterfaceMap::const_iterator iAbstractInterface = m_abstractInterfaces.begin(), iEndAbstractInterface = m_abstractInterfaces.end(); iAbstractInterface != iEndAbstractInterface; ++ iAbstractInterface)
 274                         {
 275                                 if(visitor(iAbstractInterface->second) != EVisitStatus::Continue)
 276                                 {
 277                                         break;
 278                                 }
 279                         }
 280                 }
 281         }
 282
 283         //////////////////////////////////////////////////////////////////////////
 284         IAbstractInterfaceFunctionConstPtr CEnvRegistry::GetAbstractInterfaceFunction(const SGUID& guid) const
 285         {
 286                 TAbstractInterfaceFunctionMap::const_iterator   iFunction = m_abstractInterfaceFunctions.find(guid);
 287                 return iFunction != m_abstractInterfaceFunctions.end() ? iFunction->second : IAbstractInterfaceFunctionConstPtr();
 288         }
 289
 290         //////////////////////////////////////////////////////////////////////////
 291         void CEnvRegistry::VisitAbstractInterfaceFunctions(const EnvAbstractInterfaceFunctionVisitor& visitor) const
 292         {
 293                 CRY_ASSERT(visitor);
 294                 if(visitor)
 295                 {
 296                         for(TAbstractInterfaceFunctionMap::const_iterator iFunction = m_abstractInterfaceFunctions.begin(), iEndFunction = m_abstractInterfaceFunctions.end(); iFunction != iEndFunction; ++ iFunction)
 297                         {
 298                                 if(visitor(iFunction->second) != EVisitStatus::Continue)
 299                                 {
 300                                         break;
 301                                 }
 302                         }
 303                 }
 304         }
 305
 306         //////////////////////////////////////////////////////////////////////////
 307         bool CEnvRegistry::RegisterComponentFactory(const IComponentFactoryPtr& pComponentFactory)
 308         {
 309                 CRY_ASSERT(pComponentFactory != NULL);
 310                 if(pComponentFactory != NULL)
 311                 {
 312                         const SGUID     guid = pComponentFactory->GetComponentGUID();
 313                         CRY_ASSERT(guid);
 314                         if(guid && !GetComponentFactory(guid))
 315                         {
 316                                 m_componentFactories.insert(TComponentFactoryMap::value_type(guid, pComponentFactory));
 317                                 return true;
 318                         }
 319                 }
 320                 return false;
 321         }
 322
 323         //////////////////////////////////////////////////////////////////////////
 324         IComponentFactoryConstPtr CEnvRegistry::GetComponentFactory(const SGUID& guid) const
 325         {
 326                 TComponentFactoryMap::const_iterator iComponentFactory = m_componentFactories.find(guid);
 327                 return iComponentFactory != m_componentFactories.end() ? iComponentFactory->second : IComponentFactoryConstPtr();
 328         }
 329
 330         //////////////////////////////////////////////////////////////////////////
 331         void CEnvRegistry::VisitComponentFactories(const EnvComponentFactoryVisitor& visitor) const
 332         {
 333                 CRY_ASSERT(visitor);
 334                 if(visitor)
 335                 {
 336                         for(TComponentFactoryMap::const_iterator iComponentFactory = m_componentFactories.begin(), iEndComponentFactory = m_componentFactories.end(); iComponentFactory != iEndComponentFactory; ++ iComponentFactory)
 337                         {
 338                                 if(visitor(iComponentFactory->second) != EVisitStatus::Continue)
 339                                 {
 340                                         break;
 341                                 }
 342                         }
 343                 }
 344         }
 345
 346         //////////////////////////////////////////////////////////////////////////
 347         bool CEnvRegistry::RegisterComponentMemberFunction(const IComponentMemberFunctionPtr& pFunction)
 348         {
 349                 CRY_ASSERT(pFunction != NULL);
 350                 if(pFunction != NULL)
 351                 {
 352                         const SGUID     guid = pFunction->GetGUID();
 353                         CRY_ASSERT(guid);
 354                         if(guid && !GetComponentMemberFunction(guid))
 355                         {
 356                                 m_componentMemberFunctions.insert(TComponentMemberFunctionMap::value_type(guid, pFunction));
 357                                 return true;
 358                         }
 359                 }
 360                 return false;
 361         }
 362
 363         //////////////////////////////////////////////////////////////////////////
 364         IComponentMemberFunctionConstPtr CEnvRegistry::GetComponentMemberFunction(const SGUID& guid) const
 365         {
 366                 TComponentMemberFunctionMap::const_iterator     iComponentMemberFunction = m_componentMemberFunctions.find(guid);
 367                 return iComponentMemberFunction != m_componentMemberFunctions.end() ? iComponentMemberFunction->second : IComponentMemberFunctionConstPtr();
 368         }
 369
 370         //////////////////////////////////////////////////////////////////////////
 371         void CEnvRegistry::VisitComponentMemberFunctions(const EnvComponentMemberFunctionVisitor& visitor) const
 372         {
 373                 CRY_ASSERT(visitor);
 374                 if(visitor)
 375                 {
 376                         for(TComponentMemberFunctionMap::const_iterator iComponentMemberFunction = m_componentMemberFunctions.begin(), iEndComponentMemberFunction = m_componentMemberFunctions.end(); iComponentMemberFunction != iEndComponentMemberFunction; ++ iComponentMemberFunction)
 377                         {
 378                                 if(visitor(iComponentMemberFunction->second) != EVisitStatus::Continue)
 379                                 {
 380                                         break;
 381                                 }
 382                         }
 383                 }
 384         }
 385
 386         //////////////////////////////////////////////////////////////////////////
 387         bool CEnvRegistry::RegisterActionFactory(const IActionFactoryPtr& pActionFactory)
 388         {
 389                 CRY_ASSERT(pActionFactory != NULL);
 390                 if(pActionFactory != NULL)
 391                 {
 392                         const SGUID     guid = pActionFactory->GetActionGUID();
 393                         CRY_ASSERT(guid);
 394                         if(guid && !GetActionFactory(guid))
 395                         {
 396                                 m_actionFactories.insert(TActionFactoryMap::value_type(guid, pActionFactory));
 397                                 return true;
 398                         }
 399                 }
 400                 return false;
 401         }
 402
 403         //////////////////////////////////////////////////////////////////////////
 404         IActionFactoryConstPtr CEnvRegistry::GetActionFactory(const SGUID& guid) const
 405         {
 406                 TActionFactoryMap::const_iterator iActionFactory = m_actionFactories.find(guid);
 407                 return iActionFactory != m_actionFactories.end() ? iActionFactory->second : IActionFactoryConstPtr();
 408         }
 409
 410         //////////////////////////////////////////////////////////////////////////
 411         void CEnvRegistry::VisitActionFactories(const EnvActionFactoryVisitor& visitor) const
 412         {
 413                 CRY_ASSERT(visitor);
 414                 if(visitor)
 415                 {
 416                         for(TActionFactoryMap::const_iterator iActionFactory = m_actionFactories.begin(), iEndActionFactory = m_actionFactories.end(); iActionFactory != iEndActionFactory; ++ iActionFactory)
 417                         {
 418                                 if(visitor(iActionFactory->second) != EVisitStatus::Continue)
 419                                 {
 420                                         break;
 421                                 }
 422                         }
 423                 }
 424         }
 425
 426         //////////////////////////////////////////////////////////////////////////
 427         bool CEnvRegistry::RegisterActionMemberFunction(const IActionMemberFunctionPtr& pFunction)
 428         {
 429                 CRY_ASSERT(pFunction != NULL);
 430                 if(pFunction != NULL)
 431                 {
 432                         const SGUID     guid = pFunction->GetGUID();
 433                         CRY_ASSERT(guid);
 434                         if(guid && !GetActionMemberFunction(guid))
 435                         {
 436                                 m_actionMemberFunctions.insert(TActionMemberFunctionMap::value_type(guid, pFunction));
 437                                 return true;
 438                         }
 439                 }
 440                 return false;
 441         }
 442
 443         //////////////////////////////////////////////////////////////////////////
 444         IActionMemberFunctionConstPtr CEnvRegistry::GetActionMemberFunction(const SGUID& guid) const
 445         {
 446                 TActionMemberFunctionMap::const_iterator        iActionMemberFunction = m_actionMemberFunctions.find(guid);
 447                 return iActionMemberFunction != m_actionMemberFunctions.end() ? iActionMemberFunction->second : IActionMemberFunctionConstPtr();
 448         }
 449
 450         //////////////////////////////////////////////////////////////////////////
 451         void CEnvRegistry::VisitActionMemberFunctions(const EnvActionMemberFunctionVisitor& visitor) const
 452         {
 453                 CRY_ASSERT(visitor);
 454                 if(visitor)
 455                 {
 456                         for(TActionMemberFunctionMap::const_iterator iActionMemberFunction = m_actionMemberFunctions.begin(), iEndActionMemberFunction = m_actionMemberFunctions.end(); iActionMemberFunction != iEndActionMemberFunction; ++ iActionMemberFunction)
 457                         {
 458                                 if(visitor(iActionMemberFunction->second) != EVisitStatus::Continue)
 459                                 {
 460                                         break;
 461                                 }
 462                         }
 463                 }
 464         }
 465
 466         //////////////////////////////////////////////////////////////////////////
 467         void CEnvRegistry::BlacklistElement(const SGUID& guid)
 468         {
 469                 m_blacklist.insert(guid);
 470         }
 471
 472         //////////////////////////////////////////////////////////////////////////
 473         bool CEnvRegistry::IsBlacklistedElement(const SGUID& guid) const
 474         {
 475                 return m_blacklist.find(guid) != m_blacklist.end();
 476         }
 477
 478         //////////////////////////////////////////////////////////////////////////
 479         bool CEnvRegistry::RegisterSettings(const char* name, const IEnvSettingsPtr& pSettings)
 480         {
 481                 return m_settings.insert(TSettingsMap::value_type(name, pSettings)).second;
 482         }
 483
 484         //////////////////////////////////////////////////////////////////////////
 485         IEnvSettingsPtr CEnvRegistry::GetSettings(const char* name) const
 486         {
 487                 TSettingsMap::const_iterator    iSettings = m_settings.find(name);
 488                 return iSettings != m_settings.end() ? iSettings->second : IEnvSettingsPtr();
 489         }
 490
 491         //////////////////////////////////////////////////////////////////////////
 492         void CEnvRegistry::VisitSettings(const EnvSettingsVisitor& visitor) const
 493         {
 494                 CRY_ASSERT(visitor);
 495                 if(visitor)
 496                 {
 497                         for(TSettingsMap::const_iterator iSettings = m_settings.begin(), iEndSettings = m_settings.end(); iSettings != iEndSettings; ++ iSettings)
 498                         {
 499                                 if(visitor(iSettings->first, iSettings->second) != EVisitStatus::Continue)
 500                                 {
 501                                         break;
 502                                 }
 503                         }
 504                 }
 505         }
 506
 507         //////////////////////////////////////////////////////////////////////////
 508         void CEnvRegistry::LoadAllSettings()
 509         {
 510                 MEMSTAT_CONTEXT(EMemStatContextType::Other, "Schematyc: Load All Settings");
 511                 CRY_PROFILE_FUNCTION(PROFILE_LOADING_ONLY);
 512                 const char* szSettingsFolder = gEnv->pSchematyc2->GetSettingsFolder();
 513                 const char* szSettingsExtension = gEnv->pSchematyc2->GetSettingsExtension();
 514                 for(TSettingsMap::const_iterator iSettings = m_settings.begin(), iEndSettings = m_settings.end(); iSettings != iEndSettings; ++ iSettings)
 515                 {
 516                         const char*  szName = iSettings->first.c_str();
 517                         stack_string fileName = szSettingsFolder;
 518                         fileName.append("/");
 519                         fileName.append(szName);
 520                         fileName.append(".");
 521                         fileName.append(szSettingsExtension);
 522                         fileName.MakeLower();
 523                         Serialization::LoadXmlFile(*iSettings->second, fileName);
 524                 }
 525         }
 526
 527         //////////////////////////////////////////////////////////////////////////
 528         void CEnvRegistry::SaveAllSettings()
 529         {
 530                 MEMSTAT_CONTEXT(EMemStatContextType::Other, "Schematyc: Save All Settings");
 531                 const char* szSttingsFolder = gEnv->pSchematyc2->GetSettingsFolder();
 532                 const char* szSettingsExtension = gEnv->pSchematyc2->GetSettingsExtension();
 533                 for(TSettingsMap::const_iterator iSettings = m_settings.begin(), iEndSettings = m_settings.end(); iSettings != iEndSettings; ++ iSettings)
 534                 {
 535                         const char* szName = iSettings->first.c_str();
 536                         stack_string fileName = szSttingsFolder;
 537                         fileName.append("/");
 538                         fileName.append(szName);
 539                         fileName.append(".");
 540                         fileName.append(szSettingsExtension);
 541                         fileName.MakeLower();
 542                         Serialization::SaveXmlFile(fileName, *iSettings->second, szName);
 543                 }
 544         }
 545
 546         //////////////////////////////////////////////////////////////////////////
 547         void CEnvRegistry::Validate() const
 548         {
 549                 ValidateComponentDependencies();
 550         }
 551
 552         //////////////////////////////////////////////////////////////////////////
 553         void CEnvRegistry::Clear()
 554         {
 555                 m_typeDescsById.clear();
 556                 m_typeDescsByGUID.clear();
 557                 m_signals.clear();
 558                 m_globalFunctions.clear();
 559                 m_foundations.clear();
 560                 m_abstractInterfaces.clear();
 561                 m_componentFactories.clear();
 562                 m_componentMemberFunctions.clear();
 563                 m_actionFactories.clear();
 564                 m_actionMemberFunctions.clear();
 565         }
 566
 567         //////////////////////////////////////////////////////////////////////////
 568         void CEnvRegistry::ValidateComponentDependencies() const
 569         {
 570                 for(TComponentFactoryMap::const_iterator iComponentFactory = m_componentFactories.begin(), iEndComponentFactory = m_componentFactories.end(); iComponentFactory != iEndComponentFactory; ++ iComponentFactory)
 571                 {
 572                         const SGUID                                                             componentGUID = iComponentFactory->first;
 573                         const IComponentFactory&        componentFactory = *iComponentFactory->second;
 574                         for(size_t iComponentDependency = 0, componentDependencyCount = componentFactory.GetDependencyCount(); iComponentDependency < componentDependencyCount; ++ iComponentDependency)
 575                         {
 576                                 const SGUID                                                             dependencyComponentGUID = componentFactory.GetDependencyGUID(iComponentDependency);
 577                                 IComponentFactoryConstPtr       pDependencyComponentFactory = GetComponentFactory(dependencyComponentGUID);
 578                                 if(pDependencyComponentFactory)
 579                                 {
 580                                         if((pDependencyComponentFactory->GetFlags() & EComponentFlags::Singleton) == 0)
 581                                         {
 582                                                 CryFatalError("%s : Non-singleton %s component detected as dependency of %s!", __FUNCTION__, pDependencyComponentFactory->GetName(), componentFactory.GetName());
 583                                         }
 584                                         if(EnvComponentUtils::IsDependency(*pDependencyComponentFactory, componentGUID))
 585                                         {
 586                                                 CryFatalError("%s : Circular dependency detected between %s and %s components!", __FUNCTION__, componentFactory.GetName(), pDependencyComponentFactory->GetName());
 587                                         }
 588                                 }
 589                                 else
 590                                 {
 591                                         char    stringBuffer[StringUtils::s_guidStringBufferSize];
 592                                         CryFatalError("%s : Unable to resolve dependency %s for %s component!", __FUNCTION__, StringUtils::SysGUIDToString(dependencyComponentGUID.sysGUID, stringBuffer), componentFactory.GetName());
 593                                 }
 594                         }
 595                 }
 596         }
 597 }