SelectableImpl.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/base/PtrTypes.h"

#include "zypp/ui/Selectable.h"
#include "zypp/ui/SelectableTraits.h"

namespace zypp
{ 

  namespace ui
  { 

    //
    //  CLASS NAME : Selectable::Impl
    //
    struct Selectable::Impl
    {
      friend std::ostream & operator<<( std::ostream & str, const Selectable::Impl & obj );

    public:

      typedef SelectableTraits::AvialableItemSet             AvialableItemSet;
      typedef SelectableTraits::availableItem_iterator       availableItem_iterator;
      typedef SelectableTraits::availableItem_const_iterator availableItem_const_iterator;
      typedef SelectableTraits::availableItem_size_type      availableItem_size_type;

    public:
      Impl( const ResObject::Kind & kind_r,
            const std::string & name_r,
            const PoolItem & installedItem_r,
            availableItem_const_iterator availableBegin_r,
            availableItem_const_iterator availableEnd_r )
      : _kind( kind_r )
      , _name( name_r )
      , _installedItem( installedItem_r )
      , _availableItems( availableBegin_r, availableEnd_r )
      {
        setCandidate( NULL );
      }

    public:
      ResObject::Kind kind() const
      { return _kind; }

      const std::string & name() const
      { return _name; }

      Status status() const;

      bool set_status( const Status state_r );

      PoolItem installedObj() const
      { return _installedItem; }

      PoolItem candidateObj() const
      {
        PoolItem ret( transactingCandidate() );
        if ( ret )
          return ret;

        if ( _candidate )
          return _candidate;
        return defaultCandidate();
      }

      PoolItem setCandidate( ResObject::constPtr byUser_r );

      PoolItem theObj() const
      {
        PoolItem ret( candidateObj() );
        return( ret ? ret : _installedItem );
      }

      availableItem_size_type availableObjs() const
      { return _availableItems.size(); }

      availableItem_const_iterator availableBegin() const
      { return _availableItems.begin(); }

      availableItem_const_iterator availableEnd() const
      { return _availableItems.end(); }

      ResStatus::TransactByValue modifiedBy() const;

      bool hasLicenceConfirmed() const
      { return candidateObj() && candidateObj().status().isLicenceConfirmed(); }

      void setLicenceConfirmed( bool val_r )
      { if ( candidateObj() ) candidateObj().status().setLicenceConfirmed( val_r ); }

    private:
      PoolItem transactingCandidate() const
      {
        for ( availableItem_const_iterator it = availableBegin();
              it != availableEnd(); ++it )
          {
            if ( (*it).status().transacts() )
              return (*it);
          }
        return PoolItem();
      }

      PoolItem defaultCandidate() const
      {
        if ( installedObj() )
          {
            // prefer the installed objects arch.
            for ( availableItem_const_iterator it = availableBegin();
                  it != availableEnd(); ++it )
              {
                if ( installedObj()->arch() == (*it)->arch() )
                  {
                    return (*it);
                  }
              }
          }
        if ( _availableItems.empty() )
          {
            return PoolItem();
          }
        return *_availableItems.begin();
      }

      bool allCandidatesLocked() const
      {
        for ( availableItem_const_iterator it = availableBegin();
              it != availableEnd(); ++it )
          {
            if ( ! (*it).status().isLocked() )
              return false;
          }
        return( ! _availableItems.empty() );
      }

    private:
      ResObject::Kind  _kind;
      std::string      _name;
      PoolItem         _installedItem;
      AvialableItemSet _availableItems;
      PoolItem         _candidate;
    };

    inline std::ostream & operator<<( std::ostream & str, const Selectable::Impl & obj )
    {
      return str << '[' << obj.kind() << ']' << obj.name() << ": " << obj.status()
                 << " (I " << obj._installedItem << ")"
                 << " (A " << obj._availableItems.size() << ")"
                 << obj.candidateObj();
    }

  } // namespace ui
} // namespace zypp
#endif // ZYPP_UI_SELECTABLEIMPL_H

---