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