Imported Upstream version 14.45.0

[platform/upstream/libzypp.git] / zypp / solver / detail / SolutionAction.h

diff --git a/zypp/solver/detail/SolutionAction.h b/zypp/solver/detail/SolutionAction.h
index 34451a9..84b49db 100644 (file)
--- a/zypp/solver/detail/SolutionAction.h
+++ b/zypp/solver/detail/SolutionAction.h
@@ -1,4 +1,4 @@
-/**
+/*
  *
  * Easy-to use interface to the ZYPP dependency resolver
  *
@@ -15,11 +15,12 @@
 #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"
-#include "zypp/solver/detail/ProblemSolutionPtr.h"
-#include "zypp/solver/detail/ResolverProblemPtr.h"
-#include "zypp/solver/detail/SolutionActionPtr.h"
+#include "zypp/solver/detail/SolverQueueItem.h"
 
 /////////////////////////////////////////////////////////////////////////
 namespace zypp
@@ -36,111 +37,134 @@ namespace zypp
         **/
        class SolutionAction : public base::ReferenceCounted
        {
+       protected:
+           SolutionAction ();
        public:
-         SolutionAction();
-         virtual ~SolutionAction();
-
-         // ---------------------------------- I/O
+           virtual ~SolutionAction();
 
-         static std::string toString (const SolutionAction & action);
-         static std::string toString (const SolutionActionList & actionlist);
-         static std::string toString (const CSolutionActionList & actionlist);
+           // ---------------------------------- 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);
 
-         virtual std::ostream & dumpOn(std::ostream & str ) const = 0;
-
-         friend std::ostream& operator<<(std::ostream&, const SolutionAction & action);
-
-         virtual std::string asString (void) const = 0;
-
-         // ---------------------------------- methods
+           // ---------------------------------- methods
            /**
             * Execute this action.
             * Returns 'true' on success, 'false' on error.
             **/
-           virtual bool execute() = 0;
+           virtual bool execute (Resolver & resolver) const = 0;
        };
 
 
        /**
         * A problem solution action that performs a transaction
-        * (installs, updates, removes, ...)  one resolvable
+        * (installs, removes, keep ...)  one resolvable
         * (package, patch, pattern, product).
         **/
+       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 ) {}
 
-           typedef enum
-           {
-               // TO DO: use some already existing enum (?)
-               Keep,
-               Install,
-               Update,
-               Remove
-           } TransactionKind;
+           TransactionSolutionAction( Capability capability,
+                                      TransactionKind action )
+               : SolutionAction(),
+                 _capability( capability ), _action( action ) {}
 
 
-           TransactionSolutionAction( ResItem_constPtr resolvable,
+           TransactionSolutionAction( SolverQueueItem_Ptr item,
                                       TransactionKind action )
-               : SolutionAction(), _resolvable( resolvable ), _action( 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); }
 
-         static std::string toString (const TransactionSolutionAction & action);
+         // ---------------------------------- accessors
 
-         virtual std::ostream & dumpOn(std::ostream & str ) const;
+         const PoolItem item() const { return _item; }
+         const Capability capability() const { return _capability; }
+         TransactionKind action() const { return _action; }
 
-         friend std::ostream& operator<<(std::ostream&, const TransactionSolutionAction & action);
+         // ---------------------------------- methods
+           virtual bool execute(Resolver & resolver) const;
 
-         std::string asString (void) const;
+       protected:
 
-         // ---------------------------------- accessors
-           ResItem_constPtr resolvable() const { return _resolvable; }
-           TransactionKind action()     const { return _action;     }
+           PoolItem _item;
+           Capability _capability;
+           SolverQueueItem_Ptr _solverQueueItem;
 
-         // ---------------------------------- methods
-           virtual bool execute();
+           const TransactionKind _action;
+       };
 
 
-       protected:
+       /**
+        * Type of ignoring; currently only WEAK
+        **/
 
-           ResItem_constPtr    _resolvable;
-           TransactionKind     _action;
-       };
+       typedef enum
+       {
+           WEAK
+       } InjectSolutionKind;
 
 
        /**
         * A problem solution action that injects an artificial "provides" to
-        * the pool to satisfy open requirements.
+        * the pool to satisfy open requirements or remove the conflict of
+        * concerning resolvable
         *
         * This is typically used by "ignore" (user override) solutions.
         **/
        class InjectSolutionAction: public SolutionAction
        {
        public:
-           
-           InjectSolutionAction( const Capability & provides )
-               : SolutionAction(), _capability( provides ) {}
-
-         // ---------------------------------- I/O
-
-         static std::string toString (const InjectSolutionAction & action);
 
-         virtual std::ostream & dumpOn(std::ostream & str ) const;
+           InjectSolutionAction( PoolItem item,
+                                 const InjectSolutionKind & kind)
+               : SolutionAction(),
+                 _item( item ),
+                 _kind( kind ) {}
 
-         friend std::ostream& operator<<(std::ostream&, const InjectSolutionAction & action);
-
-         std::string asString (void) const;
+         // ---------------------------------- 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 item() const { return _item; }
 
          // ---------------------------------- methods
-           virtual bool execute();
+           virtual bool execute(Resolver & resolver) const;
 
        protected:
-
-           const Capability & _capability;
+           PoolItem _item;
+           const InjectSolutionKind _kind;
        };