SolutionAction.h

Go to the documentation of this file.

/*
 *
 * Easy-to use interface to the ZYPP dependency resolver
 *
 * Author: Stefan Hundhammer <sh@suse.de>
 *
 **/

#ifndef ZYPP_SOLVER_DETAIL_SOLUTIONACTION_H
#define ZYPP_SOLVER_DETAIL_SOLUTIONACTION_H
#ifndef ZYPP_USE_RESOLVER_INTERNALS
#error Do not directly include this file!
#else

#include <list>
#include <string>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/PtrTypes.h"

#include "zypp/PoolItem.h"

namespace zypp
{ 
  namespace solver
  { 
    namespace detail
    { 

      class Resolver;

      DEFINE_PTR_TYPE(SolverQueueItem);

      DEFINE_PTR_TYPE(SolutionAction);
      typedef std::list<SolutionAction_Ptr> SolutionActionList;

        class SolutionAction : public base::ReferenceCounted
        {
        protected:
            typedef Resolver ResolverInternal;
            SolutionAction ();
        public:
            virtual ~SolutionAction();

            // ---------------------------------- I/O
            virtual std::ostream & dumpOn( std::ostream & str ) const;
            friend std::ostream& operator<<(std::ostream & str, const SolutionAction & action)
                { return action.dumpOn (str); }
            friend std::ostream& operator<<(std::ostream & str, const SolutionActionList & actionlist);

            // ---------------------------------- methods
            virtual bool execute (ResolverInternal & resolver) const = 0;
        };


        typedef enum
        {
            KEEP,
            INSTALL,
            REMOVE,
            UNLOCK,
            LOCK,
            REMOVE_EXTRA_REQUIRE,
            REMOVE_EXTRA_CONFLICT,
            ADD_SOLVE_QUEUE_ITEM,
            REMOVE_SOLVE_QUEUE_ITEM,
        } TransactionKind;


        class TransactionSolutionAction: public SolutionAction
        {
        public:
            TransactionSolutionAction( PoolItem item,
                                       TransactionKind action )
                : SolutionAction(),
                  _item( item ), _action( action ) {}

            TransactionSolutionAction( Capability capability,
                                       TransactionKind action )
                : SolutionAction(),
                  _capability( capability ), _action( action ) {}


            TransactionSolutionAction( SolverQueueItem_Ptr item,
                                       TransactionKind action )
                : SolutionAction(),
                  _solverQueueItem( item ), _action( action ) {}

            TransactionSolutionAction( TransactionKind action )
                : SolutionAction(),
                  _item(), _action( action ) {}

          // ---------------------------------- I/O
          virtual std::ostream & dumpOn( std::ostream & str ) const;
          friend std::ostream& operator<<(std::ostream& str, const TransactionSolutionAction & action)
                { return action.dumpOn (str); }

          // ---------------------------------- accessors

          const PoolItem item() const { return _item; }
          const Capability capability() const { return _capability; }
          TransactionKind action() const { return _action; }

          // ---------------------------------- methods
            virtual bool execute(ResolverInternal & resolver) const;

        protected:

            PoolItem _item;
            Capability _capability;
            SolverQueueItem_Ptr _solverQueueItem;

            const TransactionKind _action;
        };


        typedef enum
        {
            WEAK
        } InjectSolutionKind;


        class InjectSolutionAction: public SolutionAction
        {
        public:

            InjectSolutionAction( PoolItem item,
                                  const InjectSolutionKind & kind)
                : SolutionAction(),
                  _item( item ),
                  _kind( kind ) {}

          // ---------------------------------- I/O
          virtual std::ostream & dumpOn( std::ostream & str ) const;
          friend std::ostream& operator<<(std::ostream& str, const InjectSolutionAction & action)
                { return action.dumpOn (str); }

          // ---------------------------------- accessors
            const PoolItem item() const { return _item; }

          // ---------------------------------- methods
            virtual bool execute(ResolverInternal & resolver) const;

        protected:
            PoolItem _item;
            const InjectSolutionKind _kind;
        };


    };// namespace detail
  };// namespace solver
};// namespace zypp
#endif // ZYPP_USE_RESOLVER_INTERNALS
#endif // ZYPP_SOLVER_DETAIL_SOLUTIONACTION_H