LCOV - lcov.info - ept/core/apt/package.h

LTP GCOV extension - code coverage report
Current view: | directory - ept/core/apt - package.h
Test: | lcov.info
Date: | 2008-08-14 |  | Instrumented lines: | 33
Code covered: | 93.9 % |  | Executed lines: | 31

           1                 : // -*- C++ -*-
           2                 :
           3                 : #ifndef EPT_APT_PACKAGE_H
           4                 : #define EPT_APT_PACKAGE_H
           5                 :
           6                 : namespace ept {
           7                 : namespace core {
           8                 : namespace package {
           9                 :
          10                 : struct Setup {
          11                 :     typedef ept::Token Token;
          12                 :     typedef package::Internal Internal;
          13                 :     typedef package::PropertyId PropertyId;
          14                 :     typedef package::InternalList InternalList;
          15                 : };
          16                 :
          17                 : template<> struct PropertyType< Name > { typedef std::string T; };
          18                 : template<> struct PropertyType< Versions > { typedef VersionList T; };
          19                 : template<> struct PropertyType< AnyVersion > { typedef Token T; };
          20                 : template<> struct PropertyType< State > { typedef PackageState T; };
          21                 : template<> struct PropertyType< CandidateVersion > { typedef Token T; };
          22                 : template<> struct PropertyType< InstalledVersion > { typedef Token T; };
          23                 :
          24                 : struct Source : core::Source< Source, Setup, PropertyType >
          25              15 : {
          26                 :     AptDatabase &m_db;
          27                 :
          28              15 :     Source( AptDatabase &db ) : m_db( db ) {}
          29                 :
          30               3 :     InternalList listInternal() {
          31               3 :         return InternalList( m_db.cache().PkgBegin() );
          32                 :     }
          33                 :
          34              17 :     Internal lookupToken( Token t ) {
          35              17 :         return m_db.lookupPackage( t );
          36                 :     }
          37                 :
          38            3777 :     Token getToken( Internal i ) {
          39            3777 :         Token t;
          40            3777 :         t._id = i.Name();
          41               0 :         return t;
          42                 :     }
          43                 :
          44               8 :     bool exists( Token t ) {
          45               8 :         if ( t.hasVersion() )
          46               0 :             return !m_db.lookupVersion( t ).end();
          47                 :         else
          48               8 :             return !lookupToken( t ).end();
          49                 :     }
          50                 :
          51                 :     Token versionToken( pkgCache::VerIterator vi ) {
          52                 :         if ( vi.end() )
          53                 :             return Token();
          54                 :         return Token( std::string( vi.ParentPkg().Name() ) + "_" + vi.VerStr() );
          55                 :     }
          56                 :
          57                 :     template< PropertyId p >
          58                 :     typename PropertyType< p >::T getInternal( Internal );
          59                 :
          60                 :     template< typename List >
          61               1 :     void revertState( List l ) {
          62            3779 :         while ( !l.empty() ) {
          63            3777 :             PackageState s = getInternal< State >( l.head() );
          64            3777 :             if ( !s.keep() || s.purge() ) {
          65               2 :                 pkgDepCache::StateCache &S = db().state()[ l.head() ];
          66               2 :                 db().state().MarkKeep( l.head(), false, false );
          67               2 :                 S.iFlags &= ~pkgDepCache::Purge;
          68               2 :                 S.iFlags &= ~pkgDepCache::ReInstall;
          69                 :             }
          70            3777 :             l = l.tail();
          71                 :         }
          72               1 :     }
          73                 :
          74               1 :     void revertStates() {
          75               1 :         pkgDepCache::ActionGroup group( db().state() );
          76               1 :         revertState( listInternal() );
          77               1 :     }
          78                 :
          79                 :     typedef ComposedList< State > ChangeList;
          80                 :
          81                 :     static bool isChanged( Token t, PackageState s );
          82                 :     static bool isUpgradable( Token t, PackageState s );
          83                 :
          84                 :     PropertyFilter< State, __typeof( &isChanged ) >::T changedList() {
          85                 :         return propertyFilter< State >( isChanged );
          86                 :     }
          87                 :
          88                 :     PropertyFilter< State, __typeof( &isUpgradable ) >::T upgradableList() {
          89                 :         return propertyFilter< State >( isUpgradable );
          90                 :     }
          91                 :
          92               9 :     AptDatabase &db() { return m_db; }
          93                 : };
          94                 :
          95            3778 : template<> inline std::string Source::getInternal< Name >( Internal i ) {
          96            3778 :     return i.Name();
          97                 : }
          98                 :
          99            3783 : template<> inline PackageState Source::getInternal< State >( Internal i ) {
         100            3783 :     return m_db.packageState( i );
         101                 : }
         102                 :
         103                 : template<> inline Token Source::getInternal< CandidateVersion >( Internal i ) {
         104                 :     return versionToken( m_db.candidateVersion( i ) );
         105                 : }
         106                 :
         107                 : template<> inline Token Source::getInternal< AnyVersion >( Internal i ) {
         108                 :     return versionToken( m_db.candidateVersion( i ) );
         109                 : }
         110                 :
         111                 : template<> inline Token Source::getInternal< InstalledVersion >( Internal i ) {
         112                 :     return versionToken( m_db.installedVersion( i ) );
         113                 : }
         114                 :
         115                 : inline bool Source::isChanged( Token, PackageState s ) {
         116                 :     return s.modify();
         117                 : }
         118                 :
         119                 : inline bool Source::isUpgradable( Token, PackageState s ) {
         120                 :     return s.upgradable();
         121                 : }
         122                 :
         123                 : }
         124                 : }
         125                 : }
         126                 :
         127                 : #endif

Generated by: LTP GCOV extension version 1.6