This file is indexed.

/usr/include/osgDB/ObjectWrapper is in libopenscenegraph-dev 3.2.1-6.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2010 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * OpenSceneGraph Public License for more details.
*/
// Written by Wang Rui, (C) 2010

#ifndef OSGDB_OBJECTWRAPPER
#define OSGDB_OBJECTWRAPPER

#include <osgDB/Serializer>

namespace osgDB
{

typedef std::vector<std::string> StringList;
extern OSGDB_EXPORT void split( const std::string& src, StringList& list, char separator=' ' );

class OSGDB_EXPORT BaseCompressor : public osg::Referenced
{
public:
    BaseCompressor() {}
    void setName( const std::string& name ) { _name = name; }
    const std::string& getName() const { return _name; }

    virtual bool compress( std::ostream&, const std::string& ) = 0;
    virtual bool decompress( std::istream&, std::string& ) = 0;

protected:
    std::string _name;
};

struct FinishedObjectReadCallback : public osg::Referenced
{
    virtual void objectRead(osgDB::InputStream& is, osg::Object& obj) = 0;
};

class OSGDB_EXPORT ObjectWrapper : public osg::Referenced
{
public:
    typedef std::vector< osg::ref_ptr<BaseSerializer> > SerializerList;
    typedef std::vector< osg::ref_ptr<FinishedObjectReadCallback> > FinishedObjectReadCallbackList;

    ObjectWrapper( osg::Object* proto, const std::string& name,
                   const std::string& associates );
    ObjectWrapper( osg::Object* proto, const std::string& domain, const std::string& name,
                   const std::string& associates );

    void setUpdatedVersion( int ver ) { _version = ver; }
    int getUpdatedVersion() const { return _version; }

    const osg::Object* getProto() const { return _proto.get(); }
    const std::string& getName() const { return _name; }
    const StringList& getAssociates() const { return _associates; }

    void addSerializer( BaseSerializer* s, BaseSerializer::Type t=BaseSerializer::RW_UNDEFINED );
    void markSerializerAsRemoved( const std::string& name );
    BaseSerializer* getSerializer( const std::string& name );
    void addFinishedObjectReadCallback ( FinishedObjectReadCallback* forc) { _finishedObjectReadCallbacks.push_back(forc); }

    bool read( InputStream&, osg::Object& );
    bool write( OutputStream&, const osg::Object& );

    bool readSchema( const StringList& properties, const std::vector<int>& types );
    void writeSchema( StringList& properties, std::vector<int>& types );
    void resetSchema()
    { if ( _backupSerializers.size()>0 ) _serializers = _backupSerializers; }

protected:
    ObjectWrapper() : _version(0) {}
    virtual ~ObjectWrapper() {}

    osg::ref_ptr<osg::Object> _proto;
    std::string _domain;
    std::string _name;
    StringList _associates;
    SerializerList _serializers;
    SerializerList _backupSerializers;
    std::vector<int> _typeList;
    FinishedObjectReadCallbackList _finishedObjectReadCallbacks;
    int _version;  // Last updated version of the wrapper
};

struct UpdateWrapperVersionProxy
{
    UpdateWrapperVersionProxy( ObjectWrapper* w, int v ): _wrapper(w)
    {
        _lastVersion = w->getUpdatedVersion();
        w->setUpdatedVersion(v);        
    }
    
    ~UpdateWrapperVersionProxy()
    {
        _wrapper->setUpdatedVersion(_lastVersion);
    }
    
    ObjectWrapper* _wrapper;
    int _lastVersion;
};

class Registry;

class OSGDB_EXPORT ObjectWrapperManager : public osg::Referenced
{
public:

    // Wrapper handlers
    void addWrapper( ObjectWrapper* wrapper );
    void removeWrapper( ObjectWrapper* wrapper );
    ObjectWrapper* findWrapper( const std::string& name );

    typedef std::map< std::string, osg::ref_ptr<ObjectWrapper> > WrapperMap;
    WrapperMap& getWrapperMap() { return _wrappers; }
    const WrapperMap& getWrapperMap() const { return _wrappers; }

    // Compressor handlers
    void addCompressor( BaseCompressor* compressor );
    void removeCompressor( BaseCompressor* compressor );
    BaseCompressor* findCompressor( const std::string& name );

    typedef std::map< std::string, osg::ref_ptr<BaseCompressor> > CompressorMap;
    CompressorMap& getCompressorMap() { return _compressors; }
    const CompressorMap& getCompressorMap() const { return _compressors; }

