osg::BINWriter Class Reference
[File Input/Output]

#include <OSGBINWriter.h>

List of all members.

Public Member Functions
Constructors/Destructor
	BINWriter (std::ostream &os)
virtual	~BINWriter (void)
write
bool	write (NodePtr node)
bool	write (std::vector< NodePtr > nodes)
Protected Types
Type information
typedef std::map< UInt32, FCInfo >	FCInfoMap
typedef std::map< std::string, std::vector< UInt32 > >	FCTypeIdMap
Protected Member Functions
Helper
void	addToIdMap (FieldContainerPtr fcPtr)
void	writeFileHeader (void)
void	doIndexFC (FieldContainerPtr fieldConPtr)
void	doWriteIndexedFC (void)
Private Member Functions
	BINWriter (const BINWriter &source)
void	operator= (const BINWriter &source)
Private Attributes
provate members
FCInfoMap	_fcMap
FCTypeIdMap	_fcIdMap
BinaryFileHandler	_outFileHandler
std::vector< NodePtr >	_vec_pRootNodes
bool	_valid_stream
Classes
class	BinaryFileHandler
struct	FCInfo

---

Detailed Description

OpenSG propritrary file writer

Definition at line 55 of file OSGBINWriter.h.

---

Member Typedef Documentation

typedef std::map< UInt32, FCInfo > osg::BINWriter::FCInfoMap [protected]

Definition at line 92 of file OSGBINWriter.h.

typedef std::map<std::string, std::vector<UInt32> > osg::BINWriter::FCTypeIdMap [protected]

Definition at line 93 of file OSGBINWriter.h.

---

Constructor & Destructor Documentation

BINWriter::BINWriter

(

std::ostream &

os

)

Definition at line 70 of file OSGBINWriter.cpp.

                                   :
    _fcMap(),
    _fcIdMap(),
    _outFileHandler(os),
    _vec_pRootNodes(),
    _valid_stream(os != false)
{
}

BINWriter::~BINWriter

(

void

)

[virtual]

Destructor documentation

Definition at line 81 of file OSGBINWriter.cpp.

{
}

osg::BINWriter::BINWriter

(

const BINWriter &

source

)

[private]

---

Member Function Documentation

bool BINWriter::write

(

NodePtr

node

)

write contents of a single root node

Definition at line 90 of file OSGBINWriter.cpp.

References _fcIdMap, _fcMap, _outFileHandler, _valid_stream, _vec_pRootNodes, doIndexFC(), doWriteIndexedFC(), osg::BinaryDataHandler::flush(), SWARNING, and writeFileHeader().

Referenced by osg::BINSceneFileType::write().

{
    if(!_valid_stream)
    {
        SWARNING << "BINLoader::write : Stream is invalid!" << std::endl;
        return false;
    }

    _fcMap.clear();
    _fcIdMap.clear();
    _vec_pRootNodes.clear();
    _vec_pRootNodes.push_back(node);

    // traverse and index containers to write
    doIndexFC(node);

    // write the header with number and type of containers
    writeFileHeader();

    // write the containers and flush the filehandler
    doWriteIndexedFC();
    _outFileHandler.flush();

    return true;
}

bool BINWriter::write

(

std::vector< NodePtr >

nodes

)

write contents of a vector of nodes

Definition at line 118 of file OSGBINWriter.cpp.

References _fcIdMap, _fcMap, _outFileHandler, _valid_stream, _vec_pRootNodes, doIndexFC(), doWriteIndexedFC(), osg::BinaryDataHandler::flush(), SWARNING, and writeFileHeader().

{
    if(!_valid_stream)
    {
        SWARNING << "BINLoader::write : Stream is invalid!" << std::endl;
        return false;
    }

    //does the same as write(NodePtr) for every Node in the vector
    _fcMap.clear();
    _fcIdMap.clear();
    _vec_pRootNodes.clear();
    _vec_pRootNodes = nodes;

    std::vector < NodePtr >::const_iterator iter = nodes.begin();
    for(; iter != nodes.end(); ++iter)
    {
        doIndexFC(*iter);
    }

    writeFileHeader();
    doWriteIndexedFC();
    _outFileHandler.flush();

    return true;
}

void BINWriter::addToIdMap

(

FieldContainerPtr

fcPtr

)

[protected]

Add new container to the mapping table

Definition at line 150 of file OSGBINWriter.cpp.

References _fcIdMap, osg::FieldContainerPtrBase::getFieldContainerId(), osg::NullFC, and SWARNING.

Referenced by doIndexFC().

