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() {}; // polymorphic
        virtual string toString() const = 0; 
    };

    struct UserReason: public Reason
    {
        virtual string toString() const;
    };

    struct AutoRemovalReason: public Reason
    {
        virtual string toString() const;
    };

    struct RelationExpressionReason: public Reason
    {
        shared_ptr< const BinaryVersion > version; 
        BinaryVersion::RelationTypes::Type dependencyType; 
        RelationExpression relationExpression; 

        RelationExpressionReason(const shared_ptr< const BinaryVersion >&,
                BinaryVersion::RelationTypes::Type, const RelationExpression&);
        virtual string toString() const;
    };

    struct SynchronizationReason: public Reason
    {
        shared_ptr< const BinaryVersion > version; 
        string relatedPackageName; 

        SynchronizationReason(const shared_ptr< const BinaryVersion >&, const string&);
        virtual string toString() const;
    };


    struct SuggestedPackage
    {
        shared_ptr< const BinaryVersion > version; 
        bool manuallySelected; 
        vector< shared_ptr< const Reason > > reasons; 
    };
    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;

    Resolver() {};

    virtual void installVersion(const shared_ptr< const BinaryVersion >&) = 0;
    virtual void satisfyRelationExpression(const RelationExpression&) = 0;
    virtual void unsatisfyRelationExpression(const RelationExpression&) = 0;
    virtual void removePackage(const string& packageName) = 0;
    virtual void upgrade() = 0;


    virtual bool resolve(CallbackType) = 0;

    virtual ~Resolver() {};
};

}
}

#endif