CapabilityImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CAPABILITY_CAPABILITYIMPL_H
#define ZYPP_CAPABILITY_CAPABILITYIMPL_H

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"

#include "zypp/Capability.h"
#include "zypp/Resolvable.h"
#include "zypp/CapMatch.h"

namespace zypp
{ 

  namespace capability
  { 
    DEFINE_PTR_TYPE(CapabilityImpl)


    
    //
    //  CLASS NAME : CapabilityImpl
    //
    class CapabilityImpl : public base::ReferenceCounted, private base::NonCopyable
    {
    public:
      typedef CapabilityImpl           Self;
      typedef CapabilityImpl_Ptr       Ptr;
      typedef CapabilityImpl_constPtr  constPtr;

      typedef CapabilityTraits::KindType  Kind;

    public:
      virtual const Kind & kind() const = 0;

      const Resolvable::Kind & refers() const
      { return _refers; }

      virtual bool relevant() const
      { return true; }

      virtual CapMatch matches( const constPtr & rhs ) const = 0;

      virtual std::string encode() const = 0;

      virtual std::string asString() const
      { return encode(); }

      virtual std::string index() const
      { return encode(); }

    public:
      struct SplitInfo
      {
        std::string name;
        std::string path;
      };
      static SplitInfo getSplitInfo( const Capability & cap );

      static constPtr backdoor( const Capability & cap )
      { return cap._pimpl.getPtr(); }

    protected:
      CapabilityImpl( const Resolvable::Kind & refers_r );

    protected: // Match helpers
      bool sameKind( const constPtr & rhs ) const
      { return kind() == rhs->kind(); }

      bool sameRefers( const constPtr & rhs ) const
      { return _refers == rhs->_refers; }

      bool sameKindAndRefers( const constPtr & rhs ) const
      { return sameKind( rhs ) && sameRefers( rhs ); }

    protected:
      virtual std::ostream & dumpOn( std::ostream & str ) const;

    private:
      Resolvable::Kind _refers;

    private:
      friend struct CapImplOrder;
      virtual bool capImplOrderLess( const constPtr & rhs ) const;
    };

    bool isEditionSpec( Rel op_r, const Edition & edition_r );

    bool isFileSpec( const std::string & name_r );

    bool isInterestingFileSpec( const std::string & name_r );

    bool isSplitSpec( const std::string & name_r );

    bool isHalSpec( const std::string & name_r );

    bool isModaliasSpec( const std::string & name_r );

    bool isFilesystemSpec( const std::string & name_r );

    CapabilityImpl::Ptr buildFile( const Resolvable::Kind & refers_r,
                                   const std::string & name_r );

    CapabilityImpl::Ptr buildNamed( const Resolvable::Kind & refers_r,
                                    const std::string & name_r );

    CapabilityImpl::Ptr buildVersioned( const Resolvable::Kind & refers_r,
                                        const std::string & name_r,
                                        Rel op_r,
                                        const Edition & edition_r );

    CapabilityImpl::Ptr buildHal( const Resolvable::Kind & refers_r,
                                  const std::string & name_r,
                                  Rel op_r = Rel::ANY,
                                  const std::string & value_r = std::string() );

    CapabilityImpl::Ptr buildModalias( const Resolvable::Kind & refers_r,
                                       const std::string & name_r,
                                       Rel op_r = Rel::ANY,
                                       const std::string & value_r = std::string() );

    CapabilityImpl::Ptr buildFilesystem( const Resolvable::Kind & refers_r,
                                         const std::string & name_r );


    CapabilityImpl::Ptr parse( const Resolvable::Kind & refers_r,
                               const std::string & strval_r );

    CapabilityImpl::Ptr parse( const Resolvable::Kind & refers_r,
                               const std::string & name_r,
                               const std::string & op_r,
                               const std::string & edition_r );

    CapabilityImpl::Ptr parse( const Resolvable::Kind & refers_r,
                               const std::string & name_r,
                               Rel op_r,
                               const Edition & edition_r );

    template<class _Cap>
      inline bool isKind( const CapabilityImpl::constPtr & cap )
      { return cap && cap->kind() == CapTraits<_Cap>::kind; }

    template<class _Cap>
      inline intrusive_ptr<const _Cap> asKind( const CapabilityImpl::constPtr & cap )
      { return dynamic_pointer_cast<const _Cap>(cap); }

    template<class _Cap>
      inline intrusive_ptr<_Cap> asKind( const CapabilityImpl::Ptr & cap )
      { return dynamic_pointer_cast<_Cap>(cap); }

    template<class _Cap>
      inline intrusive_ptr<const _Cap> asKind( const Capability & cap )
      { return dynamic_pointer_cast<const _Cap>( CapabilityImpl::backdoor(cap) ); }


    struct CapImplOrder : public std::binary_function<CapabilityImpl::constPtr, CapabilityImpl::constPtr, bool>
    {
      bool operator()( const CapabilityImpl::constPtr & lhs,
                       const CapabilityImpl::constPtr & rhs ) const
      {
        if ( lhs->refers() != rhs->refers() )
          return lhs->refers() < rhs->refers();
        if ( lhs->kind() != rhs->kind() )
          return lhs->kind() < rhs->kind();
        return lhs->capImplOrderLess( rhs );
      }
    };

    typedef std::set<CapabilityImpl::Ptr> CapabilityImplPtrSet;

  } // namespace capability
} // namespace zypp
#endif // ZYPP_CAPABILITY_CAPABILITYIMPL_H

---