cache.hpp

Go to the documentation of this file.

/**************************************************************************
*   Copyright (C) 2010 by Eugene V. Lyubimkin                             *
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License                  *
*   (version 3 or above) as published by the Free Software Foundation.    *
*                                                                         *
*   This program 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 General Public License for more details.                          *
*                                                                         *
*   You should have received a copy of the GNU GPL                        *
*   along with this program; if not, write to the                         *
*   Free Software Foundation, Inc.,                                       *
*   51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA               *
**************************************************************************/
#ifndef CUPT_CACHE_CACHE_SEEN
#define CUPT_CACHE_CACHE_SEEN
 
 
#include <set>
#include <map>
 
#include <cupt/common.hpp>
#include <cupt/fwd.hpp>
#include <cupt/range.hpp>
 
namespace cupt {
 
namespace internal {
 
class CacheImpl;
 
}
 
using std::set;
using std::map;
 
using namespace cache;
 
class CUPT_API Cache
{
 public:
 
    struct IndexEntry
    {
        enum Type { Source, Binary } category;
        string uri; 
        string distribution; 
        string component; 
        map< string, string > options; 
    };
    struct ExtendedInfo
    {
        typedef map<string, map<string, string>> Raw;
        Raw raw; 
        set< string > automaticallyInstalled; 
    };
 
    class PackageNameIterator
    {
     public:
        typedef const string value_type;
 
        class Impl;
        PackageNameIterator(Impl* impl);
        ~PackageNameIterator();
        PackageNameIterator(const PackageNameIterator&);
        PackageNameIterator& operator=(const PackageNameIterator&);
        PackageNameIterator(PackageNameIterator&&) = default;
 
        bool operator==(const PackageNameIterator&) const;
        bool operator!=(const PackageNameIterator&) const;
 
        value_type& operator*() const;
        PackageNameIterator& operator++();
 
     private:
        Impl* p_impl;
    };
 
 private:
    internal::CacheImpl* __impl;
    Cache(const Cache&);
    Cache& operator=(const Cache&);
 public:
 
    Cache(shared_ptr< const Config > config, bool useSource, bool useBinary, bool useInstalled);
    virtual ~Cache();
 
    vector< shared_ptr< const ReleaseInfo > > getBinaryReleaseData() const;
    vector< shared_ptr< const ReleaseInfo > > getSourceReleaseData() const;
 
    Range< PackageNameIterator > getBinaryPackageNames() const;
 
    const BinaryPackage* getBinaryPackage(const string& packageName) const;
    Range< PackageNameIterator > getSourcePackageNames() const;
 
    const SourcePackage* getSourcePackage(const string& packageName) const;
 
    vector< const BinaryVersion* > getInstalledVersions() const;
 
 
    bool isAutomaticallyInstalled(const string& packageName) const;
 
    vector< IndexEntry > getIndexEntries() const;
 
    const system::State* getSystemState() const;
 
    ssize_t getPin(const Version*) const;
 
    struct VersionWithPriority
    {
        const Version* version;
        ssize_t priority;
    };
    vector<VersionWithPriority> getSortedVersionsWithPriorities(const Package*) const;
    const Version* getPreferredVersion(const Package*) const;
 
    vector< const BinaryVersion* > getSatisfyingVersions(const RelationExpression&) const;
 
    const ExtendedInfo& getExtendedInfo() const;
 
 
    string getLocalizedDescription(const BinaryVersion*) const;
 
 
    static string getPathOfCopyright(const BinaryVersion*);
 
    static string getPathOfChangelog(const BinaryVersion*);
 
 
    static bool memoize;
};
 
}
 
#endif