providespec.cc

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
 
#include <iostream>
#include <utility>
#include "providespec.h"
 
using std::endl;
 
namespace zyppng
{
  class ProvideSpecBasePrivate
  {
  public:
    ProvideSpecBasePrivate() {}
    ProvideSpecBasePrivate(const ProvideSpecBasePrivate &) = default;
    ProvideSpecBasePrivate(ProvideSpecBasePrivate &&) = delete;
    ProvideSpecBasePrivate &operator=(const ProvideSpecBasePrivate &) = delete;
    ProvideSpecBasePrivate &operator=(ProvideSpecBasePrivate &&) = delete;
    virtual ~ProvideSpecBasePrivate() {}
    HeaderValueMap _customHeaders;
  };
 
 
  class ProvideMediaSpec::Impl : public ProvideSpecBasePrivate
  {
  public:
    Impl()
    {}
 
    Impl( std::string &&label, zypp::Pathname &&vPath, unsigned medianr )
      : _label(std::move( label ))
      , _medianr( medianr )
      , _verifyDataPath(std::move(vPath))
    {}
 
    std::string _label;
    unsigned _medianr = 0U;
    zypp::Pathname _verifyDataPath;
 
  public:
    static zypp::shared_ptr<Impl> nullimpl()
    { static zypp::shared_ptr<Impl> _nullimpl( new Impl ); return _nullimpl; }
 
  private:
    friend ProvideMediaSpec::Impl * zypp::rwcowClone<ProvideMediaSpec::Impl>( const ProvideMediaSpec::Impl * rhs );
    Impl * clone() const { return new Impl( *this ); }
  };
 
  class ProvideFileSpec::Impl : public ProvideSpecBasePrivate
  {
  public:
    Impl()
    {}
 
    zypp::Pathname _destFilenameHint;
    zypp::Pathname _mediaSpecFile;
    bool _checkExistsOnly = false;
 
    bool _optional = false;
    zypp::ByteCount _downloadSize;
    zypp::CheckSum  _checksum;
 
    zypp::ByteCount _openSize;
    zypp::CheckSum  _openChecksum;
 
    zypp::ByteCount _headerSize;
    zypp::CheckSum  _headerChecksum;
 
    zypp::Pathname  _deltafile;
 
    bool _mirrorsAllowed = true;
 
  public:
    static zypp::shared_ptr<Impl> nullimpl()
    { static zypp::shared_ptr<Impl> _nullimpl( new Impl ); return _nullimpl; }
 
  private:
    friend ProvideFileSpec::Impl * zypp::rwcowClone<ProvideFileSpec::Impl>( const ProvideFileSpec::Impl * rhs );
    Impl * clone() const { return new Impl( *this ); }
  };
 
 
  ProvideMediaSpec::ProvideMediaSpec( std::string label, zypp::filesystem::Pathname verifyData, unsigned medianr )
    :  _pimpl( new Impl( std::move(label), std::move(verifyData), medianr ) )
  {
 
  }
 
  const std::string &ProvideMediaSpec::label() const
  { return _pimpl->_label; }
 
  ProvideMediaSpec &ProvideMediaSpec::setLabel(const std::string &label)
  {
    _pimpl->_label = label;
    return *this;
  }
 
  unsigned ProvideMediaSpec::medianr() const
  { return _pimpl->_medianr; }
 
  ProvideMediaSpec &ProvideMediaSpec::setMedianr(unsigned medianr)
  {
    _pimpl->_medianr = medianr;
    return *this;
  }
 
  zypp::filesystem::Pathname ProvideMediaSpec::mediaFile() const
  { return _pimpl->_verifyDataPath; }
 
  ProvideMediaSpec &ProvideMediaSpec::setMediaFile(const zypp::filesystem::Pathname &pName)
  {
    _pimpl->_verifyDataPath = pName;
    return *this;
  }
 
  HeaderValueMap &ProvideMediaSpec::customHeaders()
  { return _pimpl->_customHeaders; }
 
