Code/CryEngine/CrySchematyc2/Script/ScriptElementBase.h

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #pragma once
   4
   5 #include <CrySchematyc2/Script/IScriptElement.h>
   6 #include <CrySchematyc2/Script/IScriptFile.h>
   7 #include <CrySchematyc2/Services/ILog.h>
   8
   9 #include "Script/ScriptExtensionMap.h"
  10 #include <CrySchematyc2/BasicTypes.h>
  11
  12 namespace Schematyc2
  13 {
  14         template <typename INTERFACE> class CScriptElementBase : public INTERFACE
  15         {
  16         public:
  17
  18                 CScriptElementBase(EScriptElementType type, IScriptFile& file)
  19                         : m_type(type)
  20                         , m_file(file)
  21                         , m_flags(EScriptElementFlags::None)
  22                         , m_pNewFile(nullptr)
  23                         , m_pParent(nullptr)
  24                         , m_pFirstChild(nullptr)
  25                         , m_pLastChild(nullptr)
  26                         , m_pPrevSibling(nullptr)
  27                         , m_pNextSibling(nullptr)
  28                 {}
  29
  30                 ~CScriptElementBase()
  31                 {
  32                         if(m_pParent)
  33                         {
  34                                 m_pParent->DetachChild(*this);
  35                         }
  36                         for(IScriptElement* pChild = m_pFirstChild; pChild; )
  37                         {
  38                                 IScriptElement* pNextChild = pChild->GetNextSibling();
  39                                 pChild->SetParent(nullptr);
  40                                 pChild->SetPrevSibling(nullptr);
  41                                 pChild->SetNextSibling(nullptr);
  42                                 pChild = pNextChild;
  43                         }
  44                 }
  45
  46                 // IScriptElement
  47
  48                 virtual EScriptElementType GetElementType() const override
  49                 {
  50                         return m_type;
  51                 }
  52
  53                 virtual IScriptFile& GetFile() override
  54                 {
  55                         return m_file;
  56                 }
  57
  58                 virtual const IScriptFile& GetFile() const override
  59                 {
  60                         return m_file;
  61                 }
  62
  63                 virtual EGraphExecutionFilter GetExecutionFilter() const override
  64                 {
  65                         return EGraphExecutionFilter::Always;
  66                 }
  67
  68                 virtual void SetElementFlags(EScriptElementFlags flags) override
  69                 {
  70                         m_flags = flags;
  71                 }
  72
  73                 virtual EScriptElementFlags GetElementFlags() const override
  74                 {
  75                         return m_flags;
  76                 }
  77
  78                 virtual void SetNewFile(INewScriptFile* pNewFile) override
  79                 {
  80                         m_pNewFile = pNewFile;
  81                 }
  82
  83                 virtual INewScriptFile* GetNewFile() override
  84                 {
  85                         return m_pNewFile;
  86                 }
  87
  88                 virtual const INewScriptFile* GetNewFile() const override
  89                 {
  90                         return m_pNewFile;
  91                 }
  92
  93                 virtual void AttachChild(IScriptElement& child) override
  94                 {
  95                         IScriptElement* pPrevParent = child.GetParent();
  96                         if(pPrevParent)
  97                         {
  98                                 pPrevParent->DetachChild(child);
  99                         }
 100
 101                         child.SetParent(this);
 102                         child.SetPrevSibling(m_pLastChild);
 103
 104                         if(m_pFirstChild)
 105                         {
 106                                 m_pLastChild->SetNextSibling(&child);
 107                         }
 108                         else
 109                         {
 110                                 m_pFirstChild = &child;
 111                         }
 112                         m_pLastChild = &child;
 113                 }
 114
 115                 virtual void DetachChild(IScriptElement& child) override
 116                 {
 117                         IScriptElement* pParent = child.GetParent();
 118                         SCHEMATYC2_SYSTEM_ASSERT(pParent == this);
 119                         if(pParent == this)
 120                         {
 121                                 IScriptElement* pPrevSibling = child.GetPrevSibling();
 122                                 IScriptElement* pNextSibling = child.GetNextSibling();
 123
 124                                 if(&child == m_pFirstChild)
 125                                 {
 126                                         SCHEMATYC2_SYSTEM_ASSERT(!pPrevSibling);
 127                                         m_pFirstChild = pNextSibling;
 128                                 }
 129                                 else
 130                                 {
 131                                         SCHEMATYC2_SYSTEM_ASSERT(pPrevSibling);
 132                                         pPrevSibling->SetNextSibling(pNextSibling);
 133                                 }
 134
 135                                 if(&child == m_pLastChild)
 136                                 {
 137                                         SCHEMATYC2_SYSTEM_ASSERT(!pNextSibling);
 138                                         m_pLastChild = pPrevSibling;
 139                                 }
 140                                 else
 141                                 {
 142                                         SCHEMATYC2_SYSTEM_ASSERT(pNextSibling);
 143                                         pNextSibling->SetPrevSibling(pPrevSibling);
 144                                 }
 145
 146                                 child.SetParent(nullptr);
 147                                 child.SetPrevSibling(nullptr);
 148                                 child.SetNextSibling(nullptr);
 149                         }
 150                 }
 151
 152                 virtual void SetParent(IScriptElement* pParent) override
 153                 {
 154                         m_pParent = pParent;
 155                 }
 156
 157                 virtual void SetPrevSibling(IScriptElement* pPrevSibling) override
 158                 {
 159                         m_pPrevSibling = pPrevSibling;
 160                 }
 161
 162                 virtual void SetNextSibling(IScriptElement* pNextSibling) override
 163                 {
 164                         m_pNextSibling = pNextSibling;
 165                 }
 166
 167                 virtual IScriptElement* GetParent() override
 168                 {
 169                         return m_pParent;
 170                 }
 171
 172                 virtual const IScriptElement* GetParent() const override
 173                 {
 174                         return m_pParent;
 175                 }
 176
 177                 virtual IScriptElement* GetFirstChild() override
 178                 {
 179                         return m_pFirstChild;
 180                 }
 181
 182                 virtual const IScriptElement* GetFirstChild() const override
 183                 {
 184                         return m_pFirstChild;
 185                 }
 186
 187                 virtual IScriptElement* GetLastChild() override
 188                 {
 189                         return m_pLastChild;
 190                 }
 191
 192                 virtual const IScriptElement* GetLastChild() const override
 193                 {
 194                         return m_pLastChild;
 195                 }
 196
 197                 virtual IScriptElement* GetPrevSibling() override
 198                 {
 199                         return m_pPrevSibling;
 200                 }
 201
 202                 virtual const IScriptElement* GetPrevSibling() const override
 203                 {
 204                         return m_pPrevSibling;
 205                 }
 206
 207                 virtual IScriptElement* GetNextSibling() override
 208                 {
 209                         return m_pNextSibling;
 210                 }
 211
 212                 virtual const IScriptElement* GetNextSibling() const override
 213                 {
 214                         return m_pNextSibling;
 215                 }
 216
 217                 virtual IScriptExtensionMap& GetExtensions() override
 218                 {
 219                         return m_extensions;
 220                 }
 221
 222                 virtual const IScriptExtensionMap& GetExtensions() const override
 223                 {
 224                         return m_extensions;
 225                 }
 226
 227                 virtual void Refresh(const SScriptRefreshParams& params) override
 228                 {
 229                         m_extensions.Refresh(params);
 230                 }
 231
 232                 virtual void Serialize(Serialization::IArchive& archive) override
 233                 {
 234                         if(archive.isOutput())
 235                         {
 236                                 EScriptElementType elementType = static_cast<const INTERFACE*>(this)->GetElementType();
 237                                 archive(elementType, "elementType");
 238                         }
 239
 240                         archive(m_extensions, "extensions");
 241                 }
 242
 243                 virtual void RemapGUIDs(IGUIDRemapper& guidRemapper) override
 244                 {
 245                         m_extensions.RemapGUIDs(guidRemapper);
 246                 }
 247
 248                 // ~IScriptElement
 249
 250                 inline void AddExtension(const IScriptExtensionPtr& pExtension)
 251                 {
 252                         m_extensions.AddExtension(pExtension);
 253                 }
 254
 255         private:
 256
 257                 EScriptElementType  m_type;
 258                 IScriptFile&        m_file;
 259                 EScriptElementFlags m_flags;
 260                 INewScriptFile*     m_pNewFile;
 261                 IScriptElement*     m_pParent;
 262                 IScriptElement*     m_pFirstChild;
 263                 IScriptElement*     m_pLastChild;
 264                 IScriptElement*     m_pPrevSibling;
 265                 IScriptElement*     m_pNextSibling;
 266                 CScriptExtensionMap m_extensions;
 267         };
 268 }