Fix line endlings

1 files changed, 330 insertions, 330 deletions

diff --git a/indra/newview/llvocache.h b/indra/newview/llvocache.h
index 5dc4879f2a..8efdeb50f0 100644
--- a/indra/newview/llvocache.h
+++ b/indra/newview/llvocache.h
@@ -1,330 +1,330 @@
-/**

- * @file llvocache.h

- * @brief Cache of objects on the viewer.

- *

- * $LicenseInfo:firstyear=2003&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc.

- *

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- *

- * 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 GNU

- * Lesser General Public License for more details.

- *

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- *

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-#ifndef LL_LLVOCACHE_H

-#define LL_LLVOCACHE_H

-

-#include "lluuid.h"

-#include "lldatapacker.h"

-#include "lldir.h"

-#include "llvieweroctree.h"

-#include "llapr.h"

-#include "llgltfmaterial.h"

-

-#include <unordered_map>

-

-//---------------------------------------------------------------------------

-// Cache entries

-class LLCamera;

-

-class LLGLTFOverrideCacheEntry

-{

-public:

-    bool fromLLSD(const LLSD& data);

-    LLSD toLLSD() const;

-

-    LLUUID mObjectId;

-    U32    mLocalId = 0;

-    std::unordered_map<S32, LLSD> mSides; //override LLSD per side

-    std::unordered_map<S32, LLPointer<LLGLTFMaterial> > mGLTFMaterial; //GLTF material per side

-    U64 mRegionHandle = 0;

-};

-

-class LLVOCacheEntry

-:   public LLViewerOctreeEntryData

-{

-    LL_ALIGN_NEW

-public:

-    enum

-    {

-        //low 16-bit state

-        INACTIVE = 0x00000000,     //not visible

-        IN_QUEUE = 0x00000001,     //in visible queue, object to be created

-        WAITING  = 0x00000002,     //object creation request sent

-        ACTIVE   = 0x00000004,      //object created, and in rendering pipeline.

-

-        //high 16-bit state

-        IN_VO_TREE = 0x00010000,    //the entry is in the object cache tree.

-

-        LOW_BITS  = 0x0000ffff,

-        HIGH_BITS = 0xffff0000

-    };

-

-    struct CompareVOCacheEntry

-    {

-        bool operator()(const LLVOCacheEntry* const& lhs, const LLVOCacheEntry* const& rhs) const

-        {

-            F32 lpa = lhs->getSceneContribution();

-            F32 rpa = rhs->getSceneContribution();

-

-            //larger pixel area first

-            if(lpa > rpa)

-            {

-                return true;

-            }

-            else if(lpa < rpa)

-            {

-                return false;

-            }

-            else

-            {

-                return lhs < rhs;

-            }

-        }

-    };

-

-    struct ExtrasEntry

-    {

-        LLSD extras;

-        std::string extras_raw;

-    };

-

-protected:

-    ~LLVOCacheEntry();

-public:

-    LLVOCacheEntry(U32 local_id, U32 crc, LLDataPackerBinaryBuffer &dp);

-    LLVOCacheEntry(LLAPRFile* apr_file);

-    LLVOCacheEntry();

-

-    void updateEntry(U32 crc, LLDataPackerBinaryBuffer &dp);

-

-    void clearState(U32 state) {mState &= ~state;}

-    bool hasState(U32 state)   {return mState & state;}

-    void setState(U32 state);

-    bool isState(U32 state)    {return (mState & LOW_BITS) == state;}

-    U32  getState() const      {return mState & LOW_BITS;}

-

-    bool isAnyVisible(const LLVector4a& camera_origin, const LLVector4a& local_camera_origin, F32 dist_threshold);

-

-    U32 getLocalID() const          { return mLocalID; }

-    U32 getCRC() const              { return mCRC; }

-    S32 getHitCount() const         { return mHitCount; }

-    S32 getCRCChangeCount() const   { return mCRCChangeCount; }

-

-    void calcSceneContribution(const LLVector4a& camera_origin, bool needs_update, U32 last_update, F32 dist_threshold);

-    void setSceneContribution(F32 scene_contrib) {mSceneContrib = scene_contrib;}

-    F32 getSceneContribution() const             { return mSceneContrib;}

-

-    void dump() const;

-    S32 writeToBuffer(U8 *data_buffer) const;

-    LLDataPackerBinaryBuffer *getDP();

-    void recordHit();

-    void recordDupe() { mDupeCount++; }

-

-    /*virtual*/ void setOctreeEntry(LLViewerOctreeEntry* entry);

