LTP GCOV extension - code coverage report
Current view: directory - usr/include/apt-pkg - algorithms.h
Test: lcov.info
Date: 2008-08-14 Instrumented lines: 3
Code covered: 66.7 % Executed lines: 2

       1                 : // -*- mode: cpp; mode: fold -*-
       2                 : // Description                                                          /*{{{*/
       3                 : // $Id: algorithms.h,v 1.10 2001/05/22 04:17:41 jgg Exp $
       4                 : /* ######################################################################
       5                 : 
       6                 :    Algorithms - A set of misc algorithms
       7                 :    
       8                 :    This simulate class displays what the ordering code has done and
       9                 :    analyses it with a fresh new dependency cache. In this way we can
      10                 :    see all of the effects of an upgrade run.
      11                 : 
      12                 :    pkgDistUpgrade computes an upgrade that causes as many packages as
      13                 :    possible to move to the newest verison.
      14                 :    
      15                 :    pkgApplyStatus sets the target state based on the content of the status
      16                 :    field in the status file. It is important to get proper crash recovery.
      17                 : 
      18                 :    pkgFixBroken corrects a broken system so that it is in a sane state.
      19                 :  
      20                 :    pkgAllUpgrade attempts to upgade as many packages as possible but 
      21                 :    without installing new packages.
      22                 :    
      23                 :    The problem resolver class contains a number of complex algorithms
      24                 :    to try to best-guess an upgrade state. It solves the problem of 
      25                 :    maximizing the number of install state packages while having no broken
      26                 :    packages. 
      27                 : 
      28                 :    ##################################################################### */
      29                 :                                                                         /*}}}*/
      30                 : #ifndef PKGLIB_ALGORITHMS_H
      31                 : #define PKGLIB_ALGORITHMS_H
      32                 : 
      33                 : 
      34                 : #include <apt-pkg/packagemanager.h>
      35                 : #include <apt-pkg/depcache.h>
      36                 : #include <apt-pkg/acquire.h>
      37                 : 
      38                 : #include <iostream>
      39                 : 
      40                 : using std::ostream;
      41                 : 
      42                 : class pkgSimulate : public pkgPackageManager
      43                 : {
      44                 :    protected:
      45                 : 
      46                 :    class Policy : public pkgDepCache::Policy
      47                 :    {
      48                 :       pkgDepCache *Cache;
      49                 :       public:
      50                 :       
      51                 :       virtual VerIterator GetCandidateVer(PkgIterator Pkg)
      52                 :       {
      53                 :          return (*Cache)[Pkg].CandidateVerIter(*Cache);
      54                 :       }
      55                 :       
      56                 :       Policy(pkgDepCache *Cache) : Cache(Cache) {};
      57                 :    };
      58                 :    
      59                 :    unsigned char *Flags;
      60                 :    
      61                 :    Policy iPolicy;
      62                 :    pkgDepCache Sim;
      63                 :    
      64                 :    // The Actuall installation implementation
      65                 :    virtual bool Install(PkgIterator Pkg,string File);
      66                 :    virtual bool Configure(PkgIterator Pkg);
      67                 :    virtual bool Remove(PkgIterator Pkg,bool Purge);
      68                 : 
      69                 : private:
      70                 :    void ShortBreaks();
      71                 :    void Describe(PkgIterator iPkg,ostream &out,bool Current,bool Candidate);
      72                 :    
      73                 :    public:
      74                 : 
      75                 :    pkgSimulate(pkgDepCache *Cache);
      76                 : };
      77                 : 
      78                 : class pkgProblemResolver
      79                 : {
      80                 :    pkgDepCache &Cache;
      81                 :    typedef pkgCache::PkgIterator PkgIterator;
      82                 :    typedef pkgCache::VerIterator VerIterator;
      83                 :    typedef pkgCache::DepIterator DepIterator;
      84                 :    typedef pkgCache::PrvIterator PrvIterator;
      85                 :    typedef pkgCache::Version Version;
      86                 :    typedef pkgCache::Package Package;
      87                 :    
      88                 :    enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
      89                 :                Upgradable = (1 << 2), ReInstateTried = (1 << 3),
      90                 :                ToRemove = (1 << 4)};
      91                 :    signed short *Scores;
      92                 :    unsigned char *Flags;
      93                 :    bool Debug;
      94                 :    
      95                 :    // Sort stuff
      96                 :    static pkgProblemResolver *This;
      97                 :    static int ScoreSort(const void *a,const void *b);
      98                 : 
      99                 :    struct PackageKill
     100                 :    {
     101                 :       PkgIterator Pkg;
     102                 :       DepIterator Dep;
     103                 :    };
     104                 : 
     105                 :    void MakeScores();
     106                 :    bool DoUpgrade(pkgCache::PkgIterator Pkg);
     107                 :    
     108                 :    public:
     109                 :    
     110               4 :    inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected;};
     111               0 :    inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
     112               4 :    inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
     113                 :    
     114                 :    // Try to intelligently resolve problems by installing and removing packages   
     115                 :    bool Resolve(bool BrokenFix = false);
     116                 :    
     117                 :    // Try to resolve problems only by using keep
     118                 :    bool ResolveByKeep();
     119                 : 
     120                 :    // Install all protected packages   
     121                 :    void InstallProtect();   
     122                 :    
     123                 :    pkgProblemResolver(pkgDepCache *Cache);
     124                 :    ~pkgProblemResolver();
     125                 : };
     126                 : 
     127                 : bool pkgDistUpgrade(pkgDepCache &Cache);
     128                 : bool pkgApplyStatus(pkgDepCache &Cache);
     129                 : bool pkgFixBroken(pkgDepCache &Cache);
     130                 : bool pkgAllUpgrade(pkgDepCache &Cache);
     131                 : bool pkgMinimizeUpgrade(pkgDepCache &Cache);
     132                 : 
     133                 : void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
     134                 : 
     135                 : bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0);
     136                 :                      
     137                 : #endif

Generated by: LTP GCOV extension version 1.6