  const HeaderValueMap &ProvideMediaSpec::customHeaders() const
  { return _pimpl->_customHeaders; }
 
  ProvideMediaSpec &ProvideMediaSpec::setCustomHeaderValue(const std::string &key, const HeaderValueMap::Value &val)
  {
    _pimpl->_customHeaders.set( key,val );
    return *this;
  }
 
  ProvideMediaSpec &ProvideMediaSpec::addCustomHeaderValue(const std::string &key, const HeaderValueMap::Value &val)
  {
    _pimpl->_customHeaders.add( key,val );
    return *this;
  }
 
  zypp::TriBool ProvideMediaSpec::isSameMedium( const ProvideMediaSpec &other ) const
  {
    // first check if we have the same media data
    if ( _pimpl->_verifyDataPath != other._pimpl->_verifyDataPath )
      return false;
 
    // if the verify file is not empty check the medianr
    if ( !_pimpl->_verifyDataPath.empty() ) {
      return _pimpl->_medianr == other._pimpl->_medianr;
    }
 
    // can't tell without the URL
    return zypp::indeterminate;
  }
 
  bool ProvideMediaSpec::isSameMedium( const zypp::MirroredOrigin &originA, const ProvideMediaSpec &specA, const zypp::MirroredOrigin &originB, const ProvideMediaSpec &specB )
  {
    const auto check = specA.isSameMedium(specB);
    if ( !zypp::indeterminate (check) )
      return (bool)check;
 
    // if the endpoints intersect we assume same medium
    const auto &intersects = [](  const zypp::MirroredOrigin &l1, const zypp::MirroredOrigin &l2 ){
      bool intersect = false;
      for ( const auto &u: l1 ) {
        intersect = ( std::find( l2.begin (), l2.end(), u ) != l2.end() );
        if ( intersect )
          break;
      }
      return intersect;
    };
 
    return intersects( originA, originB );
  }

  inline std::ostream & operator<<( std::ostream & str, const ProvideFileSpec::Impl & obj )
  {
    return str << "{" << obj._destFilenameHint << "{" << obj._downloadSize << "|" << obj._checksum << "|" << obj._deltafile <<  "}" <<  "}";
  }

  inline std::ostream & dumpOn( std::ostream & str, const ProvideFileSpec::Impl & obj )
  { return str << obj; }
 
 
  ProvideFileSpec::ProvideFileSpec()
  : _pimpl( new Impl() )
  {}
 
  ProvideFileSpec::ProvideFileSpec( const zypp::OnMediaLocation &loc )
  : _pimpl( new Impl() )
  {
    setDownloadSize( loc.downloadSize() );
    setOptional( loc.optional() );
    setChecksum( loc.checksum() );
    setOpenSize( loc.openSize() );
    setOpenChecksum( loc.openChecksum() );
    setHeaderSize( loc.headerSize() );
    setHeaderChecksum( loc.headerChecksum() );
    setDeltafile( loc.deltafile() );
  }
 
  ProvideFileSpec::~ProvideFileSpec()
  {}
 
  const zypp::filesystem::Pathname &ProvideFileSpec::destFilenameHint() const
  { return _pimpl->_destFilenameHint; }
 
  ProvideFileSpec &ProvideFileSpec::setDestFilenameHint(const zypp::filesystem::Pathname &filename)
  { _pimpl->_destFilenameHint = filename; return *this; }
 
  bool ProvideFileSpec::checkExistsOnly() const
  { return _pimpl->_checkExistsOnly; }
 
  ProvideFileSpec &ProvideFileSpec::setCheckExistsOnly(const bool set)
  { _pimpl->_checkExistsOnly = set; return *this; }
 
  bool ProvideFileSpec::optional() const
  { return _pimpl->_optional; }
 
  ProvideFileSpec & ProvideFileSpec::setOptional( bool val_r )
  { _pimpl->_optional = (val_r); return *this; }
 
  const zypp::ByteCount & ProvideFileSpec::downloadSize() const
  { return _pimpl->_downloadSize; }
 