    typedef std::map<std::string, IntLookup> IntLookupMap;
    IntLookup::Value getValue( const std::string& group, const std::string& str ) { return findLookup(group).getValue(str.c_str()); }
    const std::string& getString( const std::string& group, IntLookup::Value value ) { return findLookup(group).getString(value); }

protected:

    friend class osgDB::Registry;

    ObjectWrapperManager();
    virtual ~ObjectWrapperManager();

    WrapperMap _wrappers;
    CompressorMap _compressors;

    IntLookup& findLookup( const std::string& group )
    {
        IntLookupMap::iterator itr = _globalMap.find(group);
        if ( itr!=_globalMap.end() ) return itr->second;
        else return _globalMap["GL"];
    }

    IntLookupMap _globalMap;
};


class OSGDB_EXPORT RegisterWrapperProxy
{
public:
    typedef void (*AddPropFunc)( ObjectWrapper* );

    RegisterWrapperProxy( osg::Object* proto, const std::string& name,
                          const std::string& associates, AddPropFunc func );

    virtual ~RegisterWrapperProxy();

protected:
    osg::ref_ptr<ObjectWrapper> _wrapper;
};

class OSGDB_EXPORT RegisterCustomWrapperProxy
{
public:
    typedef void (*AddPropFunc)( const char*, ObjectWrapper* );

    RegisterCustomWrapperProxy( osg::Object* proto, const std::string& domain, const std::string& name,
                                const std::string& associates, AddPropFunc func );

    virtual ~RegisterCustomWrapperProxy();

protected:
    osg::ref_ptr<ObjectWrapper> _wrapper;
};

#define REGISTER_OBJECT_WRAPPER(NAME, PROTO, CLASS, ASSOCIATES) \
    extern "C" void wrapper_serializer_##NAME(void) {} \
    extern void wrapper_propfunc_##NAME(osgDB::ObjectWrapper*); \
    static osgDB::RegisterWrapperProxy wrapper_proxy_##NAME( \
        PROTO, #CLASS, ASSOCIATES, &wrapper_propfunc_##NAME); \
    typedef CLASS MyClass; \
    void wrapper_propfunc_##NAME(osgDB::ObjectWrapper* wrapper)

#define REGISTER_OBJECT_WRAPPER2(NAME, PROTO, CLASS, CLASSNAME, ASSOCIATES) \
    extern "C" void wrapper_serializer_##NAME(void) {} \
    extern void wrapper_propfunc_##NAME(osgDB::ObjectWrapper*); \
    static osgDB::RegisterWrapperProxy wrapper_proxy_##NAME( \
        PROTO, CLASSNAME, ASSOCIATES, &wrapper_propfunc_##NAME); \
    typedef CLASS MyClass; \
    void wrapper_propfunc_##NAME(osgDB::ObjectWrapper* wrapper)

#define REGISTER_CUSTOM_OBJECT_WRAPPER(DOMAIN, NAME, PROTO, CLASS, ASSOCIATES) \
    extern "C" void wrapper_serializer_##NAME(void) {} \
    extern void wrapper_propfunc_##NAME(const char*, osgDB::ObjectWrapper*); \
    static osgDB::RegisterCustomWrapperProxy wrapper_proxy_##NAME( \
        PROTO, #DOMAIN, #CLASS, ASSOCIATES, &wrapper_propfunc_##NAME); \
    typedef CLASS MyClass; \
    void wrapper_propfunc_##NAME(const char* domain, osgDB::ObjectWrapper* wrapper)

#define REGISTER_CUSTOM_OBJECT_WRAPPER2(DOMAIN, NAME, PROTO, CLASS, CLASSNAME, ASSOCIATES) \
    extern "C" void wrapper_serializer_##NAME(void) {} \
    extern void wrapper_propfunc_##NAME(const char*, osgDB::ObjectWrapper*); \
    static osgDB::RegisterCustomWrapperProxy wrapper_proxy_##NAME( \
        PROTO, #DOMAIN, CLASSNAME, ASSOCIATES, &wrapper_propfunc_##NAME); \
    typedef CLASS MyClass; \
    void wrapper_propfunc_##NAME(const char* domain, osgDB::ObjectWrapper* wrapper)

class OSGDB_EXPORT RegisterCompressorProxy
{
public:
    RegisterCompressorProxy( const std::string& name, BaseCompressor* compressor );
    ~RegisterCompressorProxy();

protected:
    osg::ref_ptr<BaseCompressor> _compressor;
};

#define REGISTER_COMPRESSOR(NAME, CLASS) \
    extern "C" void wrapper_compressor_##CLASS(void) {} \
    static osgDB::RegisterCompressorProxy compressor_proxy_##CLASS(NAME, new CLASS);

}

#endif