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