nel/tools/3d/pipeline_max/class_data.cpp

   1 /**
   2  * \file class_data.cpp
   3  * \brief CClassData
   4  * \date 2012-08-18 19:24GMT
   5  * \author Jan Boon (Kaetemi)
   6  * CClassData
   7  */
   8
   9 /*
  10  * Copyright (C) 2012  by authors
  11  *
  12  * This file is part of RYZOM CORE PIPELINE.
  13  * RYZOM CORE PIPELINE is free software: you can redistribute it
  14  * and/or modify it under the terms of the GNU Affero General Public
  15  * License as published by the Free Software Foundation, either
  16  * version 3 of the License, or (at your option) any later version.
  17  *
  18  * RYZOM CORE PIPELINE is distributed in the hope that it will be
  19  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  20  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Affero General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU Affero General Public
  24  * License along with RYZOM CORE PIPELINE.  If not, see
  25  * <http://www.gnu.org/licenses/>.
  26  */
  27
  28 #include <nel/misc/types_nl.h>
  29 #include "class_data.h"
  30
  31 // STL includes
  32
  33 // NeL includes
  34 // #include <nel/misc/debug.h>
  35
  36 // Project includes
  37
  38 using namespace std;
  39 // using namespace NLMISC;
  40
  41 namespace PIPELINE {
  42 namespace MAX {
  43
  44 ////////////////////////////////////////////////////////////////////////
  45 ////////////////////////////////////////////////////////////////////////
  46 ////////////////////////////////////////////////////////////////////////
  47
  48 CClassData::CClassData()
  49 {
  50
  51 }
  52
  53 CClassData::~CClassData()
  54 {
  55
  56 }
  57
  58 std::string CClassData::className() const
  59 {
  60         return "ClassData";
  61 }
  62
  63 void CClassData::toString(std::ostream &ostream, const std::string &pad) const
  64 {
  65         CStorageContainer::toString(ostream, pad);
  66 }
  67
  68 void CClassData::parse(uint16 version, uint filter)
  69 {
  70         CStorageContainer::parse(version);
  71 }
  72
  73 void CClassData::clean()
  74 {
  75         CStorageContainer::clean();
  76 }
  77
  78 void CClassData::build(uint16 version, uint filter)
  79 {
  80         CStorageContainer::build(version);
  81 }
  82
  83 void CClassData::disown()
  84 {
  85         CStorageContainer::disown();
  86 }
  87
  88 IStorageObject *CClassData::createChunkById(uint16 id, bool container)
  89 {
  90         if (container)
  91         {
  92                 switch (id)
  93                 {
  94                 case 0x2100: // ClassDataEntry
  95                         return new CClassDataEntry();
  96                 }
  97         }
  98         return CStorageContainer::createChunkById(id, container);
  99 }
 100
 101 ////////////////////////////////////////////////////////////////////////
 102 ////////////////////////////////////////////////////////////////////////
 103 ////////////////////////////////////////////////////////////////////////
 104
 105 CClassDataEntry::CClassDataEntry()
 106 {
 107
 108 }
 109
 110 CClassDataEntry::~CClassDataEntry()
 111 {
 112
 113 }
 114
 115 std::string CClassDataEntry::className() const
 116 {
 117         return "ClassDataEntry";
 118 }
 119
 120 void CClassDataEntry::toString(std::ostream &ostream, const std::string &pad) const
 121 {
 122         CStorageContainer::toString(ostream, pad);
 123 }
 124
 125 void CClassDataEntry::parse(uint16 version, uint filter)
 126 {
 127         CStorageContainer::parse(version);
 128 }
 129
 130 void CClassDataEntry::clean()
 131 {
 132         CStorageContainer::clean();
 133 }
 134
 135 void CClassDataEntry::build(uint16 version, uint filter)
 136 {
 137         CStorageContainer::build(version);
 138 }
 139
 140 void CClassDataEntry::disown()
 141 {
 142         CStorageContainer::disown();
 143 }
 144
 145 IStorageObject *CClassDataEntry::createChunkById(uint16 id, bool container)
 146 {
 147         if (!container)
 148         {
 149                 switch (id)
 150                 {
 151                 case 0x2110: // ClassDataHeader
 152                         return new CClassDataHeader();
 153                 }
 154         }
 155         switch (id)
 156         {
 157         case 0x2120: // ClassDataBody: Depends on the ClassDataHeader: TODO
 158                 return CStorageContainer::createChunkById(id, container);
 159         }
 160         return CStorageContainer::createChunkById(id, container);
 161 }
 162
 163 ////////////////////////////////////////////////////////////////////////
 164 ////////////////////////////////////////////////////////////////////////
 165 ////////////////////////////////////////////////////////////////////////
 166
 167 CClassDataHeader::CClassDataHeader()
 168 {
 169
 170 }
 171
 172 CClassDataHeader::~CClassDataHeader()
 173 {
 174
 175 }
 176
 177 std::string CClassDataHeader::className() const
 178 {
 179         return "ClassDataHeader";
 180 }
 181
 182 void CClassDataHeader::serial(NLMISC::IStream &stream)
 183 {
 184         stream.serial(ClassID);
 185         stream.serial(SuperClassID);
 186 }
 187
 188 void CClassDataHeader::toString(std::ostream &ostream, const std::string &pad) const
 189 {
 190         ostream << "(" << className() << ") { ";
 191         ostream << "\n" << pad << "ClassID: " << NLMISC::toString(ClassID);
 192         ostream << "\n" << pad << "SuperClassID: " << SuperClassID;
 193         ostream << " } ";
 194 }
 195
 196 ////////////////////////////////////////////////////////////////////////
 197 ////////////////////////////////////////////////////////////////////////
 198 ////////////////////////////////////////////////////////////////////////
 199
 200 } /* namespace MAX */
 201 } /* namespace PIPELINE */
 202
 203 /* end of file */