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

#include <list>
#include <string>

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

#include "zypp/Dep.h"
#include "zypp/Capability.h"

#include "zypp/solver/detail/Types.h"
#include "zypp/solver/detail/Resolver.h"

namespace zypp
{ 

  namespace solver
  { 

    namespace detail
    { 

        class SolutionAction : public base::ReferenceCounted
        {
        protected:
            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);
            friend std::ostream& operator<<(std::ostream & str, const CSolutionActionList & actionlist);

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


        typedef enum
        {
            KEEP,
            INSTALL,
            REMOVE,
            UNLOCK,
            ALLBRANCHES_ON,
            ALLBRANCHES_OFF,        
            DOUBLETIMEOUT
        } TransactionKind;


        class TransactionSolutionAction: public SolutionAction
        {
        public:
            TransactionSolutionAction( PoolItem_Ref item,
                                       TransactionKind action )
                : SolutionAction(),
                  _item( 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_Ref item() const { return _item; }
          const TransactionKind action() const { return _action; }

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

        protected:

            PoolItem_Ref _item;
            const TransactionKind _action;
        };


        typedef enum
        {
            REQUIRES,
            CONFLICTS,
            OBSOLETES,
            INSTALLED,
            ARCHITECTURE,
            VENDOR
        } InjectSolutionKind;


        class InjectSolutionAction: public SolutionAction
        {
        public:

            InjectSolutionAction( PoolItem_Ref item,
                                  const Capability & capability,
                                  const InjectSolutionKind & kind)
                : SolutionAction(),
                  _item( item ), _capability( capability ),
                  _kind( kind ), _otherItem() {}

            InjectSolutionAction( PoolItem_Ref item,
                                  const InjectSolutionKind & kind)
                : SolutionAction(),
                  _item( item ), _capability(),
                  _kind( kind ), _otherItem() {}

            InjectSolutionAction( PoolItem_Ref item,
                                  const Capability & capability,
                                  const InjectSolutionKind & kind,
                                  PoolItem_Ref otherItem)
                : SolutionAction(),
                  _item( item ), _capability( capability ),
                  _kind( kind ), _otherItem( otherItem ) {}

          // ---------------------------------- 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 Capability & capability() const { return _capability; };
            const PoolItem_Ref item() const { return _item; }

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

        protected:
            PoolItem_Ref _item;
            const Capability _capability;
            const InjectSolutionKind _kind;
            PoolItem_Ref _otherItem;
        };


    };// namespace detail
  };// namespace solver
};// namespace zypp

#endif // ZYPP_SOLVER_DETAIL_SOLUTIONACTION_H

---