{
    if(fcPtr == NullFC)
    {
        SWARNING << "ERROR in BINWriter::addToIdMap : NullFC" << std::endl;
        return;
    }

    FCTypeIdMap::iterator   iIdMap;

    // add new ContainerType
    if(_fcIdMap.find(fcPtr->getType().getCName()) == _fcIdMap.end())
    {
        std::vector < UInt32 > idVec;
        idVec.push_back(0);
        if(!(_fcIdMap.insert(std::pair < std::string,
                             std::vector < UInt32 > >
                             (fcPtr->getType().getCName(), idVec)).second))
        {
            SWARNING <<
                "BINWriter::addToIdMap(FieldContainerPtr):" <<
                std::endl <<
                "ERROR while inserting into _fcIdMap" <<
                std::endl;
        };
    }

    // add container to the vector of appropriate type
    iIdMap = _fcIdMap.find(fcPtr->getType().getCName());
    iIdMap->second.push_back(fcPtr.getFieldContainerId());

    //increase the 0th entry of the vector (number of entries)
    iIdMap->second[0]++;
}

void BINWriter::writeFileHeader

(

void

)

[protected]

Write a file header containing the following:

    Number (k) of roots (osg::UInt32)
    {
        root IDs (osg::UInt32)
    } (k times)

    Number(i) of different containertypes (osg::UInt32)
    {
        containertype (std::string)
        number(j) of appropriate containers (osg::UInt32)
        {
            container Ids (osg::UInt32)
        } (j times)
    } (i times)
    

Definition at line 202 of file OSGBINWriter.cpp.

References _fcIdMap, _outFileHandler, _vec_pRootNodes, and osg::BinaryDataHandler::putValue().

Referenced by write().

{
    FCTypeIdMap::iterator   iIdMap = _fcIdMap.begin();
    std::vector < NodePtr >::iterator iRoots = _vec_pRootNodes.begin();

    UInt32  mapSize = _fcIdMap.size();
    UInt32  numOfRoots = _vec_pRootNodes.size();
    UInt32  i = 0;

    _outFileHandler.putValue(numOfRoots);
    for(i = 0; i != numOfRoots; ++i, ++iRoots)
    {
        _outFileHandler.putValue(iRoots->getFieldContainerId());
    }

    _outFileHandler.putValue(mapSize);
    for(i = 0; i < mapSize; ++i, ++iIdMap)
    {
        _outFileHandler.putValue(iIdMap->first);

        std::vector < UInt32 >::iterator intIt = iIdMap->second.begin();
        std::vector < UInt32 >::iterator intEnd = iIdMap->second.end();

        while(intIt != intEnd)
        {
            _outFileHandler.putValue(*intIt);

            ++intIt;
        }
    }
}

void BINWriter::doIndexFC

(

FieldContainerPtr

fieldConPtr

)

[protected]

collect fc and contained fcs. Ignore internal field.

Definition at line 236 of file OSGBINWriter.cpp.

References _fcMap, addToIdMap(), osg::Field::getCardinality(), osg::Node::getClassType(), osg::FieldDescription::getCName(), osg::TypeBase::getCName(), osg::FieldContainerPtrBase::getFieldContainerId(), osg::FieldContainerType::getFieldDescription(), osg::FieldDescription::getFieldMask(), osg::FieldContainerType::getNumFieldDescs(), osg::Field::getType(), osg::Field::isEmpty(), osg::FieldDescription::isInternal(), osg::BINWriter::FCInfo::mask, osg::FieldType::MULTI_FIELD, osg::NullFC, osg::BINWriter::FCInfo::ptr, osg::FieldType::SINGLE_FIELD, osg::BINWriter::FCInfo::type, and osg::Node::VolumeFieldMask.

Referenced by write().

