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