zypp/Repository.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/Repository.h
  10  *
  11 */
  12 #ifndef ZYPP_SAT_REPOSITORY_H
  13 #define ZYPP_SAT_REPOSITORY_H
  14
  15 #include <iosfwd>
  16 #include "zypp/base/SafeBool.h"
  17 #include "zypp/Pathname.h"
  18 #include "zypp/sat/detail/PoolMember.h"
  19 #include "zypp/sat/Solvable.h"
  20 #include "zypp/RepoInfo.h"
  21 #include "zypp/Date.h"
  22
  23 ///////////////////////////////////////////////////////////////////
  24 namespace zypp
  25 { /////////////////////////////////////////////////////////////////
  26
  27     namespace detail
  28     {
  29       struct ByRepository;
  30     }
  31
  32     ///////////////////////////////////////////////////////////////////
  33     //
  34     //  CLASS NAME : Repository
  35     //
  36     /** */
  37     class Repository : protected sat::detail::PoolMember,
  38                        private base::SafeBool<Repository>
  39     {
  40     public:
  41         typedef filter_iterator<detail::ByRepository, sat::detail::SolvableIterator> SolvableIterator;
  42         typedef sat::detail::size_type size_type;
  43         typedef sat::detail::RepoIdType IdType;
  44
  45     public:
  46         /** Default ctor creates \ref noRepository.*/
  47         Repository()
  48         : _id( sat::detail::noRepoId ) {}
  49
  50         /** \ref PoolImpl ctor. */
  51         explicit Repository( IdType id_r )
  52         : _id( id_r ) {}
  53
  54     public:
  55         /** Represents no \ref Repository. */
  56         static const Repository noRepository;
  57
  58 #ifndef SWIG // Swig treats it as syntax error
  59         /** Evaluate \ref Repository in a boolean context (\c != \c noRepository). */
  60         using base::SafeBool<Repository>::operator bool_type;
  61 #endif
  62         /** Return whether this is the system repository. */
  63         bool isSystemRepo() const;
  64
  65     public:
  66          /**
  67           * Short unique, convenience string to refer to a repo.
  68           * ie: openSUSE-10.3
  69           *
  70           * If you are looking for a label to display
  71           * see \ref info() which provides \ref RepoInfo::name()
  72           * ie: "openSUSE 10.3 Main repository"
  73           *
  74           */
  75         std::string alias() const;
  76
  77          /**
  78           * Short unique, convenience string to refer to a repo.
  79           * ie: openSUSE-10.3
  80           *
  81           * The sat solver uses name for what we know as alias
  82           * In rpm repositories, name is a label string
  83           * ie: "openSUSE 10.3 Main repository"
  84           *
  85           * We know follow rpm conventions and ignore satsolver
  86           * wording for name.
  87           *
  88           * Use \ref alias() instead
  89           */
  90         ZYPP_DEPRECATED std::string name() const
  91         { return alias(); }
  92
  93         /**
  94          * Timestamp when this repository was generated
  95          *
  96          * Usually this value is calculated as the newer
  97          * timestamp from the timestamp of all the resources
  98          * that conform the repository's metadata.
  99          *
 100          * For example in a rpm-md repository, it would be
 101          * the resource specified in the xml file whith
 102          * the newest timestamp attribute (which is the
 103          * timestamp of the file in the server ).
 104          *
 105          * The timestamp is 0 if the repository does not
 106          * specify when it was generated.
 107          *
 108          */
 109         zypp::Date generatedTimestamp() const;
 110
 111         /**
 112          * Suggested expiration timestamp.
 113          *
 114          * Repositories can define an amount of time
 115          * they expire, with the generated timestamp as
 116          * the base point of time.
 117          *
 118          * Note that is the responsability of the repository
 119          * to freshen the generated timestamp to tell the
 120          * client that the repo is alive and updating the
 121          * metadata.
 122          *
 123          * The timestamp is 0 if the repository does not specify
 124          * an expiration date.
 125          *
 126          */
 127         zypp::Date suggestedExpirationTimestamp() const;
 128
 129         /**
 130          * The suggested expiration date of this repository
 131          * already passed
 132          *
 133          */
 134         bool maybeOutdated() const;
 135
 136         /** Whether \ref Repository contains solvables. */
 137         bool solvablesEmpty() const;
 138
 139         /** Number of solvables in \ref Repository. */
 140         size_type solvablesSize() const;
 141
 142         /** Iterator to the first \ref Solvable. */
 143         SolvableIterator solvablesBegin() const;
 144
 145         /** Iterator behind the last \ref Solvable. */
 146         SolvableIterator solvablesEnd() const;
 147
 148     public:
 149         /** Return any associated \ref RepoInfo. */
 150         RepoInfo info() const;
 151
 152         /** Set \ref RepoInfo for this repository.
 153          * \throws Exception if this is \ref noRepository
 154          * \throws Exception if the \ref RepoInfo::alias
 155          *         does not match the \ref Repository::name.
 156          */
 157         void setInfo( const RepoInfo & info_r );
 158
 159         /** Remove any \ref RepoInfo set for this repository. */
 160         void clearInfo();
 161
 162     public:
 163         /** Remove this \ref Repository from it's \ref Pool. */
 164         void eraseFromPool();
 165
 166         /** Functor calling \ref eraseFromPool. */
 167         struct EraseFromPool;
 168
 169    public:
 170         /** Return next Repository in \ref Pool (or \ref noRepository). */
 171         Repository nextInPool() const;
 172
 173    public:
 174         /** \name Repository content manipulating methods.
 175          * \todo maybe a separate Repository/Solvable content manip interface
 176          * provided by the pool.
 177          */
 178         //@{
 179         /** Load \ref Solvables from a solv-file.
 180          * In case of an exception the repository remains in the \ref Pool.
 181          * \throws Exception if this is \ref noRepository
 182          * \throws Exception if loading the solv-file fails.
 183          * \see \ref Pool::addRepoSolv and \ref Repository::EraseFromPool
 184          */
 185         void addSolv( const Pathname & file_r );
 186
 187         /** Add \c count_r new empty \ref Solvable to this \ref Repository. */
 188         sat::Solvable::IdType addSolvables( unsigned count_r );
 189         /** \overload Add only one new \ref Solvable. */
 190         sat::Solvable::IdType addSolvable()
 191             { return addSolvables( 1 ); }
 192         //@}
 193
 194     public:
 195         /** Expert backdoor. */
 196         ::_Repo * get() const;
 197         /** Expert backdoor. */
 198         IdType id() const { return _id; }
 199     private:
 200 #ifndef SWIG // Swig treats it as syntax error
 201         friend base::SafeBool<Repository>::operator bool_type() const;
 202 #endif
 203         bool boolTest() const { return get(); }
 204     private:
 205         IdType _id;
 206     };
 207     ///////////////////////////////////////////////////////////////////
 208
 209     /** \relates Repository Stream output */
 210     std::ostream & operator<<( std::ostream & str, const Repository & obj );
 211
 212     /** \relates Repository */
 213     inline bool operator==( const Repository & lhs, const Repository & rhs )
 214     { return lhs.get() == rhs.get(); }
 215
 216     /** \relates Repository */
 217     inline bool operator!=( const Repository & lhs, const Repository & rhs )
 218     { return lhs.get() != rhs.get(); }
 219
 220     /** \relates Repository */
 221     inline bool operator<( const Repository & lhs, const Repository & rhs )
 222     { return lhs.get() < rhs.get(); }
 223
 224     ///////////////////////////////////////////////////////////////////
 225     //
 226     //  CLASS NAME : Repository::EraseFromPool
 227     //
 228     /** Functor removing \ref Repository from it's \ref Pool.
 229      *
 230      * E.g. used as dispose function in. \ref AutoDispose
 231      * to provide a convenient and exception safe temporary
 232      * \ref Repository.
 233      * \code
 234      *  sat::Pool satpool;
 235      *  MIL << "1 " << satpool << endl;
 236      *  {
 237      *    AutoDispose<Repository> tmprepo( (Repository::EraseFromPool()) );
 238      *    *tmprepo = satpool.reposInsert( "A" );
 239      *    tmprepo->addSolv( "sl10.1-beta7-packages.solv" );
 240      *    DBG << "2 " << satpool << endl;
 241      *    // Calling 'tmprepo.resetDispose();' here
 242      *    // would keep the Repo.
 243      *  }
 244      *  MIL << "3 " << satpool << endl;
 245      * \endcode
 246      * \code
 247      * 1 sat::pool(){0repos|2slov}
 248      * 2 sat::pool(){1repos|2612slov}
 249      * 3 sat::pool(){0repos|2slov}
 250      * \endcode
 251      * Leaving the block without calling <tt>tmprepo.resetDispose();</tt>
 252      * before, will automatically remove the \ref Repo from it's \ref Pool.
 253      */
 254     struct Repository::EraseFromPool
 255     {
 256         void operator()( Repository repository_r ) const
 257             { repository_r.eraseFromPool(); }
 258     };
 259     ///////////////////////////////////////////////////////////////////
 260     ///////////////////////////////////////////////////////////////////
 261     namespace detail
 262     { /////////////////////////////////////////////////////////////////
 263       ///////////////////////////////////////////////////////////////////
 264       //
 265       //        CLASS NAME : RepositoryIterator
 266       //
 267       /** */
 268         class RepositoryIterator : public boost::iterator_adaptor<
 269             RepositoryIterator                            // Derived
 270                            , ::_Repo **                   // Base
 271                            , Repository                   // Value
 272                            , boost::forward_traversal_tag // CategoryOrTraversal
 273                            , Repository                   // Reference
 274                              >
 275         {
 276         public:
 277             RepositoryIterator()
 278                 : RepositoryIterator::iterator_adaptor_( 0 )
 279                 {}
 280
 281             explicit RepositoryIterator( ::_Repo ** p )
 282                 : RepositoryIterator::iterator_adaptor_( p )
 283                 {}
 284
 285         private:
 286             friend class boost::iterator_core_access;
 287
 288             Repository dereference() const
 289                 { return Repository( *base() ); }
 290         };
 291         ///////////////////////////////////////////////////////////////////
 292         ///////////////////////////////////////////////////////////////////
 293         //
 294         //      CLASS NAME : ByRepository
 295         //
 296         /** Functor filtering \ref Solvable by \ref Repository.*/
 297         struct ByRepository
 298         {
 299         public:
 300             ByRepository( const Repository & repository_r ) : _repository( repository_r ) {}
 301             ByRepository( sat::detail::RepoIdType id_r ) : _repository( id_r ) {}
 302             ByRepository() {}
 303
 304             bool operator()( const sat::Solvable & slv_r ) const
 305                 { return slv_r.repository() == _repository; }
 306
 307         private:
 308             Repository _repository;
 309         };
 310         ///////////////////////////////////////////////////////////////////
 311         /////////////////////////////////////////////////////////////////
 312     } // namespace detail
 313     ///////////////////////////////////////////////////////////////////
 314
 315     /////////////////////////////////////////////////////////////////
 316 } // namespace zypp
 317 ///////////////////////////////////////////////////////////////////
 318 #endif // ZYPP_SAT_REPOSITORY_H