Arch.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_ARCH_H
#define ZYPP_ARCH_H
 
#include <iosfwd>
#include <functional>
#include <set>
#include <string>
 
#include <zypp/base/String.h>
#include <zypp/base/Iterator.h>
 
#include <zypp/IdStringType.h>
#include <zypp/RelCompare.h>
 
namespace zypp
{ 
 
  //
  //    CLASS NAME : Arch
  //
  class Arch
  {
  public:
    Arch();
 
    explicit Arch( IdString::IdType id_r );
    explicit Arch( const IdString & idstr_r );
    explicit Arch( const std::string & str_r );
    explicit Arch( const char * cstr_r );
 
  public:
    IdString idStr() const;
    const std::string & asString() const;
    const char * c_str() const
    { return asString().c_str(); }
 
    bool empty() const
    { return asString().empty(); }
 
    unsigned size() const
    { return asString().size(); }
 
    IdString::IdType id() const
    { return idStr().id(); }
 
  public:
    bool isBuiltIn() const;
 
  public:
    bool compatibleWith( const Arch & targetArch_r ) const;
 
    Arch baseArch() const;
 
    static Arch baseArch( const Arch & targetArch_r )
    { return targetArch_r.baseArch(); }
 
    int compare( const Arch & rhs ) const;
 
    static int compare( const Arch & lhs, const Arch & rhs )
    { return lhs.compare( rhs ); }
 
  public:
    typedef std::set<Arch,CompareByGT<Arch> > CompatSet;
 
    static CompatSet compatSet( const Arch & targetArch_r );
 
    static std::string asString( const CompatSet & cset )
    {
      // Explicitely select the overload we want, clang seems to choke if there is a static overload for the
      // member function we want to capture in std::mem_fn (fixes GH-478)
      const std::string & (Arch::*memfn)( ) const = &Arch::asString;
      return str::join( make_transform_iterator( cset.begin(), std::mem_fn( memfn ) ),
                        make_transform_iterator( cset.end(), std::mem_fn( memfn ) ) );
    }
 
  public:
    struct CompatEntry;
  private:
    Arch( const CompatEntry & );
    const CompatEntry * _entry;
  };
 
  extern const Arch Arch_empty;
 
  extern const Arch Arch_noarch;
 
  extern const Arch Arch_pentium4;
  extern const Arch Arch_pentium3;
 
  extern const Arch Arch_x86_64_v4;
  extern const Arch Arch_x86_64_v3;
  extern const Arch Arch_x86_64_v2;
  extern const Arch Arch_x86_64;
  extern const Arch Arch_athlon;
  extern const Arch Arch_i686;
  extern const Arch Arch_i586;
  extern const Arch Arch_i486;
  extern const Arch Arch_i386;
 
  extern const Arch Arch_s390x;
  extern const Arch Arch_s390;
 
  extern const Arch Arch_ppc64le;
 
  extern const Arch Arch_ppc64p7;
  extern const Arch Arch_ppc64;
  extern const Arch Arch_ppc;
 
  extern const Arch Arch_ia64;
 
  extern const Arch Arch_alphaev67;
  extern const Arch Arch_alphaev6;
  extern const Arch Arch_alphapca56;
  extern const Arch Arch_alphaev56;
  extern const Arch Arch_alphaev5;
  extern const Arch Arch_alpha;
 
  extern const Arch Arch_sparc64v;
  extern const Arch Arch_sparc64;
  extern const Arch Arch_sparcv9v;
  extern const Arch Arch_sparcv9;
  extern const Arch Arch_sparcv8;
  extern const Arch Arch_sparc;
 
  extern const Arch Arch_aarch64;
 
  extern const Arch Arch_armv7tnhl;     /* exists? */
  extern const Arch Arch_armv7thl;      /* exists? */
 
  extern const Arch Arch_armv7hnl,      /* legacy: */Arch_armv7nhl;
  extern const Arch Arch_armv7hl;
  extern const Arch Arch_armv6hl;
 
  extern const Arch Arch_armv8hl;
  extern const Arch Arch_armv8l;
  extern const Arch Arch_armv7l;
  extern const Arch Arch_armv6l;
  extern const Arch Arch_armv5tejl;
  extern const Arch Arch_armv5tel;
  extern const Arch Arch_armv5tl;
  extern const Arch Arch_armv5l;
  extern const Arch Arch_armv4tl;
  extern const Arch Arch_armv4l;
  extern const Arch Arch_armv3l;
 
  extern const Arch Arch_riscv64;
 
  extern const Arch Arch_sh3;
 
  extern const Arch Arch_sh4;
  extern const Arch Arch_sh4a;
 
  extern const Arch Arch_m68k;
 
  extern const Arch Arch_mips;
  extern const Arch Arch_mipsel;
  extern const Arch Arch_mips64;
  extern const Arch Arch_mips64el;
 
 
  inline std::ostream & operator<<( std::ostream & str, const Arch & obj )
  { return str << obj.asString(); }
 
  inline std::ostream & dumpAsXmlOn( std::ostream & str, const Arch & obj )
  { return str << "<arch>" << obj <<  "</arch>"; }
 
  inline bool operator==( const Arch & lhs, const Arch & rhs )
  { return lhs.asString() == rhs.asString(); }
 
  inline bool operator==( const Arch & lhs, const std::string & rhs )
  { return lhs.asString() == rhs; }
 
  inline bool operator==( const std::string & lhs, const Arch & rhs )
  { return lhs == rhs.asString(); }
 
  inline bool operator!=( const Arch & lhs, const Arch & rhs )
  { return !( lhs == rhs ); }
 
  inline bool operator!=( const Arch & lhs, const std::string & rhs )
  { return !( lhs == rhs ); }
 
  inline bool operator!=( const std::string & lhs, const Arch & rhs )
  { return !( lhs == rhs ); }
 
 
  struct ArchCompatibleWith
  {
    Arch _targetArch;
    ArchCompatibleWith( const Arch & targetArch_r )
    : _targetArch( targetArch_r )
    {}
    bool operator()( const Arch & rhs ) const
    { return rhs.compatibleWith( _targetArch ); }
  };
 
} // namespace zypp
 
namespace std
{ 
  template<>
#ifdef __clang__
constexpr
#endif
    inline bool less<zypp::Arch>::operator()( const zypp::Arch & lhs, const zypp::Arch & rhs ) const
    { return lhs.compare( rhs ) < 0; }
} // namespace zypp
#endif // ZYPP_ARCH_H