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