Resolver.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RESOLVER_H
#define ZYPP_RESOLVER_H

#include <iosfwd>
#include <functional>

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

#include "zypp/ResPool.h"
#include "zypp/UpgradeStatistics.h"
#include "zypp/solver/detail/Resolver.h"
#include "zypp/solver/detail/ResolverContext.h"
#include "zypp/ProblemTypes.h"

namespace zypp
{ 



  //
  //    CLASS NAME : Resolver
  //
  class Resolver : public base::ReferenceCounted, private base::NonCopyable
  {
  public:

    Resolver( const ResPool & pool );
    virtual ~Resolver();

    bool verifySystem ();

    bool verifySystem (bool considerNewHardware);

    bool establishPool (void);

    bool freshenPool (void);

    bool resolvePool (void);      

    bool resolvePool (bool tryAllPossibilities);
      
    bool resolveDependencies( void );

    /*
     * Undo solver changes done in resolvePool()
     * Throwing away all ignored dependencies.
     */
    void undo( void );

    /*
     * Get the most recent resolver context
     *
     * It will be NULL if resolvePool() or establishPool() was never called.
     * Depending on the return code of the last resolvePool() call,
     * it _either_ points to a valid or an invalid solution.
     */
    solver::detail::ResolverContext_Ptr context (void) const;

    void doUpgrade( UpgradeStatistics & opt_stats_r );

    std::list<PoolItem_Ref> problematicUpdateItems( void ) const;

    ResolverProblemList problems();

    std::list<std::string> problemDescription( void ) const;      

    void applySolutions( const ProblemSolutionList & solutions );

    Arch architecture() const;
    void setArchitecture( const Arch & arch);

    void setForceResolve (const bool force);
    const bool forceResolve();

    void setPreferHighestVersion (const bool highestVersion);
    const bool preferHighestVersion();      

    bool transactResObject( ResObject::constPtr robj, bool install = true);

    bool transactResKind( Resolvable::Kind kind );

    void transactReset( ResStatus::TransactByValue causer );

    void addRequire (const Capability & capability);

    void addConflict (const Capability & capability);      
      
    void setTimeout( int seconds );

    int timeout();      

    void setMaxSolverPasses (int count);

    int maxSolverPasses ();

    bool createSolverTestcase (const std::string & dumpPath = "/var/log/YaST2/solverTestcase");


    const solver::detail::ItemCapKindList isInstalledBy (const PoolItem_Ref item);

    const solver::detail::ItemCapKindList installs (const PoolItem_Ref item);
      

  protected:

  private:
    solver::detail::Resolver_Ptr _pimpl;
  };

} // namespace zypp
#endif // ZYPP_RESOLVER_H

---