CapabilityImpl.h

Go to the documentation of this file.
00001 /*---------------------------------------------------------------------\
00002 |                          ____ _   __ __ ___                          |
00003 |                         |__  / \ / / . \ . \                         |
00004 |                           / / \ V /|  _/  _/                         |
00005 |                          / /__ | | | | | |                           |
00006 |                         /_____||_| |_| |_|                           |
00007 |                                                                      |
00008 \---------------------------------------------------------------------*/
00012 #ifndef ZYPP_CAPABILITY_CAPABILITYIMPL_H
00013 #define ZYPP_CAPABILITY_CAPABILITYIMPL_H
00014 
00015 #include "zypp/base/ReferenceCounted.h"
00016 #include "zypp/base/NonCopyable.h"
00017 
00018 #include "zypp/Capability.h"
00019 #include "zypp/Resolvable.h"
00020 #include "zypp/CapMatch.h"
00021 
00023 namespace zypp
00024 { 
00025 
00026   namespace capability
00027   { 
00028     DEFINE_PTR_TYPE(CapabilityImpl)
00029 
00030     
00031     //
00032     //  CLASS NAME : CapabilityImpl
00033     //
00036     class CapabilityImpl : public base::ReferenceCounted, private base::NonCopyable
00037     {
00038     public:
00039       typedef CapabilityImpl           Self;
00040       typedef CapabilityImpl_Ptr       Ptr;
00041       typedef CapabilityImpl_constPtr  constPtr;
00042 
00043       typedef CapabilityTraits::KindType  Kind;
00044 
00045     public:
00047       virtual const Kind & kind() const = 0;
00048 
00050       const Resolvable::Kind & refers() const
00051       { return _refers; }
00052 
00054       virtual bool relevant() const
00055       { return true; }
00056 
00060       virtual CapMatch matches( const constPtr & rhs ) const = 0;
00061 
00066       virtual std::string encode() const = 0;
00067 
00072       virtual std::string asString() const
00073       { return encode(); }
00074 
00080       virtual std::string index() const
00081       { return encode(); }
00083       virtual Rel op() const
00084       { return Rel::NONE; }
00086       virtual Edition edition() const
00087       { return Edition::noedition; }
00088 
00089     public:
00091       struct SplitInfo
00092       {
00093         std::string name;
00094         std::string path;
00095       };
00097       static SplitInfo getSplitInfo( const Capability & cap );
00098 
00100       static constPtr backdoor( const Capability & cap )
00101       { return cap._pimpl.getPtr(); }
00102 
00103     protected:
00105       CapabilityImpl( const Resolvable::Kind & refers_r );
00106 
00107     protected: // Match helpers
00108       bool sameKind( const constPtr & rhs ) const
00109       { return kind() == rhs->kind(); }
00110 
00111       bool sameRefers( const constPtr & rhs ) const
00112       { return _refers == rhs->_refers; }
00113 
00114       bool sameKindAndRefers( const constPtr & rhs ) const
00115       { return sameKind( rhs ) && sameRefers( rhs ); }
00116 
00117     protected:
00119       virtual std::ostream & dumpOn( std::ostream & str ) const;
00120 
00121     private:
00123       Resolvable::Kind _refers;
00124 
00125     private:
00126       friend struct CapImplOrder;
00134       virtual bool capImplOrderLess( const constPtr & rhs ) const;
00135     };
00137 
00143     template<class _Cap>
00144       inline bool isKind( const CapabilityImpl::constPtr & cap )
00145       { return cap && cap->kind() == CapTraits<_Cap>::kind; }
00146 
00148     template<class _Cap>
00149       inline intrusive_ptr<const _Cap> asKind( const CapabilityImpl::constPtr & cap )
00150       { return dynamic_pointer_cast<const _Cap>(cap); }
00151 
00153     template<class _Cap>
00154       inline intrusive_ptr<const _Cap> asKind( const Capability & cap )
00155       { return dynamic_pointer_cast<const _Cap>( CapabilityImpl::backdoor(cap) ); }
00156 
00158 
00160     struct CapImplOrder : public std::binary_function<CapabilityImpl::constPtr, CapabilityImpl::constPtr, bool>
00161     {
00163       bool operator()( const CapabilityImpl::constPtr & lhs,
00164                        const CapabilityImpl::constPtr & rhs ) const
00165       {
00166         if ( lhs->refers() != rhs->refers() )
00167           return lhs->refers() < rhs->refers();
00168         if ( lhs->kind() != rhs->kind() )
00169           return lhs->kind() < rhs->kind();
00170         return lhs->capImplOrderLess( rhs );
00171       }
00172     };
00173 
00175   } // namespace capability
00178 } // namespace zypp
00180 #endif // ZYPP_CAPABILITY_CAPABILITYIMPL_H

Generated on Thu Jul 6 00:07:20 2006 for zypp by  doxygen 1.4.6