-

-    void setParentID(U32 id);

-    U32  getParentID() const {return mParentID;}

-    bool isChild() const {return mParentID > 0;}

-

-    void addChild(LLVOCacheEntry* entry);

-    void removeChild(LLVOCacheEntry* entry);

-    void removeAllChildren();

-    LLVOCacheEntry* getChild(); //remove the first child, and return it.

-    S32  getNumOfChildren() const  {return mChildrenList.size();}

-

-    void setBoundingInfo(const LLVector3& pos, const LLVector3& scale); //called from processing object update message

-    void updateParentBoundingInfo();

-    void saveBoundingSphere();

-

-    void setValid(bool valid = true) {mValid = valid;}

-    bool isValid() const {return mValid;}

-

-    void setUpdateFlags(U32 flags) {mUpdateFlags = flags;}

-    U32  getUpdateFlags() const    {return mUpdateFlags;}

-

-    static void updateDebugSettings();

-    static F32  getSquaredPixelThreshold(bool is_front);

-

-private:

-    void updateParentBoundingInfo(const LLVOCacheEntry* child);

-

-public:

-    typedef std::map<U32, LLPointer<LLVOCacheEntry> >      vocache_entry_map_t;

-    typedef std::set<LLVOCacheEntry*>                      vocache_entry_set_t;

-    typedef std::set<LLVOCacheEntry*, CompareVOCacheEntry> vocache_entry_priority_list_t;

-

-    typedef std::unordered_map<U32, LLGLTFOverrideCacheEntry>  vocache_gltf_overrides_map_t;

-

-    S32                         mLastCameraUpdated;

-protected:

-    U32                         mLocalID;

-    U32                         mParentID;

-    U32                         mCRC;

-    U32                         mUpdateFlags; //receive from sim

-    S32                         mHitCount;

-    S32                         mDupeCount;

-    S32                         mCRCChangeCount;

-    LLDataPackerBinaryBuffer    mDP;

-    U8                          *mBuffer;

-

-    F32                         mSceneContrib; //projected scene contributuion of this object.

-    U32                         mState; //high 16 bits reserved for special use.

-    vocache_entry_set_t         mChildrenList; //children entries in a linked set.

-

-    bool                        mValid; //if set, this entry is valid, otherwise it is invalid and will be removed.

-

-    LLVector4a                  mBSphereCenter; //bounding sphere center

-    F32                         mBSphereRadius; //bounding sphere radius

-

-public:

-    static U32                  sMinFrameRange;

-    static F32                  sNearRadius;

-    static F32                  sRearFarRadius;

-    static F32                  sFrontPixelThreshold;

-    static F32                  sRearPixelThreshold;

-};

-

-class LLVOCacheGroup : public LLOcclusionCullingGroup

-{

-public:

-    LLVOCacheGroup(OctreeNode* node, LLViewerOctreePartition* part) : LLOcclusionCullingGroup(node, part){}

-

-    //virtual

-    void handleChildAddition(const OctreeNode* parent, OctreeNode* child);

-

-protected:

-    virtual ~LLVOCacheGroup();

-};

-

-class LLVOCachePartition : public LLViewerOctreePartition

