OSG::Algorithm Class Reference

00118                          :
00119     Inherited()
00120 {
00121 }

00123                                             :
00124     Inherited(source)
00125 {
00126 }

00132 {
00133 }

00071 {
00072 #if 0
00073     if(whichField & (UrlFieldMask))
00074     {
00075         if(getAbsoluteUrl().empty())
00076         {
00077             PathHandler *ph = SceneFileHandler::the()->getPathHandler();
00078 
00079             if(ph != NULL) 
00080             {
00081                 setAbsoluteUrl(ph->findFile(getUrl().c_str()));
00082             }
00083 
00084             if(getAbsoluteUrl().empty())
00085             {
00086                 setAbsoluteUrl(getUrl());
00087             }
00088 
00089             setState(NOT_LOADED);
00090         }
00091     }
00092     if(whichField & (StateFieldMask |
00093                      UrlFieldMask   |
00094                      VolumeFieldMask))
00095     {
00096         for(UInt32 i = 0; i < _mfParents.size(); i++)
00097         {
00098             _mfParents[i]->invalidateVolume();
00099         }
00100     }
00101 #endif
00102 
00103     Inherited::changed(whichField, origin, details);
00104 }

00146 {
00147     Inherited::initMethod(ePhase);
00148 
00149     if(ePhase == TypeObject::SystemPost)
00150     {
00151     }
00152 }

00057 {
00058     return _type;
00059 }

00064 {
00065     return _type.getId();
00066 }

00070 {
00071     return _type.getGroupId();
00072 }

00112 {
00113     return _type;
00114 }

00117 {
00118     return _type;
00119 }

00122 {
00123     return sizeof(Algorithm);
00124 }

00136 {
00137     UInt32 returnValue = Inherited::getBinSize(whichField);
00138 
00139 
00140     return returnValue;
00141 }

00145 {
00146     Inherited::copyToBin(pMem, whichField);
00147 
00148 }

00152 {
00153     Inherited::copyFromBin(pMem, whichField);
00154 
00155 }

00059 {
00060     FieldDescriptionBase *pDesc = NULL;
00061 
00062     pDesc = new MFChangedFunctorCallback::Description(
00063         MFChangedFunctorCallback::getClassType(),
00064         "changedCallbacks",
00065         "List of callback functors to notify of changes.",
00066         OSG_RC_FIELD_DESC(FieldContainer::ChangedCallbacks),
00067         false,
00068         Field::SFDefaultFlags,
00069         static_cast<FieldEditMethodSig>(&FieldContainer::invalidEditField),
00070         static_cast<FieldGetMethodSig >(&FieldContainer::invalidGetField ));
00071 
00072     oType.addInitialDesc(pDesc);
00073 }

00093 {
00094     return "Algorithm";
00095 }

00199 {
00200     Inherited::resolveLinks();
00201 
00202 
00203 }

00074 {
00075     MFChangedFunctorCallback::iterator       cfIt = _mfChangedFunctors.begin();
00076     MFChangedFunctorCallback::const_iterator cfEnd= _mfChangedFunctors.end();
00077 
00078     while(cfIt != cfEnd)
00079     {
00080         if(cfIt->_func)
00081             (cfIt->_func)(this, whichField);
00082 
00083         ++cfIt;
00084     }
00085 }

00234 {
00235     ChangedFunctorCallback oTmp;
00236 
00237     oTmp._func         = func;
00238     oTmp._uiId         = _mfChangedFunctors.size();
00239     oTmp._createSymbol = createSymbol;
00240 
00241     _mfChangedFunctors.push_back(oTmp);
00242 
00243     return oTmp._uiId;
00244 }

00248 {
00249     MFChangedFunctorCallback::iterator       cfIt = _mfChangedFunctors.begin();
00250     MFChangedFunctorCallback::const_iterator cfEnd= _mfChangedFunctors.end();
00251 
00252     while(cfIt != cfEnd)
00253     {
00254         if(cfIt->_func == func)
00255             break;
00256 
00257         ++cfIt;
00258     }
00259 
00260     if(cfIt != cfEnd)
00261         _mfChangedFunctors.erase(cfIt);
00262 }

00266 {
00267     MFChangedFunctorCallback::iterator       cfIt = _mfChangedFunctors.begin();
00268     MFChangedFunctorCallback::const_iterator cfEnd= _mfChangedFunctors.end();
00269 
00270     while(cfIt != cfEnd)
00271     {
00272         if(cfIt->_uiId == uiId)
00273             break;
00274 
00275         ++cfIt;
00276     }
00277 
00278     if(cfIt != cfEnd)
00279         _mfChangedFunctors.erase(cfIt);
00280 }

00284 {
00285     _mfChangedFunctors.clear();
00286 }

00290 {
00291     return _pFieldFlags;
00292 }

00089 {
00090     ++_iRefCount;
00091     
00092     Thread::getCurrentChangeList()->addAddRefd(Inherited::getId());
00093 
00094 }

00098 {
00099     --_iRefCount;
00100 
00101     if(_iRefCount <= 0)
00102     {
00103         Thread::getCurrentChangeList()->incSubRefLevel();
00104 
00105         this->resolveLinks();
00106 
00107         Thread::getCurrentChangeList()->decSubRefLevel();
00108 
00109         Thread::getCurrentChangeList()->addSubRefd(Inherited::getId());
00110 
00111 #ifdef OSG_MT_CPTR_ASPECT
00112         this->onDestroyAspect(Inherited::getId(), Thread::getCurrentAspect());
00113 
00114         _pAspectStore->removePtrForAspect(Thread::getCurrentAspect());
00115 
00116         if(_pAspectStore->getRefCount() == 1)
00117         {
00118             this->deregister(Inherited::getId());
00119             this->onDestroy (Inherited::getId());
00120         }
00121 
00122         OSG::subRef(_pAspectStore);
00123 #else
00124         this->deregister     (Inherited::getId()   );
00125         this->onDestroyAspect(Inherited::getId(), 0);
00126         this->onDestroy      (Inherited::getId()   );
00127 #endif
00128 
00129         delete this;
00130     }
00131     else
00132     {
00133         Thread::getCurrentChangeList()->addSubRefd(Inherited::getId());
00134     }
00135 
00136 }

00141 {
00142     --_iRefCount;
00143 
00144     if(_iRefCount <= 0)
00145     {
00146 
00147         Thread::getCurrentChangeList()->incSubRefLevel();
00148 
00149         this->resolveLinks();
00150 
00151         Thread::getCurrentChangeList()->decSubRefLevel();
00152 
00153         Thread::getCurrentChangeList()->addSubRefd(Inherited::getId(),
00154                                                    true);
00155 
00156 #ifdef OSG_MT_CPTR_ASPECT
00157         this->onDestroyAspect(Inherited::getId(), Thread::getCurrentAspect());
00158 
00159         _pAspectStore->removePtrForAspect(Thread::getCurrentAspect());
00160 
00161         if(_pAspectStore->getRefCount() == 1)
00162         {
00163             this->deregister(Inherited::getId());
00164             this->onDestroy (Inherited::getId());
00165         }
00166 
00167         OSG::subRef(_pAspectStore);
00168 #else
00169         this->deregister     (Inherited::getId()   );
00170         this->onDestroyAspect(Inherited::getId(), 0);
00171         this->onDestroy      (Inherited::getId()   );
00172 #endif
00173 
00174         delete this;
00175     }
00176     else
00177     {
00178         Thread::getCurrentChangeList()->addSubRefd(Inherited::getId());
00179     }
00180 
00181 }

00185 {
00186     return _iRefCount;
00187 }

00116 {
00117 }