LCOV - lcov.info - /usr/include/apt-pkg/algorithms.h

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