Beispiel #1
0
void OSGLoader::setFieldContainerValue(FieldContainer *pNewNode)
{
    if(_pCurrentField != NULL)
    {
        FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrSFieldBase::EditHandle>(
                    _pCurrentField);

        FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrMFieldBase::EditHandle>(
                    _pCurrentField);

        EditMapFieldHandlePtr pMapHandle = 
            boost::dynamic_pointer_cast<
                EditMapFieldHandle>(_pCurrentField);

        if(pSFHandle != NULL && pSFHandle->isValid())
        {
            pSFHandle->set(pNewNode);
        }
        else if(pMFHandle != NULL && pMFHandle->isValid())
        {
            pMFHandle->add(pNewNode);
        }
        else if(pMapHandle != NULL && pMapHandle->isValid())
        {
            pMapHandle->add(pNewNode, "0");
        }
    }
}
/*\brief Sets a pointer single-field via its generic FieldContainer*.      */
void PyFieldAccessHandler::setPtrSField(const std::string& fieldName,
                                        FieldContainer*    value)
{
    EditFieldHandlePtr handle = _pPythonScript->editDynamicFieldByName(fieldName.c_str());

    FieldContainerPtrSFieldBase::EditHandlePtr sfFCPtr =
        boost::dynamic_pointer_cast<
            FieldContainerPtrSFieldBase::EditHandle>(handle);
    assert(sfFCPtr);

    sfFCPtr->set(value);
}
/*        correct type.                                                */
FieldContainerTransitPtr PyFieldAccessHandler::changePtrSField(const std::string& fieldName)
{
    EditFieldHandlePtr handle = _pPythonScript->editDynamicFieldByName(fieldName.c_str());

    FieldContainerPtrSFieldBase::EditHandlePtr sfFCPtr =
        boost::dynamic_pointer_cast<
            FieldContainerPtrSFieldBase::EditHandle>(handle);
    assert(sfFCPtr);

    FieldContainerPtrSFieldBase* field =
            static_cast<FieldContainerPtrSFieldBase *>(sfFCPtr->getField());
    return FieldContainerTransitPtr(field->getValue());
}
void ComplexSceneManager::processUnresolved(void)
{
    std::vector<DeferredFCUse>::const_iterator uIt  = _vUnresolvedFCs.begin();
    std::vector<DeferredFCUse>::const_iterator uEnd = _vUnresolvedFCs.end  ();

    for(; uIt != uEnd; ++uIt)
    {
        if(uIt->_pDstCnt == NULL)
            continue;

        FieldContainer *pTmpFC = this->findNamedComponent(uIt->_szName.c_str());

        if(pTmpFC == NULL)
        {
            continue;
        }

        EditFieldHandlePtr pDstField = 
            uIt->_pDstCnt->editField(uIt->_uiDstFieldId);

        FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrSFieldBase::EditHandle>(
                    pDstField);

        FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrMFieldBase::EditHandle>(
                    pDstField);

        EditMapFieldHandlePtr pMapHandle = 
            boost::dynamic_pointer_cast<
                EditMapFieldHandle>(pDstField);

        if(pSFHandle != NULL && pSFHandle->isValid())
        {
            pSFHandle->set(pTmpFC);
        }
        else if(pMFHandle != NULL && pMFHandle->isValid())
        {
            pMFHandle->add(pTmpFC);
        }
        else if(pMapHandle != NULL && pMapHandle->isValid())
        {
            pMapHandle->add(pTmpFC, "0");
        }

    }
        
}
/*! Fills the "pointer field" described by \a ptrField with the correct
    pointers.

    \param[in] ptrField Field to fill.
 */