-{

-public:

-    LLVOCachePartition(LLViewerRegion* regionp);

-    virtual ~LLVOCachePartition();

-

-    bool addEntry(LLViewerOctreeEntry* entry);

-    void removeEntry(LLViewerOctreeEntry* entry);

-    /*virtual*/ S32 cull(LLCamera &camera, bool do_occlusion);

-    void addOccluders(LLViewerOctreeGroup* gp);

-    void resetOccluders();

-    void processOccluders(LLCamera* camera);

-    void removeOccluder(LLVOCacheGroup* group);

-

-    void setCullHistory(bool has_new_object);

-

-    bool isFrontCull() const {return mFrontCull;}

-

-private:

-    void selectBackObjects(LLCamera &camera, F32 projection_area_cutoff, bool use_occlusion); //select objects behind camera.

-

-public:

-    static bool sNeedsOcclusionCheck;

-

-private:

-    bool  mFrontCull; //the view frustum cull if set, otherwise is back sphere cull.

-    U32   mCullHistory;

-    U32   mCulledTime[LLViewerCamera::NUM_CAMERAS];

-    std::set<LLVOCacheGroup*> mOccludedGroups;

-

-    S32   mBackSlectionEnabled; //enable to select back objects if > 0.

-    U32   mIdleHash;

-};

-

-//

-//Note: LLVOCache is not thread-safe

-//

-class LLVOCache : public LLParamSingleton<LLVOCache>

-{

-    LLSINGLETON(LLVOCache, bool read_only);

-    ~LLVOCache() ;

-

-private:

-    struct HeaderEntryInfo

-    {

-        HeaderEntryInfo() : mIndex(0), mHandle(0), mTime(0) {}

-        S32 mIndex;

-        U64 mHandle ;

-        U32 mTime ;

-    };

-

-    struct HeaderMetaInfo

-    {

-        HeaderMetaInfo() : mVersion(0), mAddressSize(0) {}

-

-        U32 mVersion;

-        U32 mAddressSize;

-    };

-

-    struct header_entry_less

-    {

-        bool operator()(const HeaderEntryInfo* lhs, const HeaderEntryInfo* rhs) const

-        {

-            if(lhs->mTime == rhs->mTime)

-            {

-                return lhs < rhs ;

-            }

-

-            return lhs->mTime < rhs->mTime ; // older entry in front of queue (set)

-        }

-    };

-    typedef std::set<HeaderEntryInfo*, header_entry_less> header_entry_queue_t;

-    typedef std::map<U64, HeaderEntryInfo*> handle_entry_map_t;

-

-public:

-    // We need this init to be separate from constructor, since we might construct cache, purge it, then init.

-    void initCache(ELLPath location, U32 size, U32 cache_version);

-    void removeCache(ELLPath location, bool started = false) ;

-

-    void readFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_entry_map_t& cache_entry_map) ;

-    void readGenericExtrasFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map);

-

-    void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, bool dirty_cache, bool removal_enabled);

-    void writeGenericExtrasToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map, bool dirty_cache, bool removal_enabled);

-    void removeEntry(U64 handle) ;

-

-    U32 getCacheEntries() { return mNumEntries; }

-    U32 getCacheEntriesMax() { return mCacheSize; }

-

-private:

-    void setDirNames(ELLPath location);

-    // determine the cache filename for the region from the region handle

-    void getObjectCacheFilename(U64 handle, std::string& filename);

-    std::string getObjectCacheExtrasFilename(U64 handle);

-    void removeFromCache(HeaderEntryInfo* entry);

-    void readCacheHeader();

-    void writeCacheHeader();

-    void clearCacheInMemory();

-    void removeCache() ;

-    void removeEntry(HeaderEntryInfo* entry) ;

-    void purgeEntries(U32 size);

-    bool updateEntry(const HeaderEntryInfo* entry);

-

-private:

-    bool                 mEnabled;

-    bool                 mInitialized ;

-    bool                 mReadOnly ;

-    HeaderMetaInfo       mMetaInfo;

-    U32                  mCacheSize;

-    U32                  mNumEntries;

-    std::string          mHeaderFileName ;

-    std::string          mObjectCacheDirName;

-    LLVolatileAPRPool*   mLocalAPRFilePoolp ;

-    header_entry_queue_t mHeaderEntryQueue;