{
    // traverse
    if(fieldConPtr == NullFC)
    {
        // nothing to do
        return;
    }

    FieldContainerType  &fcType = fieldConPtr->getType();
    UInt32 i;

    // insert into map
    std::pair < std::map<UInt32, FCInfo>::iterator, bool > element = _fcMap.
        insert(std::pair < UInt32,
                   FCInfo > (fieldConPtr.getFieldContainerId(), FCInfo()));

    // avoid loop. Element was already in the map
    if(element.second == false)
    {
        return;
    }

    // get inserted element
    FCInfo  &fcInfo = element.first->second;

    //go through all fields
    for(i = 1; i <= fcType.getNumFieldDescs(); ++i)
    {
        FieldDescription    *fDesc = fcType.getFieldDescription(i);
        Field               *fieldPtr = fieldConPtr->getField(i);
        const FieldType     &fType = fieldPtr->getType();

        // process all containers
        if(!fDesc->isInternal())
        {
            //detect referenced containers #DIRTY-HACK#
            if(strstr(fType.getCName(), "Ptr") != NULL)
            {
                //traverse the referenced SF/MF-containers
                if(fieldPtr->getCardinality() == FieldType::SINGLE_FIELD)
                {
                    doIndexFC(((SFFieldContainerPtr *) fieldPtr)->getValue());
                }
                else if(fieldPtr->getCardinality() == FieldType::MULTI_FIELD)
                {
                    UInt32 j;
                    for(j = 0; j < ((MFFieldContainerPtr *) fieldPtr)->size();
                                            ++j)
                    {
                        doIndexFC((*(((MFFieldContainerPtr *) fieldPtr)))[j]);
                    }
                }
            }

            //attachments
            if(strcmp(fDesc->getCName(), "attachments") == 0)
            {
                AttachmentMap::const_iterator   mapIt =
                    ((SFAttachmentMap *) fieldPtr)->getValue().begin();
                AttachmentMap::const_iterator   mapEnd =
                    ((SFAttachmentMap *) fieldPtr)->getValue().end();

                for(; mapIt != mapEnd; ++mapIt)
                {
                    /*
                    fprintf(stderr, "Write %s %s\n",
                                                mapIt->second->getType().getCName(),
                                                GenericAtt::getClassType().getCName());
                    */

                    doIndexFC(mapIt->second);
                }
            }
        }

        // create field mask
        // ignore internal fields except parent fields
        if(fDesc->isInternal() &&
                   strcmp(fDesc->getCName(), "parent") != 0 &&
                   strcmp(fDesc->getCName(), "parents") != 0)
        {
            continue;
        }

        // ignore node volume
        if(fcType == Node::getClassType() &&
                   fcType.getFieldDescription(i)->getFieldMask()
                       == Node::VolumeFieldMask)
        {
            continue;
        }

        // ignore empty mfields
        if(fieldPtr->getCardinality() == FieldType::MULTI_FIELD &&
                   fieldPtr->isEmpty() == true)
        {
            continue;
        }

        // add field to fieldmask
        fcInfo.mask =
            (
                fcInfo.mask |
                fcType.getFieldDescription(i)->getFieldMask()
            );
    }

    // add container to the Map of containers to write
    fcInfo.ptr = fieldConPtr;
    fcInfo.type = fieldConPtr->getType().getName();

    // add container id to index
    addToIdMap(fcInfo.ptr);
}

void BINWriter::doWriteIndexedFC

(

void

)

[protected]

write field containers

Definition at line 354 of file OSGBINWriter.cpp.

References _fcMap, _outFileHandler, osg::BinaryDataHandler::putValue(), and SINFO.

Referenced by write().

{
    FCInfoMap::const_iterator   i = _fcMap.begin();
    UInt32 mapSize = _fcMap.size(), count = 1;

    for(; i != _fcMap.end(); ++i, ++count)
    {
        SINFO <<
            "writing container " <<
            std::setw(4) <<
            count <<
            "/" <<
            mapSize <<
            "..." <<
            std::endl;

        //for each entry in _fcMap
        //write ID
        _outFileHandler.putValue(i->first);

        //write FieldMask
        _outFileHandler.putValue(i->second.mask);

        //write data
        i->second.ptr->copyToBin(_outFileHandler, i->second.mask);
    }
}

void osg::BINWriter::operator=

(

const BINWriter &

source

)

[private]

---

Member Data Documentation

FCInfoMap osg::BINWriter::_fcMap [private]

Definition at line 130 of file OSGBINWriter.h.

Referenced by doIndexFC(), doWriteIndexedFC(), and write().

FCTypeIdMap osg::BINWriter::_fcIdMap [private]

Definition at line 131 of file OSGBINWriter.h.

Referenced by addToIdMap(), write(), and writeFileHeader().

BinaryFileHandler osg::BINWriter::_outFileHandler [private]

Definition at line 132 of file OSGBINWriter.h.

Referenced by doWriteIndexedFC(), write(), and writeFileHeader().

std::vector<NodePtr> osg::BINWriter::_vec_pRootNodes [private]

Definition at line 133 of file OSGBINWriter.h.

Referenced by write(), and writeFileHeader().

bool osg::BINWriter::_valid_stream [private]

Definition at line 134 of file OSGBINWriter.h.

Referenced by write().

---

The documentation for this class was generated from the following files:

• OSGBINWriter.h
• OSGBINWriter.cpp