void
OSBRootElement::mapPtrField(const PtrFieldInfo &ptrField)
{
    OSG_OSB_LOG(("OSBRootElement::mapPtrField\n"));

    PtrFieldInfo::PtrIdStoreConstIt   idIt       = ptrField.beginIdStore();
    PtrFieldInfo::PtrIdStoreConstIt   idEnd      = ptrField.endIdStore  ();

    PtrFieldInfo::BindingStoreConstIt bindingIt  = ptrField.beginBindingStore();
    PtrFieldInfo::BindingStoreConstIt bindingEnd = ptrField.endBindingStore  ();

    const FieldContainerIdMap        &idMap      = getIdMap();
          FieldContainerIdMapConstIt  idMapIt;
          FieldContainerIdMapConstIt  idMapEnd   = idMap.end();
        
    if(bindingIt != bindingEnd)
    {
        if(ptrField.getHandledField() == true)
        {
            FieldContainer    *fieldCon = ptrField.getContainer();
            UInt32             fieldId  = ptrField.getFieldId();
        
            EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);

            EditMapFieldHandlePtr sfMapField =
                boost::dynamic_pointer_cast<EditMapFieldHandle>(fHandle);

            if(sfMapField == NULL || sfMapField->isValid() == false)
                return;

            sfMapField->fillFrom(ptrField.getBindingStore(),
                                 ptrField.getIdStore     (),
                                 idMap);
        }
        else
        {
            Attachment          *att    = NULL;
            AttachmentContainer *attCon =
                dynamic_cast<AttachmentContainer *>(ptrField.getContainer());
            
            for(; (idIt != idEnd) && (bindingIt != bindingEnd); ++idIt, 
                                                                ++bindingIt)
            {
                if(*idIt != 0)
                {
                    idMapIt = idMap.find(*idIt);
                    
                    if(idMapIt != idMapEnd)
                    {
                        att = dynamic_cast<Attachment *>(
                            FieldContainerFactory::the()->getContainer(
                                idMapIt->second));
                    }
                    else
                    {
                        FWARNING(("OSBRootElement::mapPtrField: could not find "
                                  "FieldContainer with id [%u]\n", *idIt));
                        att = NULL;
                    }
                }
                else
                {
                    att = NULL;
                }
                
                if(att != NULL)
                {
                    OSG_OSB_LOG(("OSBRootElement::mapPtrField: adding "
                            "attchment [%u] [%u]\n",
                            att->getType().getGroupId(), *bindingIt));
                }

                attCon->addAttachment(att, *bindingIt);
            }
        }
    }
    else
    {
        FieldContainer    *fc       = NULL;
        FieldContainer    *fieldCon = ptrField.getContainer();
        UInt32             fieldId  = ptrField.getFieldId();
        
        EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);
        
        FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrSFieldBase::EditHandle>(fHandle);
            
        FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle = 
            boost::dynamic_pointer_cast<
                FieldContainerPtrMFieldBase::EditHandle>(fHandle);
        
        for(; idIt != idEnd; ++idIt)
        {
            if(*idIt != 0)
            {
                idMapIt = idMap.find(*idIt);
                
                if(idMapIt != idMapEnd)
                {
                    fc = FieldContainerFactory::the()->getContainer(
                        idMapIt->second);
                }
                else
                {
                    FWARNING(("OSBRootElement::mapPtrField: could not find "
                              "FieldContainer with (file) id [%u]\n", *idIt));
                    fc = NULL;
                }
            }
            else
            {
                fc = NULL;
            }

            if(pSFHandle != NULL && pSFHandle->isValid())
            {
                pSFHandle->set(fc);
            }
            else if(pMFHandle != NULL && pMFHandle->isValid())
            {
                pMFHandle->add(fc);
            }
            else
            {
                FWARNING(("OSBRootElement::mapPtrField: FieldHandles invalid, "
                          "can not set pointer - target fc [%u][%s] "
                          "fieldId [%u][%s] file id [%u] system id [%u]\n",
                          (fc != NULL ? fc->getId() : 0),
                          (fc != NULL ? fc->getType().getCName() : ""),
                          fieldId,
                          (fc != NULL ?
                          fc->getType().getFieldDesc(fieldId)->getCName() : ""),
                          *idIt,
                          (idMapIt != idMapEnd ? idMapIt->second : 0) ));
            }
        }
    }
}
FieldContainer *SharePtrGraphOp::shareFC(FieldContainer *fc)
{
    if(fc == NULL)
        return fc;

    bool   singleParent = false;
    UInt32 fcTypeId     = fc->getType().getId           ();
    UInt32 fCount       = fc->getType().getNumFieldDescs();


    FCTypeMapIt tmIt = _typeMap.find(fcTypeId);

    if(tmIt == _typeMap.end())
    {
        tmIt =
            _typeMap.insert(FCTypeMap::value_type(fcTypeId, FCSet())).first;
    }

    if(tmIt->second.count(fc) > 0)
        return fc;


    for(UInt32 i = 1; i <= fCount; ++i)
    {
        const FieldDescriptionBase *fDesc = fc->getFieldDescription(i);

        // skip parent fields
        if(fDesc->getFieldType().getClass() == FieldType::ParentPtrField)
        {
            if(fDesc->getFieldType().getCardinality() == FieldType::SingleField)
                singleParent = true;

            continue;
        }

        EditFieldHandlePtr fHandle = fc->editField(i);

        // skip non-pointer fields
#if 1
        if(fDesc->getFieldType().isPtrField() == false)
            continue;
#else
        if(fHandle != NULL)
        {
            if(fHandle->isPointerField() == false)
                continue;
        }
        else
        {
             if(fDesc->getFieldType().isPtrField() == false)
                 continue;
        }
#endif

        // skip internal fields
        if(fDesc->isInternal() == true)
            continue;

        FieldContainerPtrSFieldBase::EditHandlePtr sfPtrHandle =
            boost::dynamic_pointer_cast<
                FieldContainerPtrSFieldBase::EditHandle>(fHandle);

        FieldContainerPtrMFieldBase::EditHandlePtr mfPtrHandle =
            boost::dynamic_pointer_cast<
                FieldContainerPtrMFieldBase::EditHandle>(fHandle);

        if(sfPtrHandle != NULL && sfPtrHandle->isValid() == true)
        {
            FieldContainer *childFC    = sfPtrHandle->get();
            FieldContainer *childEquiv = shareFC(childFC);

            if(childEquiv != childFC)
            {
                sfPtrHandle->set(childEquiv);
            }
        }
        else if(mfPtrHandle != NULL && mfPtrHandle->isValid() == true)
        {
            for(UInt32 j = 0; j < mfPtrHandle->size(); ++j)
            {
                FieldContainer *childFC    = mfPtrHandle->get(j);
                FieldContainer *childEquiv = shareFC(childFC);

                if(childEquiv != childFC)
                {
                    mfPtrHandle->replace(j, childEquiv);
                }
            }
        }
#if 0
        else
        {
            SFAttachmentPtrMap::EditHandlePtr  amEditHandle =
                boost::dynamic_pointer_cast<SFAttachmentPtrMap::EditHandle>(
                    fHandle);

            SFAttachmentPtrMap::GetHandlePtr  amGetHandle =
                boost::dynamic_pointer_cast<SFAttachmentPtrMap::GetHandle>(
                    fc->getField(i));

            if(amEditHandle != NULL && amEditHandle->isValid() == true)
            {
                 const AttachmentMap &oAttMap = (*amGetHandle)->getValue();

                 AttachmentMap::const_iterator amIt  = oAttMap.begin();
                 AttachmentMap::const_iterator amEnd = oAttMap.end  ();

                 for(; amIt != amEnd; ++amIt)
                 {
                     Attachment *att      = (*amIt).second;
                     Attachment *attEquiv =  
                         dynamic_cast<Attachment *>(shareFC(att));

                     if(attEquiv != att)
                     {
                         amEditHandle->replaceByObj(att, attEquiv);
                     }
                 }
            }
        }
#endif
    }

    if(checkIncludeSet(fcTypeId) == false)
        return fc;

    if(checkExcludeSet(fcTypeId) == true)
        return fc;

    // can not share a FC with single parents
    if(singleParent == true)
        return fc;

    FCSetIt fcsIt  = tmIt->second.begin();
    FCSetIt fcsEnd = tmIt->second.end  ();

    for(; fcsIt != fcsEnd; ++fcsIt)
    {
        Time compareStart = getSystemTime();

        bool compare      = compareContainerEqual(*fcsIt, fc, true, true);

        _compareTime += getSystemTime() - compareStart;

        if(compare)
        {
            if(*fcsIt != fc)
                _shareCount[fcTypeId] += 1;

            return *fcsIt;
        }
    }

    // no equivalent FC known, add to set of unique containers
    tmIt->second.insert(fc);

    return fc;
}