apt  0.9.9.1~ubuntu1
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 class pkgAcquireStatus;
47 
48 class pkgSimulate : public pkgPackageManager /*{{{*/
49 {
50  protected:
51 
52  class Policy : public pkgDepCache::Policy
53  {
54  pkgDepCache *Cache;
55  public:
56 
57  virtual VerIterator GetCandidateVer(PkgIterator const &Pkg)
58  {
59  return (*Cache)[Pkg].CandidateVerIter(*Cache);
60  }
61 
62  Policy(pkgDepCache *Cache) : Cache(Cache) {};
63  };
64 
65  unsigned char *Flags;
66 
67  Policy iPolicy;
68  pkgDepCache Sim;
70 
71  // The Actuall installation implementation
72  virtual bool Install(PkgIterator Pkg,std::string File);
73  virtual bool Configure(PkgIterator Pkg);
74  virtual bool Remove(PkgIterator Pkg,bool Purge);
75 
76 private:
77  void ShortBreaks();
78  void Describe(PkgIterator iPkg,std::ostream &out,bool Current,bool Candidate);
79 
80  public:
81 
82  pkgSimulate(pkgDepCache *Cache);
83  ~pkgSimulate();
84 };
85  /*}}}*/
86 class pkgProblemResolver /*{{{*/
87 {
89  void *d;
90 
91  pkgDepCache &Cache;
96  typedef pkgCache::Version Version;
97  typedef pkgCache::Package Package;
98 
99  enum Flags {Protected = (1 << 0), PreInstalled = (1 << 1),
100  Upgradable = (1 << 2), ReInstateTried = (1 << 3),
101  ToRemove = (1 << 4)};
102  int *Scores;
103  unsigned char *Flags;
104  bool Debug;
105 
106  // Sort stuff
107  static pkgProblemResolver *This;
108  static int ScoreSort(const void *a,const void *b);
109 
110  struct PackageKill
111  {
112  PkgIterator Pkg;
113  DepIterator Dep;
114  };
115 
116  void MakeScores();
117  bool DoUpgrade(pkgCache::PkgIterator Pkg);
118 
119  bool ResolveInternal(bool const BrokenFix = false);
120  bool ResolveByKeepInternal();
121 
122  protected:
123  bool InstOrNewPolicyBroken(pkgCache::PkgIterator Pkg);
124 
125  public:
126 
127  inline void Protect(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= Protected; Cache.MarkProtected(Pkg);};
128  inline void Remove(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] |= ToRemove;};
129  inline void Clear(pkgCache::PkgIterator Pkg) {Flags[Pkg->ID] &= ~(Protected | ToRemove);};
130 
131  // Try to intelligently resolve problems by installing and removing packages
132  bool Resolve(bool BrokenFix = false);
133 
134  // Try to resolve problems only by using keep
135  bool ResolveByKeep();
136 
137  __deprecated void InstallProtect();
138 
141 };
142  /*}}}*/
143 bool pkgDistUpgrade(pkgDepCache &Cache);
144 bool pkgApplyStatus(pkgDepCache &Cache);
145 bool pkgFixBroken(pkgDepCache &Cache);
146 bool pkgAllUpgrade(pkgDepCache &Cache);
147 bool pkgMinimizeUpgrade(pkgDepCache &Cache);
148 
149 void pkgPrioSortList(pkgCache &Cache,pkgCache::Version **List);
150 
151 bool ListUpdate(pkgAcquireStatus &progress, pkgSourceList &List, int PulseInterval=0);
152 bool AcquireUpdate(pkgAcquire &Fetcher, int const PulseInterval = 0,
153  bool const RunUpdateScripts = true, bool const ListCleanup = true);
154 
155 #endif