Transaction.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_TRANSACTION_H
#define ZYPP_SAT_TRANSACTION_H
 
#include <iosfwd>
 
#include <zypp/base/PtrTypes.h>
#include <zypp/base/Flags.h>
#include <zypp/base/Iterator.h>
#include <zypp-core/base/DefaultIntegral>
 
#include <zypp/sat/SolvIterMixin.h>
#include <zypp/sat/Solvable.h>
#include <zypp/sat/Queue.h>
 
#include <zypp/PoolItem.h>
 
namespace zypp
{ 
  namespace sat
  { 
 
    namespace detail
    {
      class Transaction_iterator;
      class Transaction_const_iterator;
    }
 
    class Transaction : public SolvIterMixin<Transaction, detail::Transaction_const_iterator>
    {
      friend std::ostream & operator<<( std::ostream & str, const Transaction & obj );
      friend std::ostream & dumpOn( std::ostream & str, const Transaction & obj );
      friend bool operator==( const Transaction & lhs, const Transaction & rhs );
 
     public:
       class Step;
 
       enum StepType
       {
         TRANSACTION_IGNORE             = 0x00, 
         TRANSACTION_ERASE              = 0x10, 
         TRANSACTION_INSTALL            = 0x20, 
         TRANSACTION_MULTIINSTALL       = 0x30  
       };
 
       enum StepStage
       {
         STEP_TODO      = (1 << 0),     
         STEP_DONE      = (1 << 1),     
         STEP_ERROR     = (1 << 2),     
       };
 
       ZYPP_DECLARE_FLAGS(StepStages,StepStage);
 
     public:
       struct LoadFromPoolType {};      
       static constexpr LoadFromPoolType loadFromPool = LoadFromPoolType();
 
     public:
        Transaction();
 
        Transaction( LoadFromPoolType );
 
        ~Transaction();
 
      public:
        bool valid() const;
 
        explicit operator bool() const
        { return valid(); }
 
        bool order();
 
        bool empty() const;
 
        size_t size() const;
 
        typedef detail::Transaction_iterator iterator;
        typedef detail::Transaction_const_iterator const_iterator;
 
        const_iterator begin() const;
        iterator begin();
 
        const_iterator end() const;
        iterator end();
 
        const_iterator find( const sat::Solvable & solv_r ) const;
        iterator find( const sat::Solvable & solv_r );
        const_iterator find( const ResObject::constPtr & resolvable_r ) const;
        iterator find( const ResObject::constPtr & resolvable_r );
        const_iterator find( const PoolItem & pi_r ) const;
        iterator find( const PoolItem & pi_r );
 
      public:
        struct FilterAction;
        typedef filter_iterator<FilterAction,const_iterator> action_iterator;
 
        bool actionEmpty( StepStages filter_r = StepStages() ) const;
 
        size_t actionSize( StepStages filter_r = StepStages() ) const;
 
        action_iterator actionBegin( StepStages filter_r = StepStages() ) const;
 
        action_iterator actionEnd() const;
 
        Iterable<action_iterator> action( StepStages filter_r = StepStages() ) const;
 
      public:
        int installedResult( Queue & result_r ) const;
 
        StringQueue autoInstalled() const;
 
        void autoInstalled( const StringQueue & queue_r );
 
      public:
        struct Impl;
      private:
        RW_pointer<Impl> _pimpl;
    };
 
    ZYPP_DECLARE_OPERATORS_FOR_FLAGS(Transaction::StepStages);
 
    std::ostream & operator<<( std::ostream & str, const Transaction & obj );
 
    std::ostream & dumpOn( std::ostream & str, const Transaction & obj );
 
    bool operator==( const Transaction & lhs, const Transaction & rhs );
 
    inline bool operator!=( const Transaction & lhs, const Transaction & rhs )
    { return !( lhs == rhs ); }
 
 
    class Transaction::Step
    {
      friend std::ostream & operator<<( std::ostream & str, const Step & obj );
 
      public:
        Step();
        Step( const RW_pointer<Impl> & pimpl_r, detail::IdType id_r )
          : _solv( id_r )
          , _pimpl( pimpl_r )
        {}
 
      public:
        StepType stepType() const;
 
        StepStage stepStage() const;
 
        void stepStage( StepStage val_r );
 
        Solvable satSolvable() const
        { return _solv; }
 
        IdString ident() const;
 
