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

Ran script to remove trailing spaces and tabs

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/src/osgDB/Registry.cpp

    r13000 r13041  
    1 /* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield  
     1/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield 
    22 * 
    3  * This library is open source and may be redistributed and/or modified under   
    4  * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or  
     3 * This library is open source and may be redistributed and/or modified under 
     4 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
    55 * (at your option) any later version.  The full license is in LICENSE file 
    66 * included with this distribution, and on the openscenegraph.org website. 
    7  *  
     7 * 
    88 * This library is distributed in the hope that it will be useful, 
    99 * but WITHOUT ANY WARRANTY; without even the implied warranty of 
    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the  
     10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
    1111 * OpenSceneGraph Public License for more details. 
    1212*/ 
     
    7979    ReaderWriter& operator * () { return *get(); } 
    8080    ReaderWriter* operator -> () { return get(); } 
    81      
     81 
    8282    bool valid() { return get()!=0; } 
    83      
    84     void operator ++()  
     83 
     84    void operator ++() 
    8585    { 
    8686        _rwUsed.insert(get()); 
    8787    } 
    88      
     88 
    8989 
    9090protected: 
     
    9494    Registry::ReaderWriterList&     _rwList; 
    9595    OpenThreads::ReentrantMutex&    _pluginMutex; 
    96      
     96 
    9797    std::set<ReaderWriter*>         _rwUsed; 
    9898 
    99     ReaderWriter* get()  
     99    ReaderWriter* get() 
    100100    { 
    101101        OpenThreads::ScopedLock<OpenThreads::ReentrantMutex> lock(_pluginMutex); 
     
    207207{ 
    208208    static ref_ptr<Registry> s_registry = new Registry; 
    209     if (erase)  
    210     {    
     209    if (erase) 
     210    { 
    211211        s_registry->destruct(); 
    212212        s_registry = 0; 
     
    224224    _buildKdTreesHint = Options::NO_PREFERENCE; 
    225225    _kdTreeBuilder = new osg::KdTreeBuilder; 
    226      
     226 
    227227    const char* kdtree_str = getenv("OSG_BUILD_KDTREES"); 
    228228    if (kdtree_str) 
     
    245245    if (fileCachePath) 
    246246    { 
    247         _fileCache = new FileCache(fileCachePath);     
     247        _fileCache = new FileCache(fileCachePath); 
    248248    } 
    249249 
     
    254254    _archiveExtList.push_back("osga"); 
    255255    _archiveExtList.push_back("zip"); 
    256      
     256 
    257257    initFilePathLists(); 
    258258 
     
    292292    addFileExtensionAlias("ivz",  "gz"); 
    293293    addFileExtensionAlias("ozg",  "gz"); 
    294      
     294 
    295295    addFileExtensionAlias("mag",  "dicom"); 
    296296    addFileExtensionAlias("ph",   "dicom"); 
     
    397397 
    398398    #if defined(USE_VRML) 
    399         addFileExtensionAlias("wrl",   "vrml");     
     399        addFileExtensionAlias("wrl",   "vrml"); 
    400400    #elif defined(USE_INVENTOR) 
    401401        addFileExtensionAlias("wrl",   "iv"); 
    402402    #endif 
    403      
     403 
    404404    // add alias for the text/freetype plugin. 
    405405    addFileExtensionAlias("ttf",    "freetype");  // true type 
     
    421421    addFileExtensionAlias("pgm", "pnm"); 
    422422    addFileExtensionAlias("ppm", "pnm"); 
    423      
     423 
    424424 
    425425    // add revision file mappings 
     
    439439        addMimeTypeExtensionMapping( mimeType, builtinMimeTypeExtMappings[i+1] ); 
    440440    } 
    441      
     441 
    442442    // register server protocols, so the curl can handle it, if necessary 
    443443    registerProtocol("http"); 
     
    460460    // OSG_NOTICE<<"Registry::destruct()"<<std::endl; 
    461461 
    462     // clean up the SharedStateManager  
     462    // clean up the SharedStateManager 
    463463    _sharedStateManager = 0; 
    464      
     464 
    465465 
    466466    // clean up the FileCache 
    467467    _fileCache = 0; 
    468      
     468 
    469469 
    470470    // object cache clear needed here to prevent crash in unref() of 
     
    476476    clearObjectCache(); 
    477477    clearArchiveCache(); 
    478      
     478 
    479479 
    480480    // unload all the plugin before we finally destruct. 
     
    491491    // 
    492492    char *ptr; 
    493    
     493 
    494494    if( (ptr = getenv( "OSG_FILE_PATH" )) ) 
    495495    { 
     
    505505    osgDB::appendPlatformSpecificResourceFilePaths(filepath); 
    506506    setDataFilePathList(filepath); 
    507      
     507 
    508508} 
    509509 
    510510void Registry::setDataFilePathList(const std::string& paths) 
    511511{ 
    512     _dataFilePath.clear();  
     512    _dataFilePath.clear(); 
    513513    convertStringPathIntoFilePathList(paths,_dataFilePath); 
    514514} 
     
    534534        setLibraryFilePathList(ptr); 
    535535    } 
    536      
     536 
    537537    appendPlatformSpecificLibraryFilePaths(_libraryFilePath); 
    538538 
     
    555555        loadLibrary(value); 
    556556    } 
    557          
     557 
    558558    while(arguments.read("-e",value)) 
    559559    { 
     
    851851        if((*itr)->acceptsExtension(ext)) return (*itr).get(); 
    852852    } 
    853      
     853 
    854854    // now look for a plug-in to load the file. 
    855855    std::string libraryName = createLibraryNameForExtension(ext); 
     
    881881 
    882882#if 0 
    883 struct concrete_wrapper: basic_type_wrapper  
     883struct concrete_wrapper: basic_type_wrapper 
    884884{ 
    885885    virtual ~concrete_wrapper() {} 
     
    899899    ReadObjectFunctor(const std::string& filename, const Options* options):ReadFunctor(filename,options) {} 
    900900 
    901     virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readObject(_filename, _options); }     
     901    virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readObject(_filename, _options); } 
    902902    virtual bool isValid(ReaderWriter::ReadResult& readResult) const { return readResult.validObject(); } 
    903903    virtual bool isValid(osg::Object* object) const { return object!=0;  } 
     
    910910    ReadImageFunctor(const std::string& filename, const Options* options):ReadFunctor(filename,options) {} 
    911911 
    912     virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw)const  { return rw.readImage(_filename, _options); }     
     912    virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw)const  { return rw.readImage(_filename, _options); } 
    913913    virtual bool isValid(ReaderWriter::ReadResult& readResult) const { return readResult.validImage(); } 
    914914    virtual bool isValid(osg::Object* object) const { return dynamic_cast<osg::Image*>(object)!=0;  } 
     
    921921    ReadHeightFieldFunctor(const std::string& filename, const Options* options):ReadFunctor(filename,options) {} 
    922922 
    923     virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readHeightField(_filename, _options); }     
     923    virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readHeightField(_filename, _options); } 
    924924    virtual bool isValid(ReaderWriter::ReadResult& readResult) const { return readResult.validHeightField(); } 
    925925    virtual bool isValid(osg::Object* object) const { return dynamic_cast<osg::HeightField*>(object)!=0;  } 
     
    932932    ReadNodeFunctor(const std::string& filename, const Options* options):ReadFunctor(filename,options) {} 
    933933 
    934     virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readNode(_filename, _options); }     
     934    virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw) const { return rw.readNode(_filename, _options); } 
    935935    virtual bool isValid(ReaderWriter::ReadResult& readResult) const { return readResult.validNode(); } 
    936936    virtual bool isValid(osg::Object* object) const { return dynamic_cast<osg::Node*>(object)!=0;  } 
     
    945945        _status(status), 
    946946        _indexBlockSizeHint(indexBlockSizeHint) {} 
    947          
     947 
    948948    ReaderWriter::ArchiveStatus _status; 
    949949    unsigned int _indexBlockSizeHint; 
     
    960960    ReadShaderFunctor(const std::string& filename, const Options* options):ReadFunctor(filename,options) {} 
    961961 
    962     virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw)const  { return rw.readShader(_filename, _options); }     
     962    virtual ReaderWriter::ReadResult doRead(ReaderWriter& rw)const  { return rw.readShader(_filename, _options); } 
    963963    virtual bool isValid(ReaderWriter::ReadResult& readResult) const { return readResult.validShader(); } 
    964964    virtual bool isValid(osg::Object* object) const { return dynamic_cast<osg::Shader*>(object)!=0;  } 
     
    10181018        { 
    10191019            pathsContainsCurrentWorkingDirectory = true; 
    1020         }         
     1020        } 
    10211021    } 
    10221022 
     
    10291029        } 
    10301030    } 
    1031      
     1031 
    10321032 
    10331033    // if a directory is included in the filename, get just the (simple) filename itself and try that 
     
    11091109            OSG_INFO<<"         archive : "<<archiveName<<std::endl; 
    11101110            OSG_INFO<<"         filename : "<<fileName<<std::endl; 
    1111          
     1111 
    11121112            ReaderWriter::ReadResult result = openArchiveImplementation(archiveName,ReaderWriter::READ, 4096, readFunctor._options); 
    1113          
     1113 
    11141114            if (!result.validArchive()) return result; 
    11151115 
    11161116            osgDB::Archive* archive = result.getArchive(); 
    1117          
     1117 
    11181118            //if valid options were passed through the read functor clone them 
    11191119            //otherwise make new options 
     
    11251125 
    11261126            std::auto_ptr<ReadFunctor> rf(readFunctor.cloneType(fileName, options.get())); 
    1127              
     1127 
    11281128            result = rf->doRead(*archive); 
    11291129 
     
    11361136        } 
    11371137    } 
    1138      
     1138 
    11391139    // record the errors reported by readerwriters. 
    11401140    typedef std::vector<ReaderWriter::ReadResult> Results; 
     
    11811181            else if (ritr->status()==ReaderWriter::ReadResult::ERROR_IN_READING_FILE) ++num_ERROR_IN_READING_FILE; 
    11821182        } 
    1183          
     1183 
    11841184        if (num_FILE_NOT_HANDLED!=results.size()) 
    11851185        { 
     
    12361236        } 
    12371237    } 
    1238      
     1238 
    12391239    if (!results.empty()) 
    12401240    { 
     
    12521252            else if (ritr->status()==ReaderWriter::ReadResult::ERROR_IN_READING_FILE) ++num_ERROR_IN_READING_FILE; 
    12531253        } 
    1254          
     1254 
    12551255        if (num_FILE_NOT_HANDLED!=results.size()) 
    12561256        { 
     
    13061306            } 
    13071307        } 
    1308          
     1308 
    13091309        ReaderWriter::ReadResult rr = read(readFunctor); 
    1310         if (rr.validObject())  
     1310        if (rr.validObject()) 
    13111311        { 
    13121312            // update cache with new entry. 
     
    14381438        return ReaderWriter::WriteResult("Warning: Could not find plugin to write image to file \""+fileName+"\"."); 
    14391439    } 
    1440      
     1440 
    14411441    if (results.front().message().empty()) 
    14421442    { 
     
    15011501        } 
    15021502    } 
    1503      
     1503 
    15041504    return results.front(); 
    15051505} 
     
    15191519 
    15201520    return readImplementation(ReadNodeFunctor(fileName, options),Options::CACHE_NODES); 
    1521                                
     1521 
    15221522#endif 
    15231523} 
     
    15491549        { 
    15501550            ReaderWriter::WriteResult rr = itr->writeNode(node,fileName,options); 
    1551      
     1551 
    15521552            if (rr.success()) return rr; 
    15531553            else results.push_back(rr); 
     
    16111611        return ReaderWriter::WriteResult("Warning: Could not find plugin to write shader to file \""+fileName+"\"."); 
    16121612    } 
    1613      
     1613 
    16141614    if (results.front().message().empty()) 
    16151615    { 
     
    17101710    OpenThreads::ScopedLock<OpenThreads::Mutex> lock(_archiveCacheMutex); 
    17111711    ArchiveCache::iterator itr = _archiveCache.find(fileName); 
    1712     if (itr!=_archiveCache.end())  
     1712    if (itr!=_archiveCache.end()) 
    17131713    { 
    17141714        _archiveCache.erase(itr); 
     
    17591759{ 
    17601760    if (!_sharedStateManager) _sharedStateManager = new SharedStateManager; 
    1761      
     1761 
    17621762    return _sharedStateManager.get(); 
    17631763} 
    17641764 
    17651765 
    1766 void Registry::registerProtocol(const std::string& protocol)  
    1767 {   
    1768     _registeredProtocols.insert( convertToLowerCase(protocol) );  
    1769 } 
    1770          
    1771 bool Registry::isProtocolRegistered(const std::string& protocol)  
    1772 {  
    1773     return (_registeredProtocols.find( convertToLowerCase(protocol) ) != _registeredProtocols.end());  
    1774 } 
    1775  
     1766void Registry::registerProtocol(const std::string& protocol) 
     1767{ 
     1768    _registeredProtocols.insert( convertToLowerCase(protocol) ); 
     1769} 
     1770 
     1771bool Registry::isProtocolRegistered(const std::string& protocol) 
     1772{ 
     1773    return (_registeredProtocols.find( convertToLowerCase(protocol) ) != _registeredProtocols.end()); 
     1774} 
     1775