librpmDb.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/PathInfo.h"
#include "zypp/Package.h"
#include "zypp/target/rpm/RpmHeader.h"
#include "zypp/target/rpm/RpmException.h"

namespace zypp {
  namespace target {
    namespace rpm {

      //
      //        CLASS NAME : librpmDb
      class librpmDb : public base::ReferenceCounted, private base::NonCopyable
      {
        public:
          typedef intrusive_ptr<librpmDb> Ptr;
          typedef intrusive_ptr<const librpmDb> constPtr;
        private:
        static void dbAccess( librpmDb::Ptr & ptr_r );

        public:

          //
          //    static interface
          //
        private:

          static Pathname _defaultRoot;

          static Pathname _defaultDbPath;

          static librpmDb::constPtr _defaultDb;

          static bool _dbBlocked;

          static librpmDb * newLibrpmDb( Pathname root_r, Pathname dbPath_r, bool readonly_r );

          static void dbAccess();

        public:

          static bool globalInit();

          static std::string expand( const std::string & macro_r );

          static std::string stringPath( const Pathname & root_r, const Pathname & sub_r ) {
            return std::string( "'(" ) + root_r.asString() + ")" + sub_r.asString() + "'";
          }

        public:

          static const Pathname & defaultRoot() { return _defaultRoot; }

          static const Pathname & defaultDbPath() { return _defaultDbPath; }

          static void dbAccess( const Pathname & root_r, const Pathname & dbPath_r );

          static void dbAccess( librpmDb::constPtr & ptr_r );

          static unsigned dbRelease( bool force_r = false );

          static unsigned blockAccess();

          static void unblockAccess();

          static bool isBlocked() { return _dbBlocked; }

          static std::ostream & dumpState( std::ostream & str );

        public:

          class DbDirInfo;

          class db_const_iterator;

        private:
          //
          //    internal database handle interface (nonstatic)
          //

          class D;
          D & _d;

        protected:

          librpmDb( const Pathname & root_r, const Pathname & dbPath_r, bool readonly_r );

          virtual void unref_to( unsigned refCount_r ) const;

        public:

          virtual ~librpmDb();

          const Pathname & root() const;

          const Pathname & dbPath() const;

          shared_ptr<RpmException> error() const;

          bool valid() const { return( ! error() ); }

          bool empty() const;

          unsigned size() const;

        public:

          void * dont_call_it() const;

          virtual std::ostream & dumpOn( std::ostream & str ) const;
      };


      //
      //        CLASS NAME : librpmDb::DbDirInfo
      class librpmDb::DbDirInfo {
        friend std::ostream & operator<<( std::ostream & str, const DbDirInfo & obj );

        private:

          Pathname _root;

          Pathname _dbPath;

          PathInfo _dbDir;

          PathInfo _dbV4;

          PathInfo _dbV3;

          PathInfo _dbV3ToV4;

        public:

          DbDirInfo( const Pathname & root_r, const Pathname & dbPath_r );

        public:

          const Pathname & root() const { return _root; }

          const Pathname & dbPath() const { return _dbPath; }

          const PathInfo & dbDir() const { return _dbDir; }

          const PathInfo & dbV4() const { return _dbV4; }

          const PathInfo & dbV3() const { return _dbV3; }

          const PathInfo & dbV3ToV4() const { return _dbV3ToV4; }

        public:

          void restat();

        public:

          bool illegalArgs() const { return _dbDir.path().empty(); }

          bool usableArgs() const { return _dbDir.isDir() || ! ( _dbDir.path().empty() || _dbDir.isExist() ); }

          bool hasDbDir() const { return _dbDir.isDir(); }

          bool hasDbV4() const { return _dbV4.isFile(); }

          bool hasDbV3() const { return _dbV3.isFile(); }

          bool hasDbV3ToV4() const { return _dbV3ToV4.isFile(); }
      };


      //
      //        CLASS NAME : librpmDb::db_const_iterator
      class librpmDb::db_const_iterator {
        db_const_iterator & operator=( const db_const_iterator & ); // NO ASSIGNMENT!
        db_const_iterator ( const db_const_iterator & );            // NO COPY!
        friend std::ostream & operator<<( std::ostream & str, const db_const_iterator & obj );
        friend class librpmDb;

        private:

          class D;
          D & _d;

        public:

          db_const_iterator( librpmDb::constPtr dbptr_r = 0 );

          ~db_const_iterator();

          shared_ptr<RpmException> dbError() const;

          void operator++();

          unsigned dbHdrNum() const;

          const RpmHeader::constPtr & operator*() const;

          const RpmHeader::constPtr & operator->() const {
            return operator*();
          }

        public:

          bool findAll();

          bool findByFile( const std::string & file_r );

          bool findByProvides( const std::string & tag_r );

          bool findByRequiredBy( const std::string & tag_r );

          bool findByConflicts( const std::string & tag_r );

          bool findByName( const std::string & name_r );

        public:

          bool findPackage( const std::string & name_r );

          bool findPackage( const std::string & name_r, const Edition & ed_r );

          bool findPackage( const Package::constPtr & which_r );
      };

    } //namespace rpm
  } //namespace target
} // namespace zypp

#endif // librpmDb_h

---