MirroredOrigin.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_REPO_ORIGIN_INCLUDED_H
#define ZYPP_REPO_ORIGIN_INCLUDED_H
 
#include <zypp-core/Url.h>
#include <zypp-core/base/PtrTypes.h>
 
#include <boost/iterator/iterator_facade.hpp>
 
#include <any>
#include <string>
#include <vector>
 
namespace zypp {

   class ZYPP_API OriginEndpoint {
   public:
 
// The header is exposed and in old SPs yast builds with c++11.
#ifdef __cpp_lib_any
     using SettingsMap = std::unordered_map<std::string, std::any>;
     OriginEndpoint(zypp::Url url, SettingsMap settings );
#endif
 
     OriginEndpoint();
     OriginEndpoint( zypp::Url url ); // combine with other constructor once we remove the C++11 constraint
 
     ~OriginEndpoint() = default;
     OriginEndpoint(const OriginEndpoint &) = default;
     OriginEndpoint(OriginEndpoint &&) = default;
     OriginEndpoint &operator=(const OriginEndpoint &) = default;
     OriginEndpoint &operator=(OriginEndpoint &&) = default;
 
     const zypp::Url &url() const;
     zypp::Url &url();
     void setUrl(const zypp::Url &newUrl);
 
     bool hasConfig( const std::string &key ) const;
 
// The header is exposed and in old SPs yast builds with c++11.
#ifdef __cpp_lib_any
     void setConfig( const std::string &key, std::any value );
     const std::any &getConfig( const std::string &key ) const;
     std::any &getConfig( const std::string &key );
     void eraseConfigValue( const std::string &key );
 
     const SettingsMap &config() const;
     SettingsMap &config();
 
     template <typename T>
     std::enable_if_t<!std::is_same_v<T, std::any>> setConfig ( const std::string &key, T &&value ) {
       setConfig( key, std::make_any<T>( std::forward<T>(value) ) );
     }
 
     template <typename T>
     std::enable_if_t<!std::is_same_v<T, std::any>, const T&> getConfig( const std::string &key ) const {
       const std::any &c = getConfig(key);
       // use the pointer overloads to get to a const reference of the containing type
       // we need to throw std::bad_any_cast manually here
       const T* ref = std::any_cast<const T>(&c);
       if ( !ref )
         throw std::bad_any_cast();
 
       return *ref;
     }
 
     template <typename T>
     std::enable_if_t<!std::is_same_v<T, std::any>, T&> getConfig( const std::string &key ) {
       std::any &c = getConfig(key);
       // use the pointer overloads to get to a const reference of the containing type
       // we need to throw std::bad_any_cast manually here
       T* ref = std::any_cast<T>(&c);
       if ( !ref )
         throw std::bad_any_cast();
 
       return *ref;
     }
#endif

     std::string scheme() const;

     bool schemeIsDownloading() const;
 
     bool isValid() const;
 
   private:
     struct Private;
     RWCOW_pointer<Private> _pimpl;
   };
 
 
   ZYPP_API std::ostream & operator<<( std::ostream & str, const OriginEndpoint & url );

   ZYPP_API bool operator<( const OriginEndpoint &lhs, const OriginEndpoint &rhs );

   ZYPP_API bool operator==( const OriginEndpoint &lhs, const OriginEndpoint &rhs );

   ZYPP_API bool operator!=( const OriginEndpoint &lhs, const OriginEndpoint &rhs );

  class ZYPP_API MirroredOrigin {
 
