Source/Base/Field/OSGFieldDescFactory.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 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 #include <stdlib.h>
  40 #include <stdio.h>
  41
  42 #include "OSGConfig.h"
  43 #include "OSGFieldDescFactory.h"
  44 #include "OSGFieldType.h"
  45 #include "OSGBaseFunctions.h"
  46 #include "OSGLog.h"
  47 #include "OSGFactoryController.h"
  48
  49 #include "OSGSingletonHolder.ins"
  50
  51 OSG_BEGIN_NAMESPACE
  52
  53 OSG_SINGLETON_INST(FieldDescFactoryBase, addPostFactoryExitFunction)
  54
  55 template class SingletonHolder<FieldDescFactoryBase>;
  56
  57 OSG_END_NAMESPACE
  58
  59 OSG_BEGIN_NAMESPACE
  60
  61 /*-------------------------------------------------------------------------*/
  62 /*                            Class Variable                               */
  63
  64 //std::map<UInt32, FieldType *> *FieldDescFactory::_fieldTypeM  = NULL;
  65
  66 /*-------------------------------------------------------------------------*/
  67 /*                             Destructor                                  */
  68
  69 FieldDescFactoryBase::~FieldDescFactoryBase(void)
  70 {
  71     // At this point, the Log is already destroyed
  72     //SINFO << "INFO: Destroy Singleton FieldDescFactory" << std::endl;
  73 }
  74
  75 /*-------------------------------------------------------------------------*/
  76 /*                               Create                                    */
  77
  78 Field *FieldDescFactoryBase::createField(UInt32 typeId)
  79 {
  80 #if 0
  81     FieldType *pType = getFieldType(typeId);
  82
  83
  84     if((pType                != NULL) &&
  85        (pType->_createMethod != NULL))
  86     {
  87         return pType->_createMethod();
  88     }
  89     else
  90     {
  91         return NULL;
  92     }
  93 #else
  94     return NULL;
  95 #endif
  96 }
  97
  98 Field *FieldDescFactoryBase::createField(const Char8 *szName)
  99 {
 100 #if 0
 101     FieldType *pType          = getFieldType(szName);
 102
 103     if((pType                != NULL) &&
 104        (pType->_createMethod != NULL))
 105     {
 106         return pType->_createMethod();
 107     }
 108     else
 109     {
 110         return NULL;
 111     }
 112 #else
 113     return NULL;
 114 #endif
 115 }
 116
 117 /*-------------------------------------------------------------------------*/
 118 /*                                Get                                      */
 119
 120 UInt32 FieldDescFactoryBase::getNumFieldTypes(void)
 121 {
 122 #if 0
 123     if(_fieldTypeM != NULL)
 124         return _fieldTypeM->size();
 125 #endif
 126
 127     return 0;
 128 }
 129
 130 FieldType *FieldDescFactoryBase::getFieldType(const Char8 *szName)
 131 {
 132 #if 0
 133     std::map<UInt32, FieldType *>::iterator  mIt;
 134     FieldType                               *returnValue = NULL;
 135
 136     if(_fieldTypeM != NULL)
 137     {
 138         mIt = _fieldTypeM->begin();
 139
 140         while(mIt != _fieldTypeM->end())
 141         {
 142             if(strcmp(szName, (*mIt).second->getCName()) == 0)
 143             {
 144                 returnValue = (*mIt).second;
 145                 break;
 146             }
 147
 148             mIt++;
 149         }
 150     }
 151
 152     return returnValue;
 153 #else
 154     return NULL;
 155 #endif
 156 }
 157
 158 FieldType *FieldDescFactoryBase::getFieldType(UInt32 typeId)
 159 {
 160 #if 0
 161     std::map<UInt32, FieldType *>::iterator  mIt;
 162
 163     if(_fieldTypeM == NULL)
 164         return NULL;
 165
 166     mIt = _fieldTypeM->find(typeId);
 167
 168     if(mIt != _fieldTypeM->end())
 169     {
 170         return (*mIt).second;
 171     }
 172     else
 173     {
 174         return NULL;
 175     }
 176 #else
 177     return NULL;
 178 #endif
 179 }
 180
 181 const Char8 *FieldDescFactoryBase::getFieldTypeName(UInt32 typeId)
 182 {
 183 #if 0
 184     FieldType *pFieldType = getFieldType(typeId);
 185
 186     return pFieldType ? pFieldType->getCName() : NULL;
 187 #else
 188     return NULL;
 189 #endif
 190 }
 191
 192 FieldDescriptionBase *FieldDescFactoryBase::createByName(
 193     const Char8           *szFieldTypename,
 194     const Char8           *szFieldname,
 195           FieldEditMethod  fEditMethod,
 196           FieldGetMethod   fGetMethod,
 197           UInt32           uiFieldFlags )
 198 {
 199     if(szFieldTypename == NULL)
 200     {
 201         FWARNING(("FieldDescFactory::create, no typename given\n"));
 202
 203         return NULL;
 204     }
 205
 206     FieldDescriptionBase *returnValue = NULL;
 207     std::string           tmpStr      = szFieldTypename;
 208
 209     NameCreatorMapConstIt ncIt = _mNameCreatorMap.find(tmpStr);
 210
 211     if(ncIt != _mNameCreatorMap.end())
 212     {
 213         if(ncIt->second.first)
 214         {
 215             returnValue = ncIt->second.first(szFieldname,
 216                                              uiFieldFlags,
 217
 218                                              fEditMethod,
 219                                              fGetMethod);
 220         }
 221         else
 222         {
 223             FWARNING(("no desc creator registered for %s\n",
 224                       szFieldTypename));
 225         }
 226     }
 227     else
 228     {
 229         FWARNING(("could not find desc creator for %s\n",
 230                   szFieldTypename));
 231     }
 232
 233     return returnValue;
 234 }
 235
 236 FieldDescriptionBase *FieldDescFactoryBase::createByNameIdx(
 237     const Char8               *szFieldTypename,
 238     const Char8               *szFieldname,
 239           FieldIndexEditMethod fEditMethod,
 240           FieldIndexGetMethod  fGetMethod,
 241           UInt32               uiFieldFlags )
 242 {
 243     if(szFieldTypename == NULL)
 244     {
 245         FWARNING(("FieldDescFactory::createIdx, no typename given\n"));
 246
 247         return NULL;
 248     }
 249
 250     FieldDescriptionBase *returnValue = NULL;
 251     std::string           tmpStr      = szFieldTypename;
 252
 253     NameCreatorMapConstIt ncIt = _mNameCreatorMap.find(tmpStr);
 254
 255     if(ncIt != _mNameCreatorMap.end())
 256     {
 257         if(ncIt->second.second)
 258         {
 259             returnValue = ncIt->second.second(szFieldname,
 260                                               uiFieldFlags,
 261
 262                                               fEditMethod,
 263                                               fGetMethod);
 264         }
 265         else
 266         {
 267             FWARNING(("no desc idx creator registered for %s\n",
 268                       szFieldTypename));
 269         }
 270     }
 271     else
 272     {
 273         FWARNING(("could not find desc idx creator for %s\n",
 274                   szFieldTypename));
 275     }
 276
 277     return returnValue;
 278 }
 279
 280
 281 FieldDescriptionBase *FieldDescFactoryBase::create(
 282           UInt32           uiFieldTypeId,
 283     const Char8           *szFieldname,
 284           FieldEditMethod  fEditMethod,
 285           FieldGetMethod   fGetMethod,
 286           UInt32           uiFieldFlags )
 287 {
 288     if(uiFieldTypeId >= _vCreators.size())
 289     {
 290         FWARNING(("FieldDescFactory::create, unknown type id %d (%"PRISize")\n",
 291                    uiFieldTypeId,
 292                   _vCreators.size()));
 293
 294         return NULL;
 295     }
 296
 297     FieldDescriptionBase *returnValue = NULL;
 298
 299     if(_vCreators[uiFieldTypeId].first)
 300     {
 301         returnValue = _vCreators[uiFieldTypeId].first(szFieldname,
 302                                                       uiFieldFlags,
 303
 304                                                       fEditMethod,
 305                                                       fGetMethod);
 306     }
 307     else
 308     {
 309         FWARNING(("no desc creator registered for %d\n",
 310                   uiFieldTypeId));
 311     }
 312
 313     return returnValue;
 314 }
 315
 316 FieldDescriptionBase *FieldDescFactoryBase::createIdx(
 317           UInt32               uiFieldTypeId,
 318     const Char8               *szFieldname,
 319           FieldIndexEditMethod fEditMethod,
 320           FieldIndexGetMethod  fGetMethod,
 321           UInt32               uiFieldFlags )
 322 {
 323     if(uiFieldTypeId >= _vCreators.size())
 324     {
 325         FWARNING(("FieldDescFactory::createIdx, unknown type id %d (%"
 326                   PRISize")\n",
 327
 328                    uiFieldTypeId,
 329                   _vCreators.size()));
 330
 331         return NULL;
 332     }
 333
 334     FieldDescriptionBase *returnValue = NULL;
 335
 336     if(_vCreators[uiFieldTypeId].second)
 337     {
 338         returnValue = _vCreators[uiFieldTypeId].second(szFieldname,
 339                                                        uiFieldFlags,
 340
 341                                                        fEditMethod,
 342                                                        fGetMethod);
 343     }
 344     else
 345     {
 346         FWARNING(("no desc idx creator registered for %d\n",
 347                   uiFieldTypeId));
 348     }
 349
 350     return returnValue;
 351 }
 352
 353 /*-------------------------------------------------------------------------*/
 354 /*                                 the                                     */
 355
 356 void FieldDescFactoryBase::registerDescription(
 357     const Char8                   *szFieldTypename,
 358           UInt32                   uiTypeId,
 359           FieldDescCreator         fCreator,
 360           IndexedFieldDescCreator  fIdxCreator    )
 361 {
 362     if(szFieldTypename == NULL)
 363         return;
 364
 365 //    fprintf(stderr, "register %s (%d)\n", szFieldTypename, uiTypeId);
 366
 367     std::string tmpStr = szFieldTypename;
 368
 369     NameCreatorMapConstIt ncIt = _mNameCreatorMap.find(tmpStr);
 370
 371     if(ncIt == _mNameCreatorMap.end())
 372     {
 373         DescCreators tmpCreators;
 374
 375         tmpCreators.first  = fCreator;
 376         tmpCreators.second = fIdxCreator;
 377
 378         _mNameCreatorMap[tmpStr] = tmpCreators;
 379
 380         if(uiTypeId >= _vCreators.size())
 381         {
 382             _vCreators.resize(uiTypeId + 1);
 383         }
 384
 385         _vCreators[uiTypeId] = tmpCreators;
 386     }
 387     else
 388     {
 389         FWARNING(("could not add second desc creator for %s\n",
 390                   szFieldTypename));
 391     }
 392 }
 393
 394 /*-------------------------------------------------------------------------*/
 395 /*                            Constructors                                 */
 396
 397 FieldDescFactoryBase::FieldDescFactoryBase(void) :
 398      Inherited      ("FieldDescFactory"),
 399     _mNameCreatorMap(                  ),
 400     _vCreators      (                  )
 401 {
 402     FactoryController::the()->registerFactory(this);
 403 }
 404
 405
 406 bool FieldDescFactoryBase::initialize(void)
 407 {
 408 //    fprintf(stderr, "FieldDescFactoryBase::initialize\n");
 409
 410     return true;
 411 }
 412
 413
 414 bool FieldDescFactoryBase::terminate(void)
 415 {
 416 //    fprintf(stderr, "FieldDescFactoryBase::terminate\n");
 417
 418     return true;
 419 }
 420
 421
 422 bool FieldDescFactoryBase::initializePendingElements(void)
 423 {
 424 //    fprintf(stderr, "FieldDescFactoryBase::initializePendingElements\n");
 425
 426     return true;
 427 }
 428
 429
 430 bool FieldDescFactoryBase::initializeFactoryPost(void)
 431 {
 432 //    fprintf(stderr, "FieldDescFactoryBase::initializeFactoryPost\n");
 433
 434     return true;
 435 }
 436
 437 bool FieldDescFactoryBase::initializePendingElementsFactoryPost(void)
 438 {
 439 //    fprintf(stderr,
 440 //            "FieldDescFactoryBase::initializePendingElementsFactoryPost\n");
 441
 442     return true;
 443 }
 444
 445 /*-------------------------------------------------------------------------*/
 446 /*                                 Add                                     */
 447
 448 #if 0
 449 void FieldDescFactoryBase::registerType(FieldType *pType)
 450 {
 451 }
 452
 453 void FieldDescFactoryBase::addType(FieldType *pType)
 454 {
 455     if(pType == NULL)
 456         return;
 457
 458     if(getFieldType(pType->getId()) != NULL)
 459         return;
 460
 461     if(_fieldTypeM == NULL)
 462         _fieldTypeM = new std::map<UInt32, FieldType *>();
 463
 464     (*_fieldTypeM)[pType->getId()] = pType;
 465 }
 466 #endif
 467
 468 OSG_END_NAMESPACE