apt  0.9.14
algorithms.h
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 
37 #include <iostream>
38 
39 #include <apt-pkg/macros.h>
40 
41 #ifndef APT_8_CLEANER_HEADERS
42 #include <apt-pkg/acquire.h>
43 using std::ostream;
44 #endif
45 
46 #ifndef APT_9_CLEANER_HEADERS
47 // include pkg{DistUpgrade,AllUpgrade,MiniizeUpgrade} here for compatiblity
48 #include <apt-pkg/upgrade.h>
49 #include <apt-pkg/update.h>
50 #endif
51 
52 
53 class pkgSimulate : public pkgPackageManager /*{{{*/
54 {
55  protected:
56 
57  class Policy : public pkgDepCache::Policy
58  {
59  pkgDepCache *Cache;
60  public:
61 
62  virtual VerIterator GetCandidateVer(PkgIterator const &Pkg)
63  {
64  return (*Cache)[Pkg].CandidateVerIter(*Cache);
65  }
66 
67  Policy(pkgDepCache *Cache) : Cache(Cache) {};
68  };
69 
70  unsigned char *Flags;
71 
72  Policy iPolicy;
73  pkgDepCache Sim;
75 
76  // The Actuall installation implementation
77  virtual bool Install(PkgIterator Pkg,std::string File);
78  virtual bool Configure(PkgIterator Pkg);
79  virtual bool Remove(PkgIterator Pkg,bool Purge);
80 
81 private:
82  void ShortBreaks();
83  void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
84 
85  public:
86 
87  pkgSimulate(pkgDepCache *Cache);
88  ~pkgSimulate();
89 };
90  /*}}}*/
91 class pkgProblemResolver /*{{{*/
92 {
93  private:
95  void *d;
96 
97  pkgDepCache &Cache;
102  typedef pkgCache::Version Version;
103  typedef pkgCache::Package Package;
104 
105  enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
106  Upgradable = (1 << 2), ReInstateTried = (1 << 3),
107  ToRemove = (1 << 4)};
108  int *Scores;
109  unsigned char *Flags;
110  bool Debug;
111 
112  // Sort stuff
113  static pkgProblemResolver *This;
114  static int ScoreSort(const void *a,const void *b);
115 
116  struct PackageKill
117  {
118  PkgIterator Pkg;
119  DepIterator Dep;
120  };
121 
122  void MakeScores();
123  bool DoUpgrade(pkgCache::PkgIterator Pkg);
124 
125  bool ResolveInternal(bool const BrokenFix = false);
126  bool ResolveByKeepInternal();
127 
128  protected:
129  bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg);
130 
131  public:
132 
133  inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);};
134  inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
135  inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
136 
137  // Try to intelligently resolve problems by installing and removing packages
138  bool Resolve(bool BrokenFix = false);
139 
140  // Try to resolve problems only by using keep
141  bool ResolveByKeep();
142 
143  __deprecated void InstallProtect();
144 
147 };
148  /*}}}*/
149 bool pkgApplyStatus(pkgDepCache &Cache);
150 bool pkgFixBroken(pkgDepCache &Cache);
151 
152 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
153 
154 
155 #endif
Definition: cacheiterators.h:136
Definition: algorithms.h:53
Definition: cacheiterators.h:315
Represents an active action group.
Definition: depcache.h:156
information for a single version of a package
Definition: pkgcache.h:501
Definition: packagemanager.h:47
Definition: pkgcache.h:86
contains information for a single unique package
Definition: pkgcache.h:361
Definition: cacheiterators.h:264
Definition: depcache.h:264
Definition: algorithms.h:91
Definition: cacheiterators.h:185
Definition: depcache.h:56
Definition: algorithms.h:57