  public:
     template <class Parent, class Value>
     class iter : public boost::iterator_facade<
           iter<Parent, Value>
           , Value
           , boost::forward_traversal_tag
      >
     {
     public:
        iter(){}
 
        explicit iter( Parent *list, uint idx )
           : _list(list)
           , _idx(idx)
        {}
 
     private:
        friend class boost::iterator_core_access;
 
        bool equal(iter<Parent, Value> const& other) const
        {
           return ((this->_list == other._list) && (this->_idx == other._idx));
        }
 
        void increment()
        {
           if ( !_list )
              return;
           // allow _idx max to be endpointCount for end() iterator
           if ( (_idx+1) > _list->endpointCount() )
              return;
           _idx++;
        }
 
        Value& dereference() const
        {
           if ( !_list || _idx >= _list->endpointCount() )
              throw std::out_of_range( "OriginEndpoint index out of range." );
           return _list->operator [](_idx);
        }
 
        Parent *_list = nullptr;
        uint _idx = 0;
     };
     using endpoint_iterator = iter<MirroredOrigin, OriginEndpoint> ;
     using endpoint_const_iterator = iter<MirroredOrigin const, OriginEndpoint const>;
 
    MirroredOrigin( );
    MirroredOrigin( OriginEndpoint authority, std::vector<OriginEndpoint> mirrors = {} );

    void setAuthority ( OriginEndpoint newAuthority );

    const std::vector<OriginEndpoint> &authorities() const;

    const OriginEndpoint &authority() const;

    const std::vector<OriginEndpoint> &mirrors() const;

    bool isValid() const;
 
    bool addAuthority( OriginEndpoint newAuthority );
    bool addMirror( OriginEndpoint newMirror );
    void setMirrors( std::vector<OriginEndpoint> mirrors );
    void clearMirrors();

    std::string scheme() const;

    bool schemeIsDownloading() const;

    endpoint_iterator begin() {
       return endpoint_iterator( this, 0 );
    }

    endpoint_iterator end() {
       return endpoint_iterator( this, endpointCount() );
    }
 
    endpoint_const_iterator begin() const {
       return endpoint_const_iterator( this, 0 );
    }
 
    endpoint_const_iterator end() const {
       return endpoint_const_iterator( this, endpointCount() );
    }

    uint endpointCount() const;

    uint authorityCount() const;

    const OriginEndpoint &operator[]( uint index ) const { return at(index); }
    OriginEndpoint &operator[]( uint index ) { return at(index); }

    const OriginEndpoint &at( uint index ) const;
    OriginEndpoint &at( uint index );
 
  private:
    struct Private;
    RWCOW_pointer<Private> _pimpl;
  };
 
  ZYPP_API std::ostream & operator<<( std::ostream & str, const MirroredOrigin & origin );
 

  class ZYPP_API MirroredOriginSet {
 
  public:
    using iterator = std::vector<MirroredOrigin>::iterator;
    using const_iterator = std::vector<MirroredOrigin>::const_iterator;
    using size_type = size_t;
    using value_type = MirroredOrigin;
 
    MirroredOriginSet( );

    MirroredOriginSet( std::vector<OriginEndpoint> eps);
 
    MirroredOriginSet( std::vector<zypp::Url> urls );
 
    MirroredOriginSet( std::list<zypp::Url> urls );

    const MirroredOrigin &at( size_type idx ) const;

    MirroredOrigin &at( size_type idx );

    const_iterator findByUrl( const zypp::Url &url ) const;

    iterator findByUrl( const zypp::Url &url );

    template<typename InputIterator>
    void addEndpoints( InputIterator first, InputIterator last ) {
      std::for_each(first,last,[this]( OriginEndpoint ep ) { addEndpoint(std::move(ep));} );
    }

    void addAuthorityEndpoint( OriginEndpoint endpoint );

    void addEndpoint( OriginEndpoint endpoint );

    void addEndpoints(std::vector<OriginEndpoint> endpoints );

    iterator begin();

    iterator end();

    const_iterator begin() const;

    const_iterator end() const;

    size_type size() const;
 
    bool empty() const;
 
    void clear();

    bool hasFallbackUrls() const;
 
  private:
    struct Private;
    RWCOW_pointer<Private> _pimpl;
  };
 
  ZYPP_API std::ostream & operator<<( std::ostream & str, const MirroredOriginSet & origin );
 
}
#endif