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

   1 /**
   2  * \file dll_directory.cpp
   3  * \brief CDllDirectory
   4  * \date 2012-08-18 09:01GMT
   5  * \author Jan Boon (Kaetemi)
   6  * CDllDirectory
   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 "dll_directory.h"
  30
  31 // STL includes
  32 #include <iomanip>
  33
  34 // NeL includes
  35 // #include <nel/misc/debug.h>
  36
  37 // Project includes
  38
  39 using namespace std;
  40 // using namespace NLMISC;
  41
  42 namespace PIPELINE {
  43 namespace MAX {
  44
  45 ////////////////////////////////////////////////////////////////////////
  46 ////////////////////////////////////////////////////////////////////////
  47 ////////////////////////////////////////////////////////////////////////
  48
  49 CDllDirectory::CDllDirectory() : m_DllEntryBuiltin(&DllPluginDescBuiltin), m_DllEntryScript(&DllPluginDescScript)
  50 {
  51
  52 }
  53
  54 // Parallel to CClassDirectory3
  55 CDllDirectory::~CDllDirectory()
  56 {
  57         // Delete m_ChunkCache and m_Entries when !m_ChunksOwnsPointers
  58         if (!m_ChunksOwnsPointers)
  59         {
  60                 for (TStorageObjectContainer::iterator it = m_ChunkCache.begin(), end = m_ChunkCache.end(); it != end; ++it)
  61                 {
  62                         delete it->second;
  63                 }
  64                 for (std::vector<CDllEntry *>::iterator subit = m_Entries.begin(), subend = m_Entries.end(); subit != subend; ++subit)
  65                 {
  66                         delete (*subit);
  67                 }
  68         }
  69         m_ChunkCache.clear();
  70         m_Entries.clear();
  71 }
  72
  73 std::string CDllDirectory::className() const
  74 {
  75         return "DllDirectory";
  76 }
  77
  78 // Parallel to CClassDirectory3
  79 void CDllDirectory::toString(std::ostream &ostream, const std::string &pad) const
  80 {
  81         if (m_ChunksOwnsPointers)
  82         {
  83                 CStorageContainer::toString(ostream, pad);
  84         }
  85         else
  86         {
  87                 ostream << "(" << className() << ") [" << m_Chunks.size() << "] PARSED { ";
  88                 std::string padpad = pad + "\t";
  89                 sint i = 0;
  90                 for (TStorageObjectContainer::const_iterator it = m_ChunkCache.begin(), end = m_ChunkCache.end(); it != end; ++it)
  91                 {
  92                         uint16 id = it->first;
  93                         switch (id)
  94                         {
  95                         case 0x2038: // DllEntry
  96                                 {
  97                                         uint subi = 0;
  98                                         for (std::vector<CDllEntry *>::const_iterator subit = m_Entries.begin(), subend = m_Entries.end(); subit != subend; ++subit)
  99                                         {
 100                                                 ostream << "\n" << pad << "Entries[" << subi << "]: ";
 101                                                 (*subit)->toString(ostream, padpad);
 102                                                 ++subi;
 103                                         }
 104                                 }
 105                                 break;
 106                         default:
 107                                 std::stringstream ss;
 108                                 ss << std::hex << std::setfill('0');
 109                                 ss << std::setw(4) << it->first;
 110                                 ostream << "\n" << pad << "0x" << ss.str() << ": ";
 111                                 it->second->toString(ostream, padpad);
 112                                 ++i;
 113                                 break;
 114                         }
 115                 }
 116                 ostream << "} ";
 117         }
 118 }
 119
 120 // Parallel to CClassDirectory3
 121 void CDllDirectory::parse(uint16 version, uint filter)
 122 {
 123         // Ensure not yet parsed
 124         nlassert(m_ChunkCache.empty());
 125         nlassert(m_Entries.empty());
 126
 127         // Parse entries first
 128         CStorageContainer::parse(version);
 129
 130         // Initialize
 131         addInternalIndices();
 132         uint16 lastCached = 0xFFFF;
 133         bool parsedDllEntry = false;
 134
 135         // Parse chunks
 136         for (TStorageObjectContainer::iterator it = m_Chunks.begin(), end = m_Chunks.end(); it != end; ++it)
 137         {
 138                 uint16 id = it->first;
 139                 switch (id)
 140                 {
 141                 case 0x2038: // DllEntry
 142                         {
 143                                 if (parsedDllEntry && (lastCached != id))
 144                                         throw EStorageParse(); // There were chunks inbetween
 145                                 if (!parsedDllEntry)
 146                                 {
 147                                         m_ChunkCache.push_back(TStorageObjectWithId(id, NULL)); // Dummy entry to know the location
 148                                         lastCached = id;
 149                                         parsedDllEntry = true;
 150                                 }
 151                                 CDllEntry *dllEntry = static_cast<CDllEntry *>(it->second);
 152                                 m_InternalNameToIndex[NLMISC::toLower(dllEntry->dllFilename())] = m_Entries.size();
 153                                 m_Entries.push_back(dllEntry);
 154                         }
 155                         break;
 156                 default:
 157                         m_ChunkCache.push_back(*it); // Dummy entry to know the location
 158                         lastCached = id;
 159                         break;
 160                 }
 161         }
 162
 163         // Now ownership of the pointers lies in m_ChunkCache and m_Entries
 164         m_ChunksOwnsPointers = false;
 165 }
 166
 167 // Parallel to CClassDirectory3
 168 void CDllDirectory::clean()
 169 {
 170         // Ensure parsed
 171         nlassert(!m_ChunksOwnsPointers);
 172
 173         // Clear m_Chunks
 174         m_Chunks.clear();
 175
 176         // Clean chunks
 177         for (TStorageObjectContainer::iterator it = m_ChunkCache.begin(), end = m_ChunkCache.end(); it != end; ++it)
 178         {
 179                 if (it->second != NULL && it->second->isContainer())
 180                 {
 181                         static_cast<CStorageContainer *>(it->second)->clean();
 182                 }
 183         }
 184         for (std::vector<CDllEntry *>::iterator subit = m_Entries.begin(), subend = m_Entries.end(); subit != subend; ++subit)
 185         {
 186                 (*subit)->clean();
 187         }
 188 }
 189
 190 // Parallel to CClassDirectory3
 191 void CDllDirectory::build(uint16 version, uint filter)
 192 {
 193         // Ensure parsed
 194         nlassert(!m_ChunksOwnsPointers);
 195
 196         // Initialize
 197         nlassert(m_Chunks.empty());
 198
 199         // Set up the m_Chunks list, when (CDllEntry::ID, NULL) is found write out all of the entries.
 200         for (TStorageObjectContainer::iterator it = m_ChunkCache.begin(), end = m_ChunkCache.end(); it != end; ++it)
 201         {
 202                 uint16 id = it->first;
 203                 switch (id)
 204                 {
 205                 case 0x2038: // DllEntry
 206                         for (std::vector<CDllEntry *>::iterator subit = m_Entries.begin(), subend = m_Entries.end(); subit != subend; ++subit)
 207                                 m_Chunks.push_back(TStorageObjectWithId(id, (*subit)));
 208                         break;
 209                 default:
 210                         m_Chunks.push_back(*it);
 211                         break;
 212                 }
 213         }
 214
 215         // Build the entries last (after m_Chunks is built)
 216         CStorageContainer::build(version);
 217
 218         // NOTE: Ownership remains with m_ChunkCache and m_Entries
 219 }
 220
 221 // Parallel to CClassDirectory3
 222 void CDllDirectory::disown()
 223 {
 224         m_ChunkCache.clear();
 225         m_Entries.clear();
 226         m_InternalNameToIndex.clear();
 227
 228         // Ownership goes back to m_Chunks
 229         m_ChunksOwnsPointers = true;
 230
 231         // Disown child chunks
 232         CStorageContainer::disown();
 233 }
 234
 235 // Parallel to CClassDirectory3
 236 const CDllEntry *CDllDirectory::get(sint32 index) const
 237 {
 238         nlassert(!m_ChunksOwnsPointers);
 239         if (index < 0)
 240         {
 241                 // Handle internal dummy values
 242                 switch (index)
 243                 {
 244                 case -1:
 245                         return &m_DllEntryBuiltin;
 246                 case -2:
 247                         return &m_DllEntryScript;
 248                 default:
 249                         nlerror("Bad dll entry index");
 250                 }
 251         }
 252         else
 253         {
 254                 nlassert(index < (sint32)m_Entries.size());
 255                 return m_Entries[index];
 256         }
 257         nlassert(false);
 258         return NULL;
 259 }
 260
 261 // Parallel to CClassDirectory3
 262 void CDllDirectory::reset()
 263 {
 264         nlassert(!m_ChunksOwnsPointers);
 265         for (std::vector<CDllEntry *>::iterator subit = m_Entries.begin(), subend = m_Entries.end(); subit != subend; ++subit)
 266         {
 267                 delete (*subit);
 268         }
 269         m_Entries.clear();
 270         m_InternalNameToIndex.clear();
 271         addInternalIndices();
 272 }
 273
 274 // Parallel to CClassDirectory3
 275 sint32 CDllDirectory::getOrCreateIndex(const IDllPluginDescInternal *dllPluginDesc)
 276 {
 277         nlassert(!m_ChunksOwnsPointers);
 278         std::map<ucstring, sint32>::iterator it = m_InternalNameToIndex.find(NLMISC::toLower(ucstring(dllPluginDesc->internalName())));
 279
 280         // Return existing index
 281         if (it != m_InternalNameToIndex.end())
 282                 return it->second;
 283
 284         // Create new entry
 285         CDllEntry *dllEntry = new CDllEntry(dllPluginDesc);
 286         sint32 index = m_Entries.size();
 287         m_InternalNameToIndex[NLMISC::toLower(dllEntry->dllFilename())] = index;
 288         m_Entries.push_back(dllEntry);
 289         return index;
 290 }
 291
 292 void CDllDirectory::addInternalIndices()
 293 {
 294         m_InternalNameToIndex[NLMISC::toLower(ucstring(DllPluginDescBuiltin.internalName()))] = -1;
 295         m_InternalNameToIndex[NLMISC::toLower(ucstring(DllPluginDescScript.internalName()))] = -2;
 296 }
 297
 298 IStorageObject *CDllDirectory::createChunkById(uint16 id, bool container)
 299 {
 300         if (container)
 301         {
 302                 switch (id)
 303                 {
 304                 case 0x2038: // DllEntry
 305                         return new CDllEntry();
 306                 }
 307         }
 308         else
 309         {
 310                 switch (id)
 311                 {
 312                 case 0x21C0: // DllDirectoryHeader
 313                         return new CStorageValue<uint32>();
 314                 }
 315         }
 316         return CStorageContainer::createChunkById(id, container);
 317 }
 318
 319 ////////////////////////////////////////////////////////////////////////
 320 ////////////////////////////////////////////////////////////////////////
 321 ////////////////////////////////////////////////////////////////////////
 322 // Entries[5]: (DllEntry) [2] PARSED {
 323 //      DllDescription: ...
 324 //      DllFilename: ... }
 325
 326 CDllEntry::CDllEntry() : m_DllDescription(NULL), m_DllFilename(NULL)
 327 {
 328
 329 }
 330
 331 CDllEntry::CDllEntry(const IDllPluginDescInternal *dllPluginDesc) : m_DllDescription(new CStorageValue<ucstring>()), m_DllFilename(new CStorageValue<ucstring>())
 332 {
 333         m_Chunks.push_back(TStorageObjectWithId(0x2039, m_DllDescription));
 334         m_Chunks.push_back(TStorageObjectWithId(0x2037, m_DllFilename));
 335         m_DllDescription->Value = dllPluginDesc->displayName();
 336         m_DllFilename->Value = dllPluginDesc->internalName();
 337 }
 338
 339 CDllEntry::~CDllEntry()
 340 {
 341
 342 }
 343
 344 std::string CDllEntry::className() const
 345 {
 346         return "DllEntry";
 347 }
 348
 349 void CDllEntry::toString(std::ostream &ostream, const std::string &pad) const
 350 {
 351         if (m_DllDescription && m_DllFilename)
 352         {
 353                 ostream << "(" << className() << ") [" << m_Chunks.size() << "] PARSED { ";
 354                 std::string padpad = pad + "\t";
 355                 ostream << "\n" << pad << "DllDescription: " << m_DllDescription->Value.toUtf8();
 356                 ostream << "\n" << pad << "DllFilename: " << m_DllFilename->Value.toUtf8();
 357                 ostream << " } ";
 358         }
 359         else
 360         {
 361                 CStorageContainer::toString(ostream, pad);
 362         }
 363 }
 364
 365 void CDllEntry::parse(uint16 version, uint filter)
 366 {
 367         // CStorageContainer::parse(version);
 368         nlassert(m_ChunksOwnsPointers);
 369         nlassert(m_Chunks.size() == 2);
 370         TStorageObjectContainer::iterator it = m_Chunks.begin();
 371         nlassert(it->first == 0x2039); // DllDescription
 372         m_DllDescription = static_cast<CStorageValue<ucstring> *>(it->second);
 373         ++it;
 374         nlassert(it->first == 0x2037); // DllFilename
 375         m_DllFilename = static_cast<CStorageValue<ucstring> *>(it->second);
 376         // ++it;
 377 }
 378
 379 void CDllEntry::clean()
 380 {
 381         // Nothing to do here! (m_Chunks retains ownership)
 382         // CStorageContainer::clean();
 383 }
 384
 385 void CDllEntry::build(uint16 version, uint filter)
 386 {
 387         // Nothing to do here!
 388         // CStorageContainer::build(version);
 389 }
 390
 391 void CDllEntry::disown()
 392 {
 393         // CStorageContainer::disown();
 394         m_DllDescription = NULL;
 395         m_DllFilename = NULL;
 396         nlassert(m_ChunksOwnsPointers);
 397 }
 398
 399 IStorageObject *CDllEntry::createChunkById(uint16 id, bool container)
 400 {
 401         if (!container)
 402         {
 403                 switch (id)
 404                 {
 405                 case 0x2039: // DllDescription
 406                 case 0x2037: // DllFilename
 407                         return new CStorageValue<ucstring>();
 408                 }
 409         }
 410         return CStorageContainer::createChunkById(id, container);
 411 }
 412
 413 ////////////////////////////////////////////////////////////////////////
 414 ////////////////////////////////////////////////////////////////////////
 415 ////////////////////////////////////////////////////////////////////////
 416
 417 } /* namespace MAX */
 418 } /* namespace PIPELINE */
 419
 420 /* end of file */