        Edition edition() const;
 
        Arch arch() const;
 
        operator const Solvable &() const { return _solv; }
        operator Solvable &() { return _solv; }
 
      private:
        Solvable _solv;
        RW_pointer<Impl> _pimpl;
    };
 
    std::ostream & operator<<( std::ostream & str, const Transaction::Step & obj );
 
    std::ostream & operator<<( std::ostream & str, Transaction::StepType obj );
 
    std::ostream & operator<<( std::ostream & str, Transaction::StepStage obj );
 
    namespace detail
    { 
 
      class Transaction_iterator : public boost::iterator_adaptor<
      Transaction_iterator              // Derived
      , const detail::IdType *          // Base
      , Transaction::Step               // Value
      , boost::forward_traversal_tag    // CategoryOrTraversal
      , Transaction::Step               // Reference
      >
      {
        public:
          Transaction_iterator();
          Transaction_iterator( const RW_pointer<Transaction::Impl> & pimpl_r, base_type id_r )
          : Transaction_iterator::iterator_adaptor_( id_r )
          , _pimpl( pimpl_r )
          {}
 
        private:
          friend class boost::iterator_core_access;
 
          reference dereference() const
          { return Transaction::Step( _pimpl, *base() ); }
 
        private:
          friend class Transaction_const_iterator;
          RW_pointer<Transaction::Impl> _pimpl;
      };
 
      class Transaction_const_iterator : public boost::iterator_adaptor<
      Transaction_const_iterator        // Derived
      , const detail::IdType *          // Base
      , const Transaction::Step         // Value
      , boost::forward_traversal_tag    // CategoryOrTraversal
      , const Transaction::Step         // Reference
      >
      {
        public:
          Transaction_const_iterator();
          Transaction_const_iterator( const Transaction_iterator & iter_r );
          Transaction_const_iterator( const RW_pointer<Transaction::Impl> & pimpl_r, base_type id_r )
          : Transaction_const_iterator::iterator_adaptor_( id_r )
          , _pimpl( pimpl_r )
          {}
 
        private:
          friend class boost::iterator_core_access;
 
          reference dereference() const
          { return Transaction::Step( _pimpl, *base() ); }
 
        private:
          RW_pointer<Transaction::Impl> _pimpl;
      };
 
    } // namespace detail
 
    inline Transaction::const_iterator Transaction::find( const ResObject::constPtr & resolvable_r ) const
    { return( resolvable_r ? find( resolvable_r->satSolvable() ) : end() ); }
 
    inline Transaction::iterator Transaction::find( const ResObject::constPtr & resolvable_r )
    { return( resolvable_r ? find( resolvable_r->satSolvable() ) : end() ); }
 
    inline Transaction::const_iterator Transaction::find( const PoolItem & pi_r ) const
    { return find( pi_r.satSolvable() ); }
 
    inline Transaction::iterator Transaction::find( const PoolItem & pi_r )
    { return find( pi_r.satSolvable() ); }
 
 
    struct  Transaction::FilterAction
    {
      FilterAction() {}
      FilterAction( StepStages filter_r ) : _filter( filter_r ) {}
 
      bool operator()( const Transaction::Step & step_r ) const
      {
        if ( step_r.stepType() == Transaction::TRANSACTION_IGNORE )
          return false; // no action
        return !_filter || _filter.testFlag( step_r.stepStage() );
      }
 
      StepStages _filter;
    };
 
    inline Transaction::action_iterator Transaction::actionBegin( StepStages filter_r ) const
    { return make_filter_begin( FilterAction( filter_r ), *this ); }
 
    inline Transaction::action_iterator Transaction::actionEnd() const
    { return make_filter_end( FilterAction(), *this ); }
 
    inline bool Transaction::actionEmpty( StepStages filter_r ) const
    { return( actionBegin( filter_r ) == actionEnd() ); }
 
    inline size_t Transaction::actionSize( StepStages filter_r ) const
    {
      size_t cnt = 0;
      for_( it, actionBegin( filter_r ), actionEnd() )
        ++cnt;
      return cnt;
    }
 
    inline Iterable<Transaction::action_iterator> Transaction::action( StepStages filter_r ) const
    { return makeIterable( actionBegin( filter_r ), actionEnd() ); }
 
  } // namespace sat
} // namespace zypp
#endif // ZYPP_SAT_TRANSACTION_H