Transaction.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
extern "C"
{
  struct _Transaction;
}
#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/base/DefaultIntegral.h"

#include "zypp/sat/SolvIterMixin.h"
#include "zypp/sat/Solvable.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;


      public:
        class 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;
    }

  } // namespace sat
} // namespace zypp
#endif // ZYPP_SAT_TRANSACTION_H