-    handle_entry_map_t   mHandleEntryMap;

-};

-

-#endif

+/**
+ * @file llvocache.h
+ * @brief Cache of objects on the viewer.
+ *
+ * $LicenseInfo:firstyear=2003&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * 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 GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
+ * $/LicenseInfo$
+ */
+
+#ifndef LL_LLVOCACHE_H
+#define LL_LLVOCACHE_H
+
+#include "lluuid.h"
+#include "lldatapacker.h"
+#include "lldir.h"
+#include "llvieweroctree.h"
+#include "llapr.h"
+#include "llgltfmaterial.h"
+
+#include <unordered_map>
+
+//---------------------------------------------------------------------------
+// Cache entries
+class LLCamera;
+
+class LLGLTFOverrideCacheEntry
+{
+public:
+    bool fromLLSD(const LLSD& data);
+    LLSD toLLSD() const;
+
+    LLUUID mObjectId;
+    U32    mLocalId = 0;
+    std::unordered_map<S32, LLSD> mSides; //override LLSD per side
+    std::unordered_map<S32, LLPointer<LLGLTFMaterial> > mGLTFMaterial; //GLTF material per side
+    U64 mRegionHandle = 0;
+};
+
+class LLVOCacheEntry
+:   public LLViewerOctreeEntryData
+{
+    LL_ALIGN_NEW
+public:
+    enum
+    {
+        //low 16-bit state
+        INACTIVE = 0x00000000,     //not visible
+        IN_QUEUE = 0x00000001,     //in visible queue, object to be created
+        WAITING  = 0x00000002,     //object creation request sent
+        ACTIVE   = 0x00000004,      //object created, and in rendering pipeline.
+
+        //high 16-bit state
+        IN_VO_TREE = 0x00010000,    //the entry is in the object cache tree.
+
+        LOW_BITS  = 0x0000ffff,
+        HIGH_BITS = 0xffff0000
+    };
+
+    struct CompareVOCacheEntry
+    {
+        bool operator()(const LLVOCacheEntry* const& lhs, const LLVOCacheEntry* const& rhs) const
+        {
+            F32 lpa = lhs->getSceneContribution();
+            F32 rpa = rhs->getSceneContribution();
+
+            //larger pixel area first
+            if(lpa > rpa)
+            {
+                return true;
+            }
+            else if(lpa < rpa)
+            {
+                return false;
+            }
+            else
+            {
+                return lhs < rhs;
+            }
+        }
+    };
+
+    struct ExtrasEntry
+    {
+        LLSD extras;
+        std::string extras_raw;
+    };
+
+protected:
+    ~LLVOCacheEntry();
+public:
+    LLVOCacheEntry(U32 local_id, U32 crc, LLDataPackerBinaryBuffer &dp);
+    LLVOCacheEntry(LLAPRFile* apr_file);
+    LLVOCacheEntry();
+
+    void updateEntry(U32 crc, LLDataPackerBinaryBuffer &dp);
+
+    void clearState(U32 state) {mState &= ~state;}
+    bool hasState(U32 state)   {return mState & state;}
+    void setState(U32 state);
+    bool isState(U32 state)    {return (mState & LOW_BITS) == state;}
+    U32  getState() const      {return mState & LOW_BITS;}
+
+    bool isAnyVisible(const LLVector4a& camera_origin, const LLVector4a& local_camera_origin, F32 dist_threshold);
+
+    U32 getLocalID() const          { return mLocalID; }
+    U32 getCRC() const              { return mCRC; }
+    S32 getHitCount() const         { return mHitCount; }
+    S32 getCRCChangeCount() const   { return mCRCChangeCount; }
+
+    void calcSceneContribution(const LLVector4a& camera_origin, bool needs_update, U32 last_update, F32 dist_threshold);
+    void setSceneContribution(F32 scene_contrib) {mSceneContrib = scene_contrib;}
+    F32 getSceneContribution() const             { return mSceneContrib;}
+
+    void dump() const;
+    S32 writeToBuffer(U8 *data_buffer) const;
+    LLDataPackerBinaryBuffer *getDP();
+    void recordHit();
+    void recordDupe() { mDupeCount++; }
+
+    /*virtual*/ void setOctreeEntry(LLViewerOctreeEntry* entry);
+
+    void setParentID(U32 id);
+    U32  getParentID() const {return mParentID;}
+    bool isChild() const {return mParentID > 0;}
+
+    void addChild(LLVOCacheEntry* entry);
+    void removeChild(LLVOCacheEntry* entry);
+    void removeAllChildren();
+    LLVOCacheEntry* getChild(); //remove the first child, and return it.
+    S32  getNumOfChildren() const  {return mChildrenList.size();}
+
+    void setBoundingInfo(const LLVector3& pos, const LLVector3& scale); //called from processing object update message
+    void updateParentBoundingInfo();
+    void saveBoundingSphere();
+
+    void setValid(bool valid = true) {mValid = valid;}
+    bool isValid() const {return mValid;}
+
+    void setUpdateFlags(U32 flags) {mUpdateFlags = flags;}
+    U32  getUpdateFlags() const    {return mUpdateFlags;}
+
+    static void updateDebugSettings();
+    static F32  getSquaredPixelThreshold(bool is_front);
+
+private:
+    void updateParentBoundingInfo(const LLVOCacheEntry* child);
+
+public:
+    typedef std::map<U32, LLPointer<LLVOCacheEntry> >      vocache_entry_map_t;
+    typedef std::set<LLVOCacheEntry*>                      vocache_entry_set_t;
+    typedef std::set<LLVOCacheEntry*, CompareVOCacheEntry> vocache_entry_priority_list_t;
+
+    typedef std::unordered_map<U32, LLGLTFOverrideCacheEntry>  vocache_gltf_overrides_map_t;
+
+    S32                         mLastCameraUpdated;
+protected:
+    U32                         mLocalID;
+    U32                         mParentID;
+    U32                         mCRC;
+    U32                         mUpdateFlags; //receive from sim
+    S32                         mHitCount;
+    S32                         mDupeCount;
+    S32                         mCRCChangeCount;
+    LLDataPackerBinaryBuffer    mDP;
+    U8                          *mBuffer;
+
+    F32                         mSceneContrib; //projected scene contributuion of this object.
+    U32                         mState; //high 16 bits reserved for special use.
+    vocache_entry_set_t         mChildrenList; //children entries in a linked set.
+
+    bool                        mValid; //if set, this entry is valid, otherwise it is invalid and will be removed.
+
+    LLVector4a                  mBSphereCenter; //bounding sphere center
+    F32                         mBSphereRadius; //bounding sphere radius
+
+public:
+    static U32                  sMinFrameRange;
+    static F32                  sNearRadius;
+    static F32                  sRearFarRadius;
+    static F32                  sFrontPixelThreshold;
+    static F32                  sRearPixelThreshold;
+};
+
+class LLVOCacheGroup : public LLOcclusionCullingGroup
+{
+public:
+    LLVOCacheGroup(OctreeNode* node, LLViewerOctreePartition* part) : LLOcclusionCullingGroup(node, part){}
+
+    //virtual
+    void handleChildAddition(const OctreeNode* parent, OctreeNode* child);
+
+protected:
+    virtual ~LLVOCacheGroup();
+};
+
+class LLVOCachePartition : public LLViewerOctreePartition
+{
+public:
+    LLVOCachePartition(LLViewerRegion* regionp);
+    virtual ~LLVOCachePartition();
+
+    bool addEntry(LLViewerOctreeEntry* entry);
+    void removeEntry(LLViewerOctreeEntry* entry);
+    /*virtual*/ S32 cull(LLCamera &camera, bool do_occlusion);
+    void addOccluders(LLViewerOctreeGroup* gp);
+    void resetOccluders();
+    void processOccluders(LLCamera* camera);
+    void removeOccluder(LLVOCacheGroup* group);
+
+    void setCullHistory(bool has_new_object);
+
+    bool isFrontCull() const {return mFrontCull;}
+
+private:
+    void selectBackObjects(LLCamera &camera, F32 projection_area_cutoff, bool use_occlusion); //select objects behind camera.
+
+public:
+    static bool sNeedsOcclusionCheck;
+
+private:
+    bool  mFrontCull; //the view frustum cull if set, otherwise is back sphere cull.
+    U32   mCullHistory;
+    U32   mCulledTime[LLViewerCamera::NUM_CAMERAS];
+    std::set<LLVOCacheGroup*> mOccludedGroups;
+
+    S32   mBackSlectionEnabled; //enable to select back objects if > 0.
+    U32   mIdleHash;
+};
+
+//
+//Note: LLVOCache is not thread-safe
+//
+class LLVOCache : public LLParamSingleton<LLVOCache>
+{
+    LLSINGLETON(LLVOCache, bool read_only);
+    ~LLVOCache() ;
+
+private:
+    struct HeaderEntryInfo
+    {
+        HeaderEntryInfo() : mIndex(0), mHandle(0), mTime(0) {}
+        S32 mIndex;
+        U64 mHandle ;
+        U32 mTime ;
+    };
+
+    struct HeaderMetaInfo
+    {
+        HeaderMetaInfo() : mVersion(0), mAddressSize(0) {}
+
+        U32 mVersion;
+        U32 mAddressSize;
+    };
+
+    struct header_entry_less
+    {
+        bool operator()(const HeaderEntryInfo* lhs, const HeaderEntryInfo* rhs) const
+        {
+            if(lhs->mTime == rhs->mTime)
+            {
+                return lhs < rhs ;
+            }
+
+            return lhs->mTime < rhs->mTime ; // older entry in front of queue (set)
+        }
+    };
+    typedef std::set<HeaderEntryInfo*, header_entry_less> header_entry_queue_t;
+    typedef std::map<U64, HeaderEntryInfo*> handle_entry_map_t;
+
+public:
+    // We need this init to be separate from constructor, since we might construct cache, purge it, then init.
+    void initCache(ELLPath location, U32 size, U32 cache_version);
+    void removeCache(ELLPath location, bool started = false) ;
+
+    void readFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_entry_map_t& cache_entry_map) ;
+    void readGenericExtrasFromCache(U64 handle, const LLUUID& id, LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map);
+
+    void writeToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_entry_map_t& cache_entry_map, bool dirty_cache, bool removal_enabled);
+    void writeGenericExtrasToCache(U64 handle, const LLUUID& id, const LLVOCacheEntry::vocache_gltf_overrides_map_t& cache_extras_entry_map, bool dirty_cache, bool removal_enabled);
+    void removeEntry(U64 handle) ;
+
+    U32 getCacheEntries() { return mNumEntries; }
+    U32 getCacheEntriesMax() { return mCacheSize; }
+
+private:
+    void setDirNames(ELLPath location);
+    // determine the cache filename for the region from the region handle
+    void getObjectCacheFilename(U64 handle, std::string& filename);
+    std::string getObjectCacheExtrasFilename(U64 handle);
+    void removeFromCache(HeaderEntryInfo* entry);
+    void readCacheHeader();
+    void writeCacheHeader();
+    void clearCacheInMemory();
+    void removeCache() ;
+    void removeEntry(HeaderEntryInfo* entry) ;
+    void purgeEntries(U32 size);
+    bool updateEntry(const HeaderEntryInfo* entry);
+
+private:
+    bool                 mEnabled;
+    bool                 mInitialized ;
+    bool                 mReadOnly ;
+    HeaderMetaInfo       mMetaInfo;
+    U32                  mCacheSize;
+    U32                  mNumEntries;
+    std::string          mHeaderFileName ;
+    std::string          mObjectCacheDirName;
+    LLVolatileAPRPool*   mLocalAPRFilePoolp ;
+    header_entry_queue_t mHeaderEntryQueue;
+    handle_entry_map_t   mHandleEntryMap;
+};
+
+#endif