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 )
    {
      return str::join( make_transform_iterator( cset.begin(), std::mem_fun_ref(&Arch::asString) ),
                        make_transform_iterator( cset.end(), std::mem_fun_ref(&Arch::asString) ) );
    }

  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;
  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_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_armv7nhl;
  extern const Arch Arch_armv7hl;
  extern const Arch Arch_armv7l;
  extern const Arch Arch_armv6l;
  extern const Arch Arch_armv5tejl;
  extern const Arch Arch_armv5tel;
  extern const Arch Arch_armv5l;
  extern const Arch Arch_armv4tl;
  extern const Arch Arch_armv4l;
  extern const Arch Arch_armv3l;

  extern const Arch Arch_sh3;

  extern const Arch Arch_sh4;
  extern const Arch Arch_sh4a;


  inline std::ostream & operator<<( std::ostream & str, const Arch & obj )
  { return str << obj.asString(); }

  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 : public std::unary_function<Arch,bool>
  {
    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<>
    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