PMObjectContainerIter.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       PMObjectContainerIter.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

/-*/
#ifndef PMObjectContainerIter_h
#define PMObjectContainerIter_h

#include <vector>
#include <list>
#include <set>

#include <y2pm/PMObjectPtr.h>
#include <y2pm/PMPackagePtr.h>
#include <y2pm/PMSelectionPtr.h>
#include <y2pm/PMYouPatchPtr.h>

//
//      CLASS NAME : PMObjectContainerIter
class PMObjectContainerIter {

  private:

    class ContBase {
      public:
        ContBase() {}
        virtual ~ContBase() {}
        virtual ContBase *  clone()    const = 0;
      public:
        virtual void        setBegin()       = 0;
        virtual void        setNext()        = 0;
        virtual bool        atEnd()    const = 0;
        virtual PMObjectPtr get()      const = 0;
        virtual unsigned    size()     const = 0;
    };

    template <class Ptr> class StdCont : public ContBase {
      private:
        const Ptr &                  _cont;
        typename Ptr::const_iterator _iter;

        template <typename Tp>
        PMObjectPtr _get( const Tp & ) const { return *_iter; }

        template <typename Tp,class ObjPtr>
        PMObjectPtr _get( const std::map<Tp,ObjPtr> & ) const { return _iter->second; }

      public:
        StdCont( const Ptr & cont_r ) : _cont( cont_r ) { _iter = cont_r.begin(); }
        virtual ~StdCont() {}
        virtual ContBase *  clone()    const { return new StdCont( *this ); }
      public:
        virtual void        setBegin()       { _iter = _cont.begin(); }
        virtual void        setNext()        { ++_iter; }
        virtual bool        atEnd()    const { return ( _iter == _cont.end() ); }
        virtual PMObjectPtr get()      const { return _get( _cont ); }
        virtual unsigned    size()     const { return _cont.size(); }
   };


  private:

    ContBase * _cont;

  public:
    template <class ObjPtr>
    PMObjectContainerIter( const std::vector<ObjPtr> & cont_r ) {
      _cont = new StdCont<std::vector<ObjPtr> >( cont_r );
    }
    template <class ObjPtr>
    PMObjectContainerIter( const std::list<ObjPtr> & cont_r ) {
      _cont = new StdCont<std::list<ObjPtr> >( cont_r );
    }
    template <class ObjPtr>
    PMObjectContainerIter( const std::set<ObjPtr> & cont_r ) {
      _cont = new StdCont<std::set<ObjPtr> >( cont_r );
    }
    template <typename Tp,class ObjPtr>
    PMObjectContainerIter( const std::map<Tp,ObjPtr> & cont_r ) {
      _cont = new StdCont<std::map<Tp,ObjPtr> >( cont_r );
    }

#if 0
    PMObjectContainerIter( const std::vector<PMObjectPtr> & cont_r ) {
      _cont = new StdCont<std::vector<PMObjectPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::list<PMObjectPtr> & cont_r ) {
      _cont = new StdCont<std::list<PMObjectPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::set<PMObjectPtr> & cont_r ) {
      _cont = new StdCont<std::set<PMObjectPtr> >( cont_r );
    }

    PMObjectContainerIter( const std::vector<PMPackagePtr> & cont_r ) {
      _cont = new StdCont<std::vector<PMPackagePtr> >( cont_r );
    }
    PMObjectContainerIter( const std::list<PMPackagePtr> & cont_r ) {
      _cont = new StdCont<std::list<PMPackagePtr> >( cont_r );
    }
    PMObjectContainerIter( const std::set<PMPackagePtr> & cont_r ) {
      _cont = new StdCont<std::set<PMPackagePtr> >( cont_r );
    }

    PMObjectContainerIter( const std::vector<PMSelectionPtr> & cont_r ) {
      _cont = new StdCont<std::vector<PMSelectionPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::list<PMSelectionPtr> & cont_r ) {
      _cont = new StdCont<std::list<PMSelectionPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::set<PMSelectionPtr> & cont_r ) {
      _cont = new StdCont<std::set<PMSelectionPtr> >( cont_r );
    }

    PMObjectContainerIter( const std::vector<PMYouPatchPtr> & cont_r ) {
      _cont = new StdCont<std::vector<PMYouPatchPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::list<PMYouPatchPtr> & cont_r ) {
      _cont = new StdCont<std::list<PMYouPatchPtr> >( cont_r );
    }
    PMObjectContainerIter( const std::set<PMYouPatchPtr> & cont_r ) {
      _cont = new StdCont<std::set<PMYouPatchPtr> >( cont_r );
    }
#endif

  public:

    PMObjectContainerIter( const PMObjectContainerIter & rhs ) : _cont( 0 ) {
      if ( rhs._cont ) {
        _cont = rhs._cont->clone();
      }
    }

    PMObjectContainerIter & operator = ( const PMObjectContainerIter & rhs ) {
      if ( &rhs != this ) {
        delete _cont;
        if ( rhs._cont ) {
          _cont = rhs._cont->clone();
        } else {
          _cont = 0;
        }
      }
      return *this;
    }

    ~PMObjectContainerIter() {
      delete _cont;
    }

  public:

    void setBegin() { _cont->setBegin(); }

    void setNext() { _cont->setNext(); }

    bool atEnd() const { return _cont->atEnd(); }

    PMObjectPtr operator * () const { return _cont->get(); }

    PMObjectPtr operator -> () const { return _cont->get(); }

    unsigned size() const { return _cont->size(); }

    bool empty() const { return ( size() == 0 ); }
};


#endif // PMObjectContainerIter_h

---