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-core/base/String.h>
#include <zypp-core/base/Iterator.h>

#include <zypp/IdStringType.h>
#include <zypp/RelCompare.h>

namespace zypp
{ 

  //
  //    CLASS NAME : Arch
  //
  class ZYPP_API 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 );

    static Arch detectSystemArchitecture();

  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:
    using CompatSet = std::set<Arch, CompareByGT<Arch>>;

    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 ZYPP_API;

  extern const Arch Arch_noarch ZYPP_API;

  extern const Arch Arch_pentium4 ZYPP_API;
  extern const Arch Arch_pentium3 ZYPP_API;

  extern const Arch Arch_x86_64_v4 ZYPP_API;
  extern const Arch Arch_x86_64_v3 ZYPP_API;
  extern const Arch Arch_x86_64_v2 ZYPP_API;
  extern const Arch Arch_x86_64 ZYPP_API;
  extern const Arch Arch_athlon ZYPP_API;
  extern const Arch Arch_i686 ZYPP_API;
  extern const Arch Arch_i586 ZYPP_API;
  extern const Arch Arch_i486 ZYPP_API;
  extern const Arch Arch_i386 ZYPP_API;

  extern const Arch Arch_s390x ZYPP_API;
  extern const Arch Arch_s390 ZYPP_API;

  extern const Arch Arch_ppc64le ZYPP_API;

  extern const Arch Arch_ppc64p7 ZYPP_API;
  extern const Arch Arch_ppc64 ZYPP_API;
  extern const Arch Arch_ppc ZYPP_API;

  extern const Arch Arch_ia64 ZYPP_API;

  extern const Arch Arch_alphaev67 ZYPP_API;
  extern const Arch Arch_alphaev6 ZYPP_API;
  extern const Arch Arch_alphapca56 ZYPP_API;
  extern const Arch Arch_alphaev56 ZYPP_API;
  extern const Arch Arch_alphaev5 ZYPP_API;
  extern const Arch Arch_alpha ZYPP_API;

  extern const Arch Arch_sparc64v ZYPP_API;
  extern const Arch Arch_sparc64 ZYPP_API;
  extern const Arch Arch_sparcv9v ZYPP_API;
  extern const Arch Arch_sparcv9 ZYPP_API;
  extern const Arch Arch_sparcv8 ZYPP_API;
  extern const Arch Arch_sparc ZYPP_API;

  extern const Arch Arch_aarch64 ZYPP_API;

  extern const Arch Arch_armv7tnh ZYPP_API;     /* exists? */
  extern const Arch Arch_armv7thl ZYPP_API;     /* exists? */

  extern const Arch Arch_armv7hnl ZYPP_API,     /* legacy: */Arch_armv7nhl ZYPP_API;
  extern const Arch Arch_armv7hl ZYPP_API;
  extern const Arch Arch_armv6hl ZYPP_API;

  extern const Arch Arch_armv8hl ZYPP_API;
  extern const Arch Arch_armv8l ZYPP_API;
  extern const Arch Arch_armv7l ZYPP_API;
  extern const Arch Arch_armv6l ZYPP_API;
  extern const Arch Arch_armv5tejl ZYPP_API;
  extern const Arch Arch_armv5tel ZYPP_API;
  extern const Arch Arch_armv5tl ZYPP_API;
  extern const Arch Arch_armv5l ZYPP_API;
  extern const Arch Arch_armv4tl ZYPP_API;
  extern const Arch Arch_armv4l ZYPP_API;
  extern const Arch Arch_armv3l ZYPP_API;

  extern const Arch Arch_riscv64 ZYPP_API;

  extern const Arch Arch_sh3 ZYPP_API;

  extern const Arch Arch_sh4 ZYPP_API;
  extern const Arch Arch_sh4a ZYPP_API;

  extern const Arch Arch_m68k ZYPP_API;

  extern const Arch Arch_mips ZYPP_API;
  extern const Arch Arch_mipsel ZYPP_API;
  extern const Arch Arch_mips64 ZYPP_API;
  extern const Arch Arch_mips64el ZYPP_API;

  extern const Arch Arch_loong64 ZYPP_API;


  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