Source/System/FileIO/Collada/OSGColladaElementFactory.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                   Copyright (C) 2009 by the OpenSG Forum                  *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #if __GNUC__ >= 4 || __GNUC_MINOR__ >=3
  40 #pragma GCC diagnostic ignored "-Wold-style-cast"
  41 #endif
  42
  43 #include "OSGColladaElementFactory.h"
  44
  45 #if defined(OSG_WITH_COLLADA) || defined(OSG_DO_DOC)
  46
  47 #include "OSGBaseInitFunctions.h"
  48 #include "OSGColladaLog.h"
  49 #include "OSGColladaGlobal.h"
  50 #include "OSGSingletonHolder.ins"
  51
  52
  53 OSG_BEGIN_NAMESPACE
  54
  55 #if !defined(OSG_DO_DOC)
  56 OSG_SINGLETON_INST(OSG::ColladaElementFactorySingleton,
  57                    addPostFactoryExitFunction)
  58 #endif
  59
  60 template class SingletonHolder<OSG::ColladaElementFactorySingleton>;
  61
  62
  63 bool
  64 ColladaElementFactorySingleton::registerElement(
  65           CreateFunctor  createFunc,
  66     const std::string   &elemName,
  67     const std::string   &profile,
  68           bool           override)
  69 {
  70     bool retVal = true;
  71
  72     if(profile.empty() == false)
  73     {
  74         retVal = doRegisterElement(createFunc, elemName,
  75                                    _profileHandlerMap[profile],
  76                                    override                   );
  77     }
  78     else
  79     {
  80         retVal = doRegisterElement(createFunc, elemName,
  81                                    _defaultHandlerMap,
  82                                    override            );
  83     }
  84
  85     return retVal;
  86 }
  87
  88 bool
  89 ColladaElementFactorySingleton::unregisterElement(
  90     const std::string &elemName, const std::string &profile)
  91 {
  92     bool retVal = true;
  93
  94     if(profile.empty() == false)
  95     {
  96         retVal = doUnregisterElement(elemName, _profileHandlerMap[profile]);
  97     }
  98     else
  99     {
 100         retVal = doUnregisterElement(elemName, _defaultHandlerMap         );
 101     }
 102
 103     return retVal;
 104 }
 105
 106 const ColladaElementFactorySingleton::HandlerMap &
 107 ColladaElementFactorySingleton::getDefaultHandlerMap(void) const
 108 {
 109     return _defaultHandlerMap;
 110 }
 111
 112 ColladaElementFactorySingleton::HandlerMap &
 113 ColladaElementFactorySingleton::editDefaultHandlerMap(void)
 114 {
 115     return _defaultHandlerMap;
 116 }
 117
 118 const ColladaElementFactorySingleton::ProfileHandlerMap &
 119 ColladaElementFactorySingleton::getProfileHandlerMap(void) const
 120 {
 121     return _profileHandlerMap;
 122 }
 123
 124 ColladaElementFactorySingleton::ProfileHandlerMap &
 125 ColladaElementFactorySingleton::editProfileHandlerMap(void)
 126 {
 127     return _profileHandlerMap;
 128 }
 129
 130 const std::string &
 131 ColladaElementFactorySingleton::getDefaultProfile(void) const
 132 {
 133     return _defaultProfile;
 134 }
 135
 136 void
 137 ColladaElementFactorySingleton::setDefaultProfile(const std::string &profile)
 138 {
 139     _defaultProfile = profile;
 140 }
 141
 142 ColladaElementFactorySingleton::CreateFunctor
 143 ColladaElementFactorySingleton::getCreateFunc(const std::string &elemName,
 144                                               const std::string &profile  )
 145 {
 146     if(profile.empty() == false)
 147     {
 148         return doGetCreateFunc(elemName, _profileHandlerMap[profile]        );
 149     }
 150     else if(_defaultProfile.empty() == false)
 151     {
 152         return doGetCreateFunc(elemName, _profileHandlerMap[_defaultProfile]);
 153     }
 154     else
 155     {
 156         return doGetCreateFunc(elemName, _defaultHandlerMap                 );
 157     }
 158 }
 159
 160 ColladaElementTransitPtr
 161 ColladaElementFactorySingleton::create(daeElement        *daeElem,
 162                                        ColladaGlobal     *global,
 163                                        const std::string &elemName,
 164                                        const std::string &profile  )
 165 {
 166     ColladaElementTransitPtr retVal;
 167     std::string              lookupName;
 168
 169     if(elemName.empty() == true)
 170     {
 171         if(daeElem->getElementName() != NULL)
 172         {
 173             lookupName = daeElem->getElementName();
 174         }
 175         else if(daeElem->getTypeName() != NULL)
 176         {
 177             lookupName = daeElem->getTypeName();
 178         }
 179     }
 180     else
 181     {
 182         lookupName = elemName;
 183     }
 184
 185     if(lookupName.empty() == false)
 186     {
 187         CreateFunctor createFunc = getCreateFunc(lookupName, profile);
 188
 189         if(createFunc.empty() == false)
 190         {
 191             retVal = createFunc(daeElem, global);
 192         }
 193
 194         if(retVal != NULL)
 195         {
 196             retVal->getDOMElement()->setUserData(retVal.get());
 197
 198             global->addElement                  (retVal.get());
 199         }
 200         else
 201         {
 202             daeString dsElemName =
 203                 daeElem->getElementName() != NULL ?
 204                 daeElem->getElementName()         : "??";
 205             daeString dsTypeName =
 206                 daeElem->getTypeName   () != NULL ?
 207                 daeElem->getTypeName   ()         : "??";
 208
 209             SWARNING << "ColladaElementFactory::create: No element registered "
 210                      << "for [" << lookupName
 211                      << "] - elemName [" << dsElemName
 212                      << "] typeName [" << dsTypeName
 213                      << "] id [" << daeElem->typeID() << "]."
 214                      << std::endl;
 215         }
 216     }
 217
 218     return retVal;
 219 }
 220
 221
 222 bool
 223 ColladaElementFactorySingleton::doRegisterElement(
 224           CreateFunctor createFunc,
 225     const std::string &elemName,
 226           HandlerMap  &handlerMap,
 227           bool         override  )
 228 {
 229     bool         retVal = true;
 230     HandlerMapIt hIt    = handlerMap.find(elemName);
 231
 232     if(hIt != handlerMap.end())
 233     {
 234         if(override == false)
 235         {
 236             SWARNING << "ColladaElementFactorySingleton::doRegisterElement: "
 237                      << "elemName [" << elemName << "] already registered."
 238                      << std::endl;
 239
 240             retVal = false;
 241         }
 242         else
 243         {
 244             SWARNING << "ColladaElementFactorySingleton::doRegisterElement: "
 245                      << "overrode elemName [" << elemName << "] handler."
 246                      << std::endl;
 247
 248             hIt->second = createFunc;
 249         }
 250     }
 251     else
 252     {
 253         handlerMap.insert(hIt, HandlerMap::value_type(elemName, createFunc));
 254     }
 255
 256     return retVal;
 257 }
 258
 259 bool
 260 ColladaElementFactorySingleton::doUnregisterElement(
 261     const std::string &elemName, HandlerMap &handlerMap)
 262 {
 263     bool         retVal = true;
 264     HandlerMapIt hIt    = handlerMap.find(elemName);
 265
 266     if(hIt != handlerMap.end())
 267     {
 268         handlerMap.erase(hIt);
 269     }
 270     else
 271     {
 272         SWARNING << "ColladaElemnetFactorySingleton::doUnregisterElement: "
 273                  << "elemName [" << elemName << "] not registered."
 274                  << std::endl;
 275
 276         retVal = false;
 277     }
 278
 279     return retVal;
 280 }
 281
 282 ColladaElementFactorySingleton::CreateFunctor
 283 ColladaElementFactorySingleton::doGetCreateFunc(
 284     const std::string &elemName, HandlerMap &handlerMap)
 285 {
 286     CreateFunctor retVal;
 287     HandlerMapIt  hIt    = handlerMap.find(elemName);
 288
 289     if(hIt != handlerMap.end())
 290     {
 291         retVal = hIt->second;
 292     }
 293
 294     return retVal;
 295 }
 296
 297 ColladaElementFactorySingleton::ColladaElementFactorySingleton(void)
 298     : _defaultProfile   ()
 299     , _defaultHandlerMap()
 300     , _profileHandlerMap()
 301 {
 302 }
 303
 304 ColladaElementFactorySingleton::~ColladaElementFactorySingleton(void)
 305 {
 306 }
 307
 308 OSG_END_NAMESPACE
 309
 310 #endif // OSG_WITH_COLLADA