Show
Ignore:
Timestamp:
03/21/12 18:36:20 (2 years ago)
Author:
robert
Message:

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgPlugins/osg/XmlStreamOperator.h

    r12808 r13041  
    1919        TEXT_LINE            // A text line, e.g. recording array elements 
    2020    }; 
    21      
     21 
    2222    XmlOutputIterator( std::ostream* ostream, int precision ) 
    2323    :   _readLineType(FIRST_LINE), _prevReadLineType(FIRST_LINE), _hasSubProperty(false) 
     
    2828        _root->type = osgDB::XmlNode::GROUP; 
    2929    } 
    30      
     30 
    3131    virtual ~XmlOutputIterator() {} 
    32      
     32 
    3333    virtual bool isBinary() const { return false; } 
    34      
     34 
    3535    virtual void writeBool( bool b ) 
    3636    { addToCurrentNode( b ? std::string("TRUE") : std::string("FALSE") ); } 
    37      
     37 
    3838    virtual void writeChar( char c ) 
    3939    { _sstream << (short)c; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    40      
     40 
    4141    virtual void writeUChar( unsigned char c ) 
    4242    { _sstream << (unsigned short)c; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    43      
     43 
    4444    virtual void writeShort( short s ) 
    4545    { _sstream << s; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    46      
     46 
    4747    virtual void writeUShort( unsigned short s ) 
    4848    { _sstream << s; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    49      
     49 
    5050    virtual void writeInt( int i ) 
    5151    { _sstream << i; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    52      
     52 
    5353    virtual void writeUInt( unsigned int i ) 
    5454    { _sstream << i; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    55      
     55 
    5656    virtual void writeLong( long l ) 
    5757    { _sstream << l; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    58      
     58 
    5959    virtual void writeULong( unsigned long l ) 
    6060    { _sstream << l; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    61      
     61 
    6262    virtual void writeFloat( float f ) 
    6363    { _sstream << f; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    64      
     64 
    6565    virtual void writeDouble( double d ) 
    6666    { _sstream << d; addToCurrentNode( _sstream.str() ); _sstream.str(""); } 
    67      
     67 
    6868    virtual void writeString( const std::string& s ) 
    6969    { addToCurrentNode( s, true ); } 
     
    9090            else if ( _readLineType==TEXT_LINE ) 
    9191                addToCurrentNode( fn ); 
    92              
     92 
    9393            setLineType( NEW_LINE ); 
    9494        } 
     
    9696            addToCurrentNode( fn ); 
    9797    } 
    98      
     98 
    9999    virtual void writeBase( std::ios_base& (*fn)(std::ios_base&) ) 
    100100    { 
    101101        _sstream << fn; 
    102102    } 
    103      
     103 
    104104    virtual void writeGLenum( const osgDB::ObjectGLenum& value ) 
    105105    { 
    106         GLenum e = value.get();  
     106        GLenum e = value.get(); 
    107107        const std::string& enumString = osgDB::Registry::instance()->getObjectWrapperManager()->getString("GL", e); 
    108108        addToCurrentNode( enumString, true ); 
    109109    } 
    110      
     110 
    111111    virtual void writeProperty( const osgDB::ObjectProperty& prop ) 
    112112    { 
     
    137137        } 
    138138    } 
    139      
     139 
    140140    virtual void writeMark( const osgDB::ObjectMark& mark ) 
    141141    { 
     
    150150        } 
    151151    } 
    152      
     152 
    153153    virtual void writeCharArray( const char* s, unsigned int size ) {} 
    154      
     154 
    155155    virtual void writeWrappedString( const std::string& str ) 
    156156    { 
     
    167167        addToCurrentNode( realStr ); 
    168168    } 
    169      
     169 
    170170    virtual void flush() 
    171171    { 
     
    175175        xmlRoot->write( *_out ); 
    176176    } 
    177      
     177 
    178178protected: 
    179179    void addToCurrentNode( const std::string& str, bool isString=false ) 
     
    184184            return; 
    185185        } 
    186          
     186 
    187187        if ( _readLineType==NEW_LINE ) 
    188188        { 
     
    196196                setLineType( TEXT_LINE ); 
    197197        } 
    198          
     198 
    199199        if ( _readLineType==TEXT_LINE ) 
    200200        { 
     
    214214        } 
    215215    } 
    216      
     216 
    217217    void addToCurrentNode( std::ostream& (*fn)(std::ostream&) ) 
    218218    { 
     
    226226        } 
    227227    } 
    228      
     228 
    229229    osgDB::XmlNode* pushNode( const std::string& name ) 
    230230    { 
    231231        osg::ref_ptr<osgDB::XmlNode> node = new osgDB::XmlNode; 
    232232        node->type = osgDB::XmlNode::ATOM; 
    233          
     233 
    234234        // Set element name without '#' and '::' characters 
    235235        std::string realName; 
     
    239239        { 
    240240            realName = name; 
    241              
     241 
    242242            std::string::size_type pos = realName.find("::"); 
    243243            if ( pos!=std::string::npos ) 
     
    245245        } 
    246246        node->name = realName; 
    247          
     247 
    248248        if ( _nodePath.size()>0 ) 
    249249        { 
     
    253253        else 
    254254            _root->children.push_back(node); 
    255          
     255 
    256256        _nodePath.push_back( node.get() ); 
    257257        return node.get(); 
    258258    } 
    259      
     259 
    260260    osgDB::XmlNode* popNode() 
    261261    { 
     
    270270        return node; 
    271271    } 
    272      
     272 
    273273    void trimEndMarkers( osgDB::XmlNode* node, const std::string& name ) 
    274274    { 
    275275        osgDB::XmlNode::Properties::iterator itr = node->properties.find(name); 
    276276        if ( itr==node->properties.end() ) return; 
    277          
     277 
    278278        std::string& str = itr->second; 
    279279        if ( !str.empty() ) 
     
    283283            str.erase( end+1 ); 
    284284        } 
    285          
     285 
    286286        if ( str.empty() ) 
    287287            node->properties.erase(itr); 
    288288    } 
    289      
     289 
    290290    void setLineType( ReadLineType type ) 
    291291    { 
     
    293293        _readLineType = type; 
    294294    } 
    295      
     295 
    296296    typedef std::vector<osgDB::XmlNode*> XmlNodePath; 
    297297    XmlNodePath _nodePath; 
    298      
     298 
    299299    osg::ref_ptr<osgDB::XmlNode> _root; 
    300300    std::stringstream _sstream; 
    301      
     301 
    302302    ReadLineType _readLineType; 
    303303    ReadLineType _prevReadLineType; 
     
    312312        _in = istream; 
    313313        _root = osgDB::readXmlStream( *istream ); 
    314          
     314 
    315315        if ( _root.valid() && _root->children.size()>0 ) 
    316316            _nodePath.push_back( _root->children[0] ); 
    317317    } 
    318      
     318 
    319319    virtual ~XmlInputIterator() {} 
    320      
     320 
    321321    virtual bool isBinary() const { return false; } 
    322      
     322 
    323323    virtual void readBool( bool& b ) 
    324324    { 
     
    328328        else b = false; 
    329329    } 
    330      
     330 
    331331    virtual void readChar( char& c ) 
    332332    { 
     
    335335        c = (char)s; 
    336336    } 
    337      
     337 
    338338    virtual void readSChar( signed char& c ) 
    339339    { 
     
    342342        c = (signed char)s; 
    343343    } 
    344      
     344 
    345345    virtual void readUChar( unsigned char& c ) 
    346346    { 
     
    349349        c = (unsigned char)s; 
    350350    } 
    351      
     351 
    352352    virtual void readShort( short& s ) 
    353353    { std::string str; if (prepareStream()) _sstream >> str; s = static_cast<short>(strtol(str.c_str(), NULL, 0)); } 
    354      
     354 
    355355    virtual void readUShort( unsigned short& s ) 
    356356    { std::string str; if (prepareStream()) _sstream >> str; s = static_cast<unsigned short>(strtoul(str.c_str(), NULL, 0)); } 
    357      
     357 
    358358    virtual void readInt( int& i ) 
    359359    { std::string str; if (prepareStream()) _sstream >> str; i = static_cast<int>(strtol(str.c_str(), NULL, 0)); } 
    360      
     360 
    361361    virtual void readUInt( unsigned int& i ) 
    362362    { std::string str; if (prepareStream()) _sstream >> str; i = static_cast<unsigned int>(strtoul(str.c_str(), NULL, 0)); } 
    363      
     363 
    364364    virtual void readLong( long& l ) 
    365365    { std::string str; if (prepareStream()) _sstream >> str; l = strtol(str.c_str(), NULL, 0); } 
    366      
     366 
    367367    virtual void readULong( unsigned long& l ) 
    368368    { std::string str; if (prepareStream()) _sstream >> str; l = strtoul(str.c_str(), NULL, 0); } 
    369      
     369 
    370370    virtual void readFloat( float& f ) 
    371371    { std::string str; if (prepareStream()) _sstream >> str; f = osg::asciiToFloat(str.c_str()); } 
    372      
     372 
    373373    virtual void readDouble( double& d ) 
    374374    { std::string str; if (prepareStream()) _sstream >> str; d = osg::asciiToDouble(str.c_str()); } 
    375      
     375 
    376376    virtual void readString( std::string& s ) 
    377377    { 
    378378        if ( prepareStream() ) _sstream >> s; 
    379          
     379 
    380380        // Replace '--' to '::' to get correct wrapper class 
    381381        std::string::size_type pos = s.find("--"); 
     
    383383            s.replace( pos, 2, "::" ); 
    384384    } 
    385      
     385 
    386386    virtual void readStream( std::istream& (*fn)(std::istream&) ) 
    387387    { if ( prepareStream() ) _sstream >> fn; } 
    388      
     388 
    389389    virtual void readBase( std::ios_base& (*fn)(std::ios_base&) ) 
    390390    { _sstream >> fn; } 
    391      
     391 
    392392    virtual void readGLenum( osgDB::ObjectGLenum& value ) 
    393393    { 
     
    398398        value.set( e ); 
    399399    } 
    400      
     400 
    401401    virtual void readProperty( osgDB::ObjectProperty& prop ) 
    402402    { 
     
    414414            if ( pos!=std::string::npos ) 
    415415                enumString.replace( pos, 2, "::" ); 
    416              
     416 
    417417            if ( prop._name!=enumString ) 
    418418            { 
     
    429429        prop.set( value ); 
    430430    } 
    431      
     431 
    432432    virtual void readMark( osgDB::ObjectMark& mark ) {} 
    433      
     433 
    434434    virtual void readCharArray( char* s, unsigned int size ) {} 
    435      
     435 
    436436    virtual void readWrappedString( std::string& str ) 
    437437    { 
    438438        if ( !prepareStream() ) return; 
    439          
     439 
    440440        // Read available string in the stream buffer 
    441441        unsigned int availSize = _sstream.rdbuf()->in_avail(); 
    442442        std::string realStr = _sstream.str(); 
    443443        _sstream.str(""); 
    444          
     444 
    445445        // Find the first quot or valid character 
    446446        bool hasQuot = false; 
     
    480480        } 
    481481    } 
    482      
     482 
    483483    virtual bool matchString( const std::string& str ) 
    484484    { 
     
    492492        return false; 
    493493    } 
    494      
     494 
    495495    virtual void advanceToCurrentEndBracket() {} 
    496      
     496 
    497497protected: 
    498498    bool isReadable() const { return _sstream.rdbuf()->in_avail()>0; } 
    499      
     499 
    500500    bool prepareStream() 
    501501    { 
     
    503503        if ( isReadable() ) return true; 
    504504        _sstream.clear(); 
    505          
     505 
    506506        osgDB::XmlNode* current = _nodePath.back().get(); 
    507507        if ( current->type!=osgDB::XmlNode::COMMENT ) 
     
    513513                return true; 
    514514            } 
    515              
     515 
    516516            if ( current->properties.size()>0 ) 
    517517            { 
     
    519519                else if ( applyPropertyToStream(current, "text") ) return true; 
    520520            } 
    521              
     521 
    522522            if ( current->children.size()>0 ) 
    523523            { 
     
    530530        return prepareStream(); 
    531531    } 
    532      
     532 
    533533    bool applyPropertyToStream( osgDB::XmlNode* node, const std::string& name ) 
    534534    { 
     
    542542        return false; 
    543543    } 
    544      
     544 
    545545    typedef std::vector< osg::ref_ptr<osgDB::XmlNode> > XmlNodePath; 
    546546    XmlNodePath _nodePath; 
    547      
     547 
    548548    osg::ref_ptr<osgDB::XmlNode> _root; 
    549549    std::stringstream _sstream;