src/solver_private.h

   1 /*
   2  * Copyright (c) 2011, Novell Inc.
   3  *
   4  * This program is licensed under the BSD license, read LICENSE.BSD
   5  * for further information
   6  */
   7
   8 /*
   9  * solver_p.h - private functions
  10  *
  11  */
  12
  13 #ifndef LIBSOLV_SOLVER_P_H
  14 #define LIBSOLV_SOLVER_P_H
  15
  16 #if 0
  17 struct _Solver {
  18   Pool *pool;                           /* back pointer to pool */
  19   Queue job;                            /* copy of the job we're solving */
  20
  21   Transaction trans;                    /* calculated transaction */
  22
  23   Repo *installed;                      /* copy of pool->installed */
  24
  25   /* list of rules, ordered
  26    * rpm rules first, then features, updates, jobs, learnt
  27    * see start/end offsets below
  28    */
  29   Rule *rules;                          /* all rules */
  30   Id nrules;                            /* [Offset] index of the last rule */
  31
  32   Queue ruleassertions;                 /* Queue of all assertion rules */
  33
  34   /* start/end offset for rule 'areas' */
  35
  36   Id rpmrules_end;                      /* [Offset] rpm rules end */
  37
  38   Id featurerules;                      /* feature rules start/end */
  39   Id featurerules_end;
  40
  41   Id updaterules;                       /* policy rules, e.g. keep packages installed or update. All literals > 0 */
  42   Id updaterules_end;
  43
  44   Id jobrules;                          /* user rules */
  45   Id jobrules_end;
  46
  47   Id infarchrules;                      /* inferior arch rules */
  48   Id infarchrules_end;
  49
  50   Id duprules;                          /* dist upgrade rules */
  51   Id duprules_end;
  52
  53   Id choicerules;                       /* choice rules (always weak) */
  54   Id choicerules_end;
  55   Id *choicerules_ref;
  56
  57   Id learntrules;                       /* learnt rules, (end == nrules) */
  58
  59   Map noupdate;                         /* don't try to update these
  60                                            installed solvables */
  61   Map noobsoletes;                      /* ignore obsoletes for these (multiinstall) */
  62
  63   Map updatemap;                        /* bring these installed packages to the newest version */
  64   int updatemap_all;                    /* bring all packages to the newest version */
  65
  66   Map fixmap;                           /* fix these packages */
  67   int fixmap_all;                       /* fix all packages */
  68
  69   Queue weakruleq;                      /* index into 'rules' for weak ones */
  70   Map weakrulemap;                      /* map rule# to '1' for weak rules, 1..learntrules */
  71
  72   Id *watches;                          /* Array of rule offsets
  73                                          * watches has nsolvables*2 entries and is addressed from the middle
  74                                          * middle-solvable : decision to conflict, offset point to linked-list of rules
  75                                          * middle+solvable : decision to install: offset point to linked-list of rules
  76                                          */
  77
  78   Queue ruletojob;                      /* index into job queue: jobs for which a rule exits */
  79
  80   /* our decisions: */
  81   Queue decisionq;                      /* >0:install, <0:remove/conflict */
  82   Queue decisionq_why;                  /* index of rule, Offset into rules */
  83
  84   Id *decisionmap;                      /* map for all available solvables,
  85                                          * = 0: undecided
  86                                          * > 0: level of decision when installed,
  87                                          * < 0: level of decision when conflict */
  88
  89   /* learnt rule history */
  90   Queue learnt_why;
  91   Queue learnt_pool;
  92
  93   Queue branches;
  94   int (*solution_callback)(struct _Solver *solv, void *data);
  95   void *solution_callback_data;
  96
  97   int propagate_index;                  /* index into decisionq for non-propagated decisions */
  98
  99   Queue problems;                       /* list of lists of conflicting rules, < 0 for job rules */
 100   Queue solutions;                      /* refined problem storage space */
 101
 102   Queue recommendations;                /* recommended packages */
 103   Queue suggestions;                    /* suggested packages */
 104   Queue orphaned;                       /* orphaned packages */
 105
 106   int stats_learned;                    /* statistic */
 107   int stats_unsolvable;                 /* statistic */
 108
 109   Map recommendsmap;                    /* recommended packages from decisionmap */
 110   Map suggestsmap;                      /* suggested packages from decisionmap */
 111   int recommends_index;                 /* recommendsmap/suggestsmap is created up to this level */
 112
 113   Id *obsoletes;                        /* obsoletes for each installed solvable */
 114   Id *obsoletes_data;                   /* data area for obsoletes */
 115   Id *multiversionupdaters;             /* updaters for multiversion packages in updatesystem mode */
 116
 117   /*-------------------------------------------------------------------------------------------------------------
 118    * Solver configuration
 119    *-------------------------------------------------------------------------------------------------------------*/
 120
 121   int fixsystem;                        /* repair errors in rpm dependency graph */
 122   int allowdowngrade;                   /* allow to downgrade installed solvable */
 123   int allowarchchange;                  /* allow to change architecture of installed solvables */
 124   int allowvendorchange;                /* allow to change vendor of installed solvables */
 125   int allowuninstall;                   /* allow removal of installed solvables */
 126   int updatesystem;                     /* update all packages to the newest version */
 127   int noupdateprovide;                  /* true: update packages needs not to provide old package */
 128   int dosplitprovides;                  /* true: consider legacy split provides */
 129   int dontinstallrecommended;           /* true: do not install recommended packages */
 130   int ignorealreadyrecommended;         /* true: ignore recommended packages that were already recommended by the installed packages */
 131   int dontshowinstalledrecommended;     /* true: do not show recommended packages that are already installed */
 132
 133   /* distupgrade also needs updatesystem and dosplitprovides */
 134   int distupgrade;
 135   int distupgrade_removeunsupported;
 136
 137   int noinfarchcheck;                   /* true: do not forbid inferior architectures */
 138
 139   /* Callbacks for defining the bahaviour of the SAT solver */
 140
 141   /* Finding best candidate
 142    *
 143    * Callback definition:
 144    * void  bestSolvable (Pool *pool, Queue *canditates)
 145    *     candidates       : List of canditates which has to be sorted by the function call
 146    *     return candidates: Sorted list of the candidates(first is the best).
 147    */
 148   BestSolvableCb bestSolvableCb;
 149
 150   /* Checking if two solvables has compatible architectures
 151    *
 152    * Callback definition:
 153    *     int  archCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
 154    *
 155    *     return 0 it the two solvables has compatible architectures
 156    */
 157   ArchCheckCb archCheckCb;
 158
 159   /* Checking if two solvables has compatible vendors
 160    *
 161    * Callback definition:
 162    *     int  vendorCheck (Pool *pool, Solvable *solvable1, Solvable *solvable2);
 163    *
 164    *     return 0 it the two solvables has compatible architectures
 165    */
 166   VendorCheckCb vendorCheckCb;
 167
 168   /* Evaluate update candidate
 169    *
 170    * Callback definition:
 171    * void pdateCandidateCb (Pool *pool, Solvable *solvable, Queue *canditates)
 172    *     solvable   : for which updates should be search
 173    *     candidates : List of candidates (This list depends on other
 174    *                  restrictions like architecture and vendor policies too)
 175    */
 176   UpdateCandidateCb   updateCandidateCb;
 177
 178   Map dupmap;                           /* dup these packages*/
 179   int dupmap_all;                       /* dup all packages */
 180   Map dupinvolvedmap;                   /* packages involved in dup process */
 181
 182   Map droporphanedmap;                  /* packages to drop in dup mode */
 183   int droporphanedmap_all;
 184
 185   Map cleandepsmap;                     /* try to drop these packages as of cleandeps erases */
 186
 187   Queue *ruleinfoq;                     /* tmp space for solver_ruleinfo() */
 188 };
 189 #endif
 190
 191 extern void solver_run_sat(Solver *solv, int disablerules, int doweak);
 192 extern void solver_reset(Solver *solv);
 193
 194 extern int solver_dep_installed(Solver *solv, Id dep);
 195 extern int solver_splitprovides(Solver *solv, Id dep);
 196
 197 static inline int
 198 solver_dep_fulfilled(Solver *solv, Id dep)
 199 {
 200   Pool *pool = solv->pool;
 201   Id p, pp;
 202
 203   if (ISRELDEP(dep))
 204     {
 205       Reldep *rd = GETRELDEP(pool, dep);
 206       if (rd->flags == REL_AND)
 207         {
 208           if (!solver_dep_fulfilled(solv, rd->name))
 209             return 0;
 210           return solver_dep_fulfilled(solv, rd->evr);
 211         }
 212       if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_SPLITPROVIDES)
 213         return solver_splitprovides(solv, rd->evr);
 214       if (rd->flags == REL_NAMESPACE && rd->name == NAMESPACE_INSTALLED)
 215         return solver_dep_installed(solv, rd->evr);
 216     }
 217   FOR_PROVIDES(p, pp, dep)
 218     {
 219       if (solv->decisionmap[p] > 0)
 220         return 1;
 221     }
 222   return 0;
 223 }
 224
 225 static inline int
 226 solver_is_supplementing(Solver *solv, Solvable *s)
 227 {
 228   Id sup, *supp;
 229   if (!s->supplements)
 230     return 0;
 231   supp = s->repo->idarraydata + s->supplements;
 232   while ((sup = *supp++) != 0)
 233     if (solver_dep_fulfilled(solv, sup))
 234       return 1;
 235   return 0;
 236 }
 237
 238 static inline int
 239 solver_is_enhancing(Solver *solv, Solvable *s)
 240 {
 241   Id enh, *enhp;
 242   if (!s->enhances)
 243     return 0;
 244   enhp = s->repo->idarraydata + s->enhances;
 245   while ((enh = *enhp++) != 0)
 246     if (solver_dep_fulfilled(solv, enh))
 247       return 1;
 248   return 0;
 249 }
 250
 251 #endif /* LIBSOLV_SOLVER_P_H */