resolver.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_COMMON_RESOLVER_SEEN
#define CUPT_COMMON_RESOLVER_SEEN
 
 
#include <functional>
 
#include <cupt/common.hpp>
#include <cupt/cache/binaryversion.hpp>
 
namespace cupt {
namespace system {
 
using namespace cache;
 
 
class CUPT_API Resolver
{
    Resolver(const Resolver&);
    Resolver& operator=(const Resolver&);
 public:
    struct Reason
    {
     protected:
        CUPT_LOCAL Reason() {};
     public:
        virtual ~Reason() {};
        virtual string toString() const = 0; 
    };
 
    struct UserReason: public Reason
    {
        virtual string toString() const;
    };
 
    struct ImplicitReason: public Reason
    {
        virtual string toString() const override;
    };
 
    struct AutoRemovalReason: public Reason
    {
        virtual string toString() const;
    };
 
    struct RelationExpressionReason: public Reason
    {
        const BinaryVersion* version; 
        BinaryVersion::RelationTypes::Type dependencyType; 
        RelationExpression relationExpression; 
 
        RelationExpressionReason(const BinaryVersion*,
                BinaryVersion::RelationTypes::Type, const RelationExpression&);
        virtual string toString() const;
    };
 
    struct SynchronizationReason: public Reason
    {
        const BinaryVersion* version; 
        string relatedPackageName; 
 
        SynchronizationReason(const BinaryVersion*, const string&);
        virtual string toString() const;
    };
 
 
    struct SuggestedPackage
    {
        const BinaryVersion* version; 
        bool automaticallyInstalledFlag;
        vector< shared_ptr< const Reason > > reasons; 
        vector< string > reasonPackageNames; 
    };
    typedef map< string, SuggestedPackage > SuggestedPackages; 
    struct Offer
    {
        SuggestedPackages suggestedPackages; 
        vector< shared_ptr< const Reason > > unresolvedProblems;
    };
 
    struct UserAnswer
    {
        enum Type
        {
            Accept, 
            Decline, 
            Abandon 
        };
    };
 
    typedef std::function< UserAnswer::Type (const Offer&) > CallbackType;
 
    struct RequestImportance
    {
        typedef uint32_t Value;
 
        static const Value Must;
        static const Value Try;
        static const Value Wish;
 
        RequestImportance(Value value)
            : p_value(value)
        {}
        operator Value() const
        {
            return p_value;
        }
     private:
        Value p_value;
    };
 
    Resolver() {};
 
    void installVersion(const vector< const BinaryVersion* >&,
            const string& annotation = string(), RequestImportance importance = RequestImportance::Must);
    void removeVersions(const vector< const BinaryVersion* >&,
            const string& annotation = string(), RequestImportance importance = RequestImportance::Must);
    virtual void satisfyRelationExpression(const RelationExpression&,
            bool invert = false, const string& annotation = string(), RequestImportance importance = RequestImportance::Must,
            bool asAutomatic = false) = 0;
    virtual void upgrade() = 0;
    virtual void setAutomaticallyInstalledFlag(const string& packageName, bool flagValue) = 0;
 
 
    virtual bool resolve(CallbackType) = 0;
 
    virtual ~Resolver() {};
};
 
}
}
 
#endif