128  { 
return ! ( lhs == rhs ); }
 
 
  152  #define DEF_BUILTIN(A) \ 
  153  namespace { static inline const IdString & a_##A () { static IdString _str(#A); return _str; } } \ 
  154  const Arch Arch_##A( a_##A() ) 
 
  254      using Set = std::unordered_set<CompatEntry>;
 
  255      using iterator = Set::iterator;
 
  256      using const_iterator = Set::const_iterator;
 
  259      static ArchCompatSet & instance()
 
  261        static ArchCompatSet _instance;
 
  268      const Arch::CompatEntry & assertDef( 
const std::string & archStr_r )
 
  269      { 
return *_compatSet.insert( Arch::CompatEntry( archStr_r ) ).first; }
 
  271      const Arch::CompatEntry & assertDef( IdString archStr_r )
 
  272      { 
return *_compatSet.insert( Arch::CompatEntry( archStr_r ) ).first; }
 
  274      const_iterator begin()
 const 
  275      { 
return _compatSet.begin(); }
 
  277      const_iterator end()
 const 
  278      { 
return _compatSet.end(); }
 
  282        int operator()( 
const CompatEntry & lhs,  
const CompatEntry & rhs )
 const 
  283        { 
return lhs._idBit.value() < rhs._idBit.value(); }
 
  286      std::ostream & 
dumpOn( std::ostream & str )
 const 
  288        str << 
"ArchCompatSet:";
 
  289        std::list<CompatEntry> ov( _compatSet.begin(), _compatSet.end() );
 
  290        ov.sort( DumpOnCompare() );
 
  291        for_( it, ov.begin(), ov.end() )
 
  293            str << endl << 
' ' << *it;
 
  305        _compatSet.insert( Arch::CompatEntry( a_noarch(), 0 ) );
 
  312        defCompatibleWith( a_i386(),            a_noarch() );
 
  313        defCompatibleWith( a_i486(),            a_noarch(),a_i386() );
 
  314        defCompatibleWith( a_i586(),            a_noarch(),a_i386(),a_i486() );
 
  315        defCompatibleWith( a_i686(),            a_noarch(),a_i386(),a_i486(),a_i586() );
 
  316        defCompatibleWith( a_athlon(),          a_noarch(),a_i386(),a_i486(),a_i586(),a_i686() );
 
  317        defCompatibleWith( a_x86_64(),          a_noarch(),a_i386(),a_i486(),a_i586(),a_i686(),a_athlon() );
 
  318        defCompatibleWith( a_x86_64_v2(),       a_noarch(),a_i386(),a_i486(),a_i586(),a_i686(),a_athlon(),a_x86_64() );
 
  319        defCompatibleWith( a_x86_64_v3(),       a_noarch(),a_i386(),a_i486(),a_i586(),a_i686(),a_athlon(),a_x86_64(),a_x86_64_v2() );
 
  320        defCompatibleWith( a_x86_64_v4(),       a_noarch(),a_i386(),a_i486(),a_i586(),a_i686(),a_athlon(),a_x86_64(),a_x86_64_v2(),a_x86_64_v3() );
 
  322        defCompatibleWith( a_pentium3(),        a_noarch(),a_i386(),a_i486(),a_i586(),a_i686() );
 
  323        defCompatibleWith( a_pentium4(),        a_noarch(),a_i386(),a_i486(),a_i586(),a_i686(),a_pentium3() );
 
  325        defCompatibleWith( a_ia64(),            a_noarch(),a_i386(),a_i486(),a_i586(),a_i686() );
 
  327        defCompatibleWith( a_s390(),            a_noarch() );
 
  328        defCompatibleWith( a_s390x(),           a_noarch(),a_s390() );
 
  330        defCompatibleWith( a_ppc(),             a_noarch() );
 
  331        defCompatibleWith( a_ppc64(),           a_noarch(),a_ppc() );
 
  332        defCompatibleWith( a_ppc64p7(),         a_noarch(),a_ppc(),a_ppc64() );
 
  334        defCompatibleWith( a_ppc64le(),         a_noarch() );
 
  336        defCompatibleWith( a_alpha(),           a_noarch() );
 
  337        defCompatibleWith( a_alphaev5(),        a_noarch(),a_alpha() );
 
  338        defCompatibleWith( a_alphaev56(),       a_noarch(),a_alpha(),a_alphaev5() );
 
  339        defCompatibleWith( a_alphapca56(),      a_noarch(),a_alpha(),a_alphaev5(),a_alphaev56() );
 
  340        defCompatibleWith( a_alphaev6(),        a_noarch(),a_alpha(),a_alphaev5(),a_alphaev56(),a_alphapca56() );
 
  341        defCompatibleWith( a_alphaev67(),       a_noarch(),a_alpha(),a_alphaev5(),a_alphaev56(),a_alphapca56(),a_alphaev6() );
 
  343        defCompatibleWith( a_sparc(),           a_noarch() );
 
  344        defCompatibleWith( a_sparcv8(),         a_noarch(),a_sparc() );
 
  345        defCompatibleWith( a_sparcv9(),         a_noarch(),a_sparc(),a_sparcv8() );
 
  346        defCompatibleWith( a_sparcv9v(),        a_noarch(),a_sparc(),a_sparcv8(),a_sparcv9() );
 
  348        defCompatibleWith( a_sparc64(),         a_noarch(),a_sparc(),a_sparcv8(),a_sparcv9() );
 
  349        defCompatibleWith( a_sparc64v(),        a_noarch(),a_sparc(),a_sparcv8(),a_sparcv9(),a_sparcv9v(),a_sparc64() );
 
  351        defCompatibleWith( a_armv3l(),          a_noarch() );
 
  352        defCompatibleWith( a_armv4l(),          a_noarch(),a_armv3l() );
 
  353        defCompatibleWith( a_armv4tl(),         a_noarch(),a_armv3l(),a_armv4l() );
 
  354        defCompatibleWith( a_armv5l(),          a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl() );
 
  355        defCompatibleWith( a_armv5tl(),         a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l() );
 
  356        defCompatibleWith( a_armv5tel(),        a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l(),a_armv5tl() );
 
  357        defCompatibleWith( a_armv5tejl(),       a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l(),a_armv5tl(),a_armv5tel() );
 
  358        defCompatibleWith( a_armv6l(),          a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l(),a_armv5tl(),a_armv5tel(),a_armv5tejl() );
 
  359        defCompatibleWith( a_armv7l(),          a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l(),a_armv5tl(),a_armv5tel(),a_armv5tejl(),a_armv6l() );
 
  360        defCompatibleWith( a_armv8l(),          a_noarch(),a_armv3l(),a_armv4l(),a_armv4tl(),a_armv5l(),a_armv5tl(),a_armv5tel(),a_armv5tejl(),a_armv6l(),a_armv7l() );
 
  362        defCompatibleWith( a_armv6hl(),         a_noarch() );
 
  363        defCompatibleWith( a_armv7hl(),         a_noarch(),a_armv6hl() );
 
  364        defCompatibleWith( a_armv8hl(),         a_noarch(),a_armv7hl() );
 
  365        defCompatibleWith( a_armv7hnl(),        a_noarch(),a_armv7hl(),a_armv6hl() );
 
  367        defCompatibleWith( a_armv7nhl(),        a_noarch(),a_armv7hnl(),a_armv7hl(),a_armv6hl() );
 
  369        defCompatibleWith( a_armv7thl(),   a_noarch(),a_armv7hl() );
 
  370        defCompatibleWith( a_armv7tnhl(),  a_noarch(),a_armv7hl(),a_armv7nhl(),a_armv7thl() );
 
  372        defCompatibleWith( a_aarch64(),         a_noarch() );
 
  374        defCompatibleWith( a_riscv64(),         a_noarch() );
 
  376        defCompatibleWith( a_sh3(),             a_noarch() );
 
  378        defCompatibleWith( a_sh4(),             a_noarch() );
 
  379        defCompatibleWith( a_sh4a(),            a_noarch(),a_sh4() );
 
  381        defCompatibleWith( a_m68k(),            a_noarch() );
 
  383        defCompatibleWith( a_mips(),            a_noarch() );
 
  384        defCompatibleWith( a_mipsel(),          a_noarch() );
 
  385        defCompatibleWith( a_mips64(),          a_noarch() );
 
  386        defCompatibleWith( a_mips64el(),        a_noarch() );
 
  388        defCompatibleWith( a_loong64(),         a_noarch() );
 
  406          ZYPP_THROW( Exception(
"Need more bits to encode architectures.") );
 
  415      const CompatEntry & assertCompatSetEntry( IdString archStr_r )
 
  416      { 
return *_compatSet.insert( Arch::CompatEntry( archStr_r, nextIdBit() ) ).first; }
 
  420      void defCompatibleWith( IdString targetArch_r,
 
  432        const CompatEntry & target( assertCompatSetEntry( targetArch_r ) );
 
  433        target.addCompatBit( assertCompatSetEntry( arch0_r )._idBit );
 
  434#define SETARG(N) if ( arch##N##_r.empty() ) return; target.addCompatBit( assertCompatSetEntry( arch##N##_r )._idBit ) 
  463  : 
_entry( &ArchCompatSet::instance().assertDef( a_noarch() ) )
 
 
  467  : 
_entry( &ArchCompatSet::instance().assertDef( 
IdString(id_r) ) )
 
 
  471  : 
_entry( &ArchCompatSet::instance().assertDef( idstr_r ) )
 
 
  475  : 
_entry( &ArchCompatSet::instance().assertDef( str_r ) )
 
 
  479  : 
_entry( &ArchCompatSet::instance().assertDef( cstr_r ) )
 
 
  492  { 
return _entry->_idStr; }
 
 
  500  { 
return _entry->_archStr; }
 
 
  508  { 
return _entry->isBuiltIn(); }
 
 
  516  { 
return _entry->compatibleWith( *targetArch_r.
_entry ); }
 
 
  526    if (Arch_x86_64.compatibleWith(*
this))
 
  530    if (Arch_sparc64v.compatibleWith(*
this))
 
  532      return Arch_sparc64v;
 
  534    if (Arch_sparc64.compatibleWith(*
this))
 
  538    if (Arch_ppc64.compatibleWith(*
this))
 
  542    if (Arch_s390x.compatibleWith(*
this))
 
  548    if ( cset.size() > 2 )      
 
  550      return *(++cset.rbegin());
 
 
  572    for ( ArchCompatSet::const_iterator it = ArchCompatSet::instance().begin();
 
  573          it != ArchCompatSet::instance().end(); ++it )
 
  575        if ( it->compatibleWith( *targetArch_r.
_entry ) )
 
  577            ret.insert( 
Arch(*it) );
 
 
const CompatEntry * _entry
int compare(const Arch &rhs) const
Arch comparison.
Arch()
Default ctor Arc_noarch.
static CompatSet compatSet(const Arch &targetArch_r)
Return a set of all Arch's compatibleWith a targetArch_r.
bool isBuiltIn() const
Whether this is a buitin (or known) architecture.
IdString idStr() const
String representation of Arch.
const std::string & asString() const
This is an overloaded member function, provided for convenience. It differs from the above function o...
std::set< Arch, CompareByGT< Arch > > CompatSet
Reversed arch order, best Arch first.
bool compatibleWith(const Arch &targetArch_r) const
Compatibility relation.
bool operator()(const zypp::Arch &lhs, const zypp::Arch &rhs) const
Default order for std::container based Arch::compare.
Access to the sat-pools string space.
sat::detail::IdType IdType
static const IdString Empty
Empty string.
An integral type used as BitField.
TInt value() const
Return the value.
String related utilities and Regular expression matching.
boost::noncopyable NonCopyable
Ensure derived classes cannot be copied.
std::string numstring(char n, int w=0)
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Easy-to use interface to the ZYPP dependency resolver.
std::ostream & dumpOn(std::ostream &str, const Capability &obj)
const Arch Arch_empty(IdString::Empty)
Holds an architecture ID and its compatible relation.
void addCompatBit(const CompatBits &idBit_r) const
std::ostream & operator<<(std::ostream &str, const Arch::CompatEntry &obj)
Stream output.
bool compatibleWith(const CompatEntry &targetEntry_r) const
Return whether this is compatible with targetEntry_r.
int compare(const CompatEntry &rhs) const
compare by score, then archStr.
bool operator==(const Arch::CompatEntry &lhs, const Arch::CompatEntry &rhs)
IdString::IdType id() const
bool operator!=(const Arch::CompatEntry &lhs, const Arch::CompatEntry &rhs)
bit::BitField< uint64_t > CompatBits
Bitfield for architecture IDs and compatBits relation.
CompatEntry(IdString archStr_r, CompatBits::IntT idBit_r=1)
CompatEntry(const std::string &archStr_r, CompatBits::IntT idBit_r=1)
static const unsigned size
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.
#define ZYPP_DEFINE_ID_HASHABLE(C)
Define hash function for id based classes.