This file is indexed.

/usr/include/osgEarth/CachePolicy is in libosgearth-dev 2.7.0+dfsg-2+b3.

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
/* -*-c++-*- */
/* osgEarth - Dynamic map generation toolkit for OpenSceneGraph
* Copyright 2015 Pelican Mapping
* http://osgearth.org
*
* osgEarth 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; either version 2 of the License, or
* (at your option) any later version.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
* IN THE SOFTWARE.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>
*/

#ifndef OSGEARTH_CACHE_POLICY_H
#define OSGEARTH_CACHE_POLICY_H 1

#include <osgEarth/Common>
#include <osgEarth/Config>
#include <osgEarth/DateTime>
#include <osgDB/Options>

namespace osgEarth
{
    /**
     * Policy for cache usage.
     */
    class OSGEARTH_EXPORT CachePolicy
    {
    public:
        enum Usage
        {
            USAGE_READ_WRITE   = 0,  // read/write to the cache if one exists.
            USAGE_CACHE_ONLY   = 1,  // treat the cache as the ONLY source of data.
            USAGE_READ_ONLY    = 2,  // read from the cache, but don't write new data to it.
            USAGE_NO_CACHE     = 3   // neither read from or write to the cache
        };

        /** default cache policy (READ_WRITE) */
        static CachePolicy DEFAULT;

        /* policy indicating to never use a cache */
        static CachePolicy NO_CACHE;

        /** policy indicating to only use a cache */
        static CachePolicy CACHE_ONLY;

    public:
        /** constructs an invalid CachePolicy. */
        CachePolicy();

        /** copy ctor */
        CachePolicy(const CachePolicy& rhs);

        /** constructs a caching policy. */
        CachePolicy( const Usage& usage );

        /** constructs a CachePolicy from a config options */
        CachePolicy( const Config& conf );

        /** construct a cache policy be reading it from an osgDB::Options */
        static bool fromOptions( const osgDB::Options* dbOptions, optional<CachePolicy>& out_policy );

        /** Stores this cache policy in a DB Options. */
        void apply( osgDB::Options* options );

        /** Merges any set properties in another CP into this one, override existing values. */
        void mergeAndOverride(const CachePolicy& rhs);
        void mergeAndOverride(const optional<CachePolicy>& rhs);

        /** Gets the oldest timestamp for which to accept a cache record */
        TimeStamp getMinAcceptTime() const;

        /**
         * Determine whether the given timestamp is considered to be expired based on this CachePolicy
         */
        bool isExpired(TimeStamp lastModified) const;

        /** dtor */
        virtual ~CachePolicy() { }

        /** Gets the usage policy */
        optional<Usage>& usage() { return _usage; }
        const optional<Usage>& usage() const { return _usage; }

        /** Gets the age limit for a cache record (in seconds) */
        optional<TimeSpan>& maxAge() { return _maxAge; }
        const optional<TimeSpan>& maxAge() const { return _maxAge; }

        /** Gets the age limit for a cache record (as an absolute timestamp) */
        optional<TimeStamp>& minTime() { return _minTime; }
        const optional<TimeStamp>& minTime() const { return _minTime; }


    public: // convenience functions.

        bool isCacheReadable() const { 
            return *_usage == USAGE_READ_WRITE || *_usage == USAGE_CACHE_ONLY || *_usage == USAGE_READ_ONLY;
        }

        bool isCacheWriteable() const {
            return *_usage == USAGE_READ_WRITE;
        }

        bool operator == ( const CachePolicy& rhs ) const;

        bool operator != ( const CachePolicy& rhs ) const {
            return ! operator==(rhs);
        }

        // returns a readable string describing usage
        std::string usageString() const;

    public: // config
        Config getConfig() const;
        void fromConfig( const Config& conf );

    private:
        optional<Usage>     _usage;
        optional<TimeSpan>  _maxAge;
        optional<TimeStamp> _minTime;
    };
}

#endif // OSGEARTH_CACHE_POLICY_H