  ProvideFileSpec & ProvideFileSpec::setDownloadSize( const zypp::ByteCount &val_r )
  { _pimpl->_downloadSize = (val_r); return *this; }
 
  const zypp::CheckSum & ProvideFileSpec::checksum() const
  { return _pimpl->_checksum; }
 
  ProvideFileSpec & ProvideFileSpec::setChecksum( const zypp::CheckSum &val_r )
  { _pimpl->_checksum = (val_r); return *this; }
 
  const zypp::ByteCount & ProvideFileSpec::openSize() const
  { return _pimpl->_openSize; }
 
  ProvideFileSpec & ProvideFileSpec::setOpenSize( const zypp::ByteCount &val_r )
  { _pimpl->_openSize = (val_r); return *this; }
 
  const zypp::CheckSum & ProvideFileSpec::openChecksum() const
  { return _pimpl->_openChecksum; }
 
  ProvideFileSpec & ProvideFileSpec::setOpenChecksum( const zypp::CheckSum &val_r )
  { _pimpl->_openChecksum = (val_r); return *this; }
 
  const zypp::ByteCount & ProvideFileSpec::headerSize() const
  { return _pimpl->_headerSize; }
 
  ProvideFileSpec & ProvideFileSpec::setHeaderSize( const zypp::ByteCount &val_r )
  { _pimpl->_headerSize = (val_r); return *this; }
 
  const zypp::CheckSum & ProvideFileSpec::headerChecksum() const
  { return _pimpl->_headerChecksum; }
 
  ProvideFileSpec & ProvideFileSpec::setHeaderChecksum( const zypp::CheckSum &val_r )
  { _pimpl->_headerChecksum = (val_r); return *this; }
 
  const zypp::Pathname &ProvideFileSpec::deltafile() const
  { return _pimpl->_deltafile; }
 
  ProvideFileSpec &ProvideFileSpec::setDeltafile( const zypp::Pathname &path )
  { _pimpl->_deltafile = (path); return *this; }
 
  bool ProvideFileSpec::mirrorsAllowed() const
  { return _pimpl->_mirrorsAllowed; }
 
  ProvideFileSpec &ProvideFileSpec::setMirrorsAllowed(bool set)
  { _pimpl->_mirrorsAllowed = std::move(set); return *this; }
 
  HeaderValueMap &ProvideFileSpec::customHeaders()
  { return _pimpl->_customHeaders; }
 
  const HeaderValueMap &ProvideFileSpec::customHeaders() const
  { return _pimpl->_customHeaders; }
 
  ProvideFileSpec &ProvideFileSpec::setCustomHeaderValue(const std::string &key, const HeaderValueMap::Value &val)
  {
    _pimpl->_customHeaders.set( key,val );
    return *this;
  }
 
  ProvideFileSpec &ProvideFileSpec::addCustomHeaderValue(const std::string &key, const HeaderValueMap::Value &val)
  {
    _pimpl->_customHeaders.add( key,val );
    return *this;
  }
 
  zypp::OnMediaLocation ProvideFileSpec::asOnMediaLocation( const zypp::Pathname &path, unsigned int mediaNr ) const
  {
    return zypp::OnMediaLocation( path, mediaNr )
        .setDownloadSize( downloadSize() )
        .setOptional( optional() )
        .setChecksum( checksum() )
        .setOpenSize( openSize() )
        .setOpenChecksum( openChecksum() )
        .setHeaderSize( headerSize() )
        .setHeaderChecksum( headerChecksum() )
        .setDeltafile( deltafile() )
        .setMirrorsAllowed( mirrorsAllowed () );
  }
 
  std::ostream & operator<<( std::ostream & str, const ProvideFileSpec & obj )
  { return str << *obj._pimpl; }
 
  std::ostream & dumpOn( std::ostream & str, const ProvideFileSpec & obj )
  { return dumpOn( str, *obj._pimpl ); }
 
} // namespace zypp