|
| _avgindegree [Statistics.Make] |
|
| _avgoutdegree [Statistics.Make] |
|
| _false [Flatten.Formula] |
|
| _false [Flatten.Disj] |
|
| _indata [Statistics.Make] |
|
| _maxindegree [Statistics.Make] |
|
| _maxoutdegree [Statistics.Make] |
|
| _outdata [Statistics.Make] |
|
| _true [Flatten.Formula] |
|
A |
| add [Challenged] |
|
| add [Flatten.Conflict] |
|
| add [Diagnostic] |
|
| add_edge [Defaultgraphs.IntPkgGraph] |
|
| add_edge [Defaultgraphs.MakePackageGraph] |
|
| add_epochs [Evolution] |
|
| add_format [Distcheck] |
|
| add_normalize [Evolution] |
|
| add_properties [CudfAdd] |
|
| add_rule [EdosSolver.T] |
add_rule st l add a disjuction to the solver of type
|
| add_to_package_list [CudfAdd] |
|
| add_unique [Evolution] |
|
| al_regexp [Apt] |
|
| align [Evolution] |
|
| all_constraints [Evolution] |
|
| all_disabled [Util.Messages] |
disable all handles in the module
|
| all_enabled [Util.Messages] |
enable all handles in the module
|
| all_quiet [Boilerplate] |
|
| all_quiet [BoilerplateNoRpm] |
|
| all_ver_constr [Evolution] |
|
| all_versions [Evolution] |
|
| apt_get_cmdline [Apt-cudf] |
|
| arch_filter [Packages] |
|
| assignment [EdosSolver.T] |
assignment st return the array of values associated to every variable.
|
| assignment_true [EdosSolver.T] |
assignment_true st return the list of variables that are true
|
| assoc [Packages] |
|
| associate_vars [EdosSolver.T] |
associate_vars st lit vl associate a variable to a list of variables.
|
| available [Util.Timer] |
return the labels of all available progress bar
|
| available [Util.Progress] |
return the labels of all available progress bar
|
| avalaible [Util.Messages] |
return the list of all labels known to the module
|
| averageComponents [Statistics.Make] |
|
| averageComponentsSC [Statistics.Make] |
|
| averageComponentsWC [Statistics.Make] |
|
| averageInDegree [Statistics.Make] |
|
| averageOutDegree [Statistics.Make] |
|
| averageShortestPathLength [Statistics.Make] |
|
| averageTwoStepReach [Statistics.Make] |
|
| average_distance [Statistics.Make] |
|
B |
| background [Distcheck.Options] |
|
| blank_regexp [Apt] |
|
| brokenlist [Challenged.Options] |
|
| build_paths [Diagnostic] |
given a list of dependencies, return a list of list containg all
* paths in the dependency tree starting from root
|
| bzip_open_file [Input] |
load a file in bzip format - Not implemented yet
|
C |
| centralityDegree [Statistics.Make] |
|
| centralityInDegree [Statistics.Make] |
|
| centralityOutDegree [Statistics.Make] |
|
| challenged [Challenged] |
|
| check [Flatten.Conflict] |
|
| check_exit_status [Apt-cudf] |
|
| check_fail [Apt-cudf] |
|
| check_request [Depsolver] |
|
| check_strong [Strongdeps_int] |
check if p strong depends on any packages in l
|
| checkonly [Challenged.Options] |
|
| checkonly [Outdated.Options] |
|
| checkonly [Distcheck.Options] |
|
| choose_criteria [Apt-cudf] |
|
| clear [Debcudf] |
return the cudf version associated to a tuple (name,version).
|
| close_ch [Input] |
|
| cluster [Challenged.Options] |
|
| cluster [Debutil] |
group_by_source universe returns a hashtbl that maps
(source,sourceversion) -> to a packages list
|
| clustering [Statistics.Make] |
|
| clustering_coefficient [Statistics.Make] |
|
| cnf_iter [Evolution] |
|
| coinst [Distcheck.Options] |
|
| collect [Diagnostic] |
|
| collect_reasons [EdosSolver.T] |
in case of failure return the list of associated reasons
|
| collect_reasons_lst [EdosSolver.T] |
in case of failure return the list of associated reasons
|
| comma_regexp [Apt] |
|
| compare [Version] |
compare x y returns 0 if x is eqivalent to y, -1 if x is smaller
than y, and 1 if x is greater than y.
|
| compare [Defaultgraphs.PkgE] |
|
| compare [Defaultgraphs.PkgV] |
|
| compare [Defaultgraphs.SyntacticDependencyGraph.PkgE] |
|
| compare [Defaultgraphs.SyntacticDependencyGraph.PkgV] |
|
| compare [Flatten.Disj] |
|
| compare [Flatten.Package] |
|
| compare [Strongconflicts_int.CflE] |
|
| compare [Defaultgraphs.IntPkgGraph.PkgV] |
|
| compare [Strongconflicts.CflE] |
|
| compare [CudfAdd] |
Compare function: compares two CUDF packages using standard CUDF comparison operator (i.e.
|
| components [Statistics.Make] |
|
| compose [Version] |
recompose a decomposed version string.
|
| computeInDegree [Statistics.Make] |
|
| computeOutDegree [Statistics.Make] |
|
| compute_pool [CudfAdd] |
|
| concat [Version] |
|
| cone [Ceve.Options] |
|
| cone_maxdepth [Ceve.Options] |
|
| conffile [Apt-cudf.Options] |
|
| conflict_graph [Defaultgraphs.MakePackageGraph] |
Build the conflict graph from the given cudf universe
|
| conj [Flatten.Formula] |
|
| conj1 [Flatten.Formula] |
|
| conj_iter [Evolution] |
|
| conjbar [Strongdeps_int] |
|
| conjdepgraph [Defaultgraphs.IntPkgGraph] |
for all id \in idlist add to the graph all conjunctive dependencies
|
| conjdepgraph [Defaultgraphs.MakePackageGraph] |
for all id \in idlist add to the graph all conjunctive dependencies
|
| conjdepgraph_int [Defaultgraphs.IntPkgGraph] |
add to the graph all conjunctive dependencies of package id
|
| conjdepgraph_int [Defaultgraphs.MakePackageGraph] |
add to the graph all conjunctive dependencies of package id
|
| conjdeps [Defaultgraphs.IntPkgGraph] |
given a graph return the conjunctive dependency closure of the package id
|
| conjdeps [Defaultgraphs.MakePackageGraph] |
given a graph return the conjunctive dependency closure of the package id
|
| conjdeps [Strongdeps] |
compute the conjunctive dependency graph considering only packages
in pkglist
|
| conjdeps_univ [Strongdeps] |
compute the conjunctive dependency graph
|
| conjl [Flatten.Formula] |
|
| conjtimer [Strongdeps_int] |
|
| connected_components [Defaultgraphs.MakePackageGraph] |
Return the list of connected component of an undirected graph
|
| constraints [Evolution] |
constraints universe returns a map between package names
and an ordered list of constraints where the package name is
mentioned
|
| copy [EdosSolver.T] |
provide a deep copy of the current state of the solver
|
| copy_solver [Depsolver_int] |
return a copy of the state of the solver
|
| create [Flatten.Conflict] |
|
| create [Flatten.PTbl] |
|
| create [Util.Timer] |
create s create and register a new logger named s
|
| create [Util.Progress] |
create "barname" : create new a progress bar labelled "barname".
|
| create [Util.Messages] |
|
| create_pathlist [Diagnostic] |
|
| criteria [Apt-cudf.Options] |
|
| csw_load_list [Boilerplate] |
|
| csw_load_list [BoilerplateNoRpm] |
|
| csw_parse_input [Boilerplate] |
|
| csw_parse_input [BoilerplateNoRpm] |
|
| cudf_load_list [Boilerplate] |
|
| cudf_load_list [BoilerplateNoRpm] |
|
| cudf_load_universe [Boilerplate] |
|
| cudf_load_universe [BoilerplateNoRpm] |
|
| cudf_parse_input [Boilerplate] |
|
| cudf_parse_input [BoilerplateNoRpm] |
|
| cudfop [CudfAdd] |
|
| cut [Flatten.Disj] |
|
| cvt [Strongconflicts] |
|
| cycle_reduction [Defaultgraphs.MakePackageGraph] |
|
D |
| deb_build_arch [Boilerplate.MakeDistribOptions] |
|
| deb_build_arch [BoilerplateNoRpm.MakeDistribOptions] |
|
| deb_foreign_arch [Boilerplate.MakeDistribOptions] |
|
| deb_foreign_arch [BoilerplateNoRpm.MakeDistribOptions] |
|
| deb_host_arch [Boilerplate.MakeDistribOptions] |
|
| deb_host_arch [BoilerplateNoRpm.MakeDistribOptions] |
|
| deb_ignore_essential [Boilerplate.MakeDistribOptions] |
|
| deb_ignore_essential [BoilerplateNoRpm.MakeDistribOptions] |
|
| deb_load_list [Boilerplate] |
|
| deb_load_list [BoilerplateNoRpm] |
|
| deb_load_universe [Boilerplate] |
transform a list of debian control stanza into a cudf universe
|
| deb_load_universe [BoilerplateNoRpm] |
transform a list of debian control stanza into a cudf universe
|
| deb_native_arch [Boilerplate.MakeDistribOptions] |
|
| deb_native_arch [BoilerplateNoRpm.MakeDistribOptions] |
|
| deb_parse_input [Boilerplate] |
|
| deb_parse_input [BoilerplateNoRpm] |
|
| debug [Util.Logging] |
|
| debug [EdosSolver.T] |
enable debug messages
|
| debvpkg [Boilerplate] |
|
| debvpkg [BoilerplateNoRpm] |
|
| decode [CudfAdd] |
Decode a string.
|
| decompose [Version] |
decompose a version string
|
| default [Defaultgraphs.PkgE] |
|
| default [Defaultgraphs.SyntacticDependencyGraph.PkgE] |
|
| default [Strongconflicts_int.CflE] |
|
| default [Strongconflicts.CflE] |
|
| default_edge_attributes [Defaultgraphs.IntPkgGraph.Display] |
|
| default_edge_attributes [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| default_edge_attributes [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| default_extras [Packages] |
|
| default_options [Debcudf] |
|
| default_package [Packages] |
|
| default_pp [Diagnostic] |
|
| default_release [Release] |
|
| default_request [Edsp] |
|
| default_result [Diagnostic] |
|
| default_source [Sources] |
|
| default_vertex_attributes [Defaultgraphs.IntPkgGraph.Display] |
|
| default_vertex_attributes [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| default_vertex_attributes [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| degree [Statistics.Make] |
|
| density [Statistics.Make] |
|
| dependency_closure [Depsolver_int] |
dependency_closure index l return the union of the dependency closure of
all packages in l .
|
| dependency_closure [Depsolver] |
dependency_closure universe l compute the dependencies closure
of the give package list.
|
| dependency_closure_cache [Depsolver_int] |
|
| dependency_graph [Defaultgraphs.IntPkgGraph] |
Build the dependency graph from the given index.
|
| dependency_graph [Defaultgraphs.MakePackageGraph] |
Build the dependency graph from the given cudf universe
|
| dependency_graph [Defaultgraphs.SyntacticDependencyGraph] |
Build the syntactic dependency graph from the give cudf universe
|
| dependency_graph_list [Defaultgraphs.IntPkgGraph] |
|
| dependency_graph_list [Defaultgraphs.MakePackageGraph] |
Build the dependency graph from the given list of packages
|
| depgraphbar [Defaultgraphs.SyntacticDependencyGraph] |
|
| description [Outdated.Options] |
|
| description [Apt-cudf.Options] |
|
| description [Ceve.Options] |
|
| description [Distcheck.Options] |
|
| di_regexp [Apt] |
|
| disable [Util.Progress] |
disable "barname" : disable the progress bar with label "barname"
|
| disable [Util.Messages] |
disable l the handle with label l
|
| discriminant [Evolution] |
discriminants ?bottom ?ascending evalsel vl constraints
returns the discriminants of the versions vl w.r.t.
|
| disj [Flatten.Formula] |
|
| disj [Flatten.Disj] |
|
| disjl [Flatten.Formula] |
|
| disjl [Flatten.Disj] |
|
| downgrades [Challenged.Options] |
|
| dst [Ceve.Options] |
|
| dt [Util.Logging] |
|
| dummy [Challenged] |
|
| dummy [Outdated] |
|
| dummy_loc [Format822] |
|
| dump [Outdated.Options] |
|
| dump [Apt-cudf.Options] |
|
| dump [Util.Timer] |
print all timers that are enabled
|
| dump [EdosSolver.T] |
if the solver was initialized with buffer = true,
dump the state of the solver.
|
E |
| eclipse_load_list [Boilerplate] |
|
| eclipse_load_list [BoilerplateNoRpm] |
|
| eclipse_parse_input [Boilerplate] |
|
| eclipse_parse_input [BoilerplateNoRpm] |
|
| edge_attributes [Defaultgraphs.IntPkgGraph.Display] |
|
| edge_attributes [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| edge_attributes [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| edos_coinstall [Depsolver] |
check if the give package list can be installed in the universe
|
| edos_coinstall_prod [Depsolver] |
accept a list of list of packages and return the coinstallability test of
the cartesian product.
|
| edos_install [Depsolver] |
check if the given package can be installed in the universe
|
| enable [Util.Timer] |
enable "barname" : enable the progress bar with label "barname"
|
| enable [Util.Progress] |
enable "barname" : enable the progress bar with label "barname"
|
| enable [Util.Messages] |
enable l the handle with label l
|
| enable_bars [Boilerplate] |
|
| enable_bars [BoilerplateNoRpm] |
|
| enable_debug [Boilerplate] |
|
| enable_debug [BoilerplateNoRpm] |
|
| enable_timers [Boilerplate] |
|
| enable_timers [BoilerplateNoRpm] |
|
| encode [CudfAdd] |
Encode a string.
|
| eprintf [Util.Messages] |
Print the message on stderr if the Util module has been
* set to verbose using the function make_verbose and
* either the handle t is enable or all handles were enabled with
* the function all_enabled
|
| eq_regexp [Apt] |
|
| equal [Version] |
|
| equal [Defaultgraphs.PkgE] |
|
| equal [Defaultgraphs.PkgV] |
|
| equal [Defaultgraphs.SyntacticDependencyGraph.PkgE] |
|
| equal [Defaultgraphs.SyntacticDependencyGraph.PkgV] |
|
| equal [Defaultgraphs.IntPkgGraph.PkgV] |
|
| equal [CudfAdd] |
Equality test: two CUDF packages are equal if their names and versions are equal.
|
| equiv [Flatten.Formula] |
|
| equiv [Flatten.Disj] |
|
| evalsel [Challenged] |
|
| evalsel [Outdated] |
|
| exclude [Challenged] |
|
| exists [Flatten.Conflict] |
|
| exists [Flatten.Formula] |
|
| exists [Flatten.Disj] |
|
| explain [Outdated.Options] |
|
| explain [Apt-cudf.Options] |
|
| explain [Distcheck.Options] |
|
| explicit [Strongconflicts_int] |
|
| extend_loc [Format822] |
|
| extract_epochs [Evolution] |
|
| extras [Edsp] |
|
| extras_tocudf [Edsp] |
|
F |
| failure [Outdated.Options] |
|
| failures [Distcheck.Options] |
|
| fatal [Util.Logging] |
|
| filter [Flatten.Formula] |
|
| filter [Flatten.Disj] |
|
| filter_conflicts [Flatten] |
|
| find_broken [Depsolver] |
return the list of the broken packages
|
| flatten_dep [Flatten] |
|
| flatten_dependencies [Flatten] |
|
| flatten_deps [Flatten] |
|
| flatten_repository [Flatten] |
|
| fold [Flatten.Formula] |
|
| fold [Flatten.Disj] |
|
| fold [Flatten.PTbl] |
|
| foldi [Flatten.PTbl] |
|
| for_all [Flatten.Conflict] |
|
| for_all [Flatten.Disj] |
|
| foreground [Distcheck.Options] |
|
| foreign_arch [Apt-cudf.Options] |
|
| fprintf [Diagnostic] |
|
| from_apt_request [Edsp] |
|
| from_channel [Format822] |
|
G |
| general_regexp [Apt] |
|
| get [Flatten.PTbl] |
|
| get_architectures [Apt-cudf] |
|
| get_cudf_version [Debcudf] |
|
| get_option [Statistics.Make] |
|
| get_package_list [CudfAdd] |
|
| get_real_version [Debcudf] |
return the real version associated to a Cudf package
|
| get_source [Debutil] |
|
| get_subgraph [Defaultgraphs.IntPkgGraph.Display] |
|
| get_subgraph [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| get_subgraph [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| graph_attributes [Defaultgraphs.IntPkgGraph.Display] |
|
| graph_attributes [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| graph_attributes [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| guess_format [Distcheck] |
|
| guess_format [Input] |
guess the input format from a list of list of uris and check
* if the list is omogenueous w.r.t the guessed format.
|
| gzip_open_file [Input] |
load a file in gzip format
|
H |
| has [Flatten.Conflict] |
|
| hash [Defaultgraphs.PkgE] |
|
| hash [Defaultgraphs.PkgV] |
|
| hash [Defaultgraphs.SyntacticDependencyGraph.PkgE] |
|
| hash [Defaultgraphs.SyntacticDependencyGraph.PkgV] |
|
| hash [Defaultgraphs.IntPkgGraph.PkgV] |
|
| hash [CudfAdd] |
A hash function for CUDF packages, using only their name and version.
|
I |
| if_application [Boilerplate] |
|
| if_application [BoilerplateNoRpm] |
|
| impactlist [Strongdeps_int] |
invariant : we assume the graph is NOT detransitivitized
|
| impactset [Strongdeps_int] |
|
| impactset [Strongdeps] |
compute the impact set of the node q, that is the list of all
packages p that strong depends on q
|
| implies [Flatten.Formula] |
|
| implies [Flatten.Disj] |
|
| implies1 [Flatten.Formula] |
|
| implies1 [Flatten.Disj] |
|
| incr_str_list [Boilerplate] |
|
| incr_str_list [BoilerplateNoRpm] |
|
| info [Util.Logging] |
|
| init [Flatten.PTbl] |
|
| init_conflicts [CudfAdd] |
|
| init_map [Depsolver_int] |
|
| init_pool_univ [Depsolver_int] |
|
| init_solver_cache [Depsolver_int] |
initalise the sat solver.
|
| init_solver_closure [Depsolver_int] |
low level constraint solver initialization
|
| init_solver_pool [Depsolver_int] |
this function creates an array indexed by solver ids that can be
used to init the edos solver
|
| init_solver_univ [Depsolver_int] |
low level constraint solver initialization
|
| init_tables [Debcudf] |
initialize the version conversion tables
|
| initialize_problem [EdosSolver.T] |
initialize the solver initialize_problem n
|
| input_all_lines [Apt-cudf] |
|
| input_raw [Format822.RawInput] |
|
| input_raw [Sources] |
parse a debian Sources file
|
| input_raw [Packages] |
input_raw file : parse a debian Packages file from file
|
| input_raw_ch [Edsp] |
|
| input_raw_ch [Format822.RawInput] |
|
| input_raw_ch [Packages] |
input_raw_ch ch : parse a debian Packages file from channel ch
|
| inputtype [Distcheck.Options] |
|
| inttovar [CudfAdd] |
|
| is_composition [Flatten] |
|
| is_enabled [Util.Messages] |
|
| is_essential [CudfAdd] |
|
| is_installed [Edsp] |
|
| is_solution [Diagnostic] |
|
| it [Util.Logging] |
|
| iter [Flatten.Conflict] |
|
| iter [Flatten.Formula] |
|
| iter [Flatten.Disj] |
|
| iter_on_packages [Flatten.Conflict] |
|
| iteri [Flatten.PTbl] |
|
L |
| largestComponent [Statistics.Make] |
|
| largestComponentSC [Statistics.Make] |
|
| largestComponentWC [Statistics.Make] |
|
| latest [Distcheck.Options] |
|
| lesser_or_equal [Challenged] |
|
| lexbuf_wrapper [Packages] |
|
| list_unique [Util] |
return a list of unique elements.
|
| listcheck [Depsolver] |
|
| lit [Flatten.Formula] |
|
| lit [Flatten.Disj] |
|
| lit_disj [Flatten.Formula] |
|
| lit_disj [Flatten.Disj] |
|
| lit_of_var [EdosSolver.T] |
lit_of_var given a variable create a positive or a negative literal.
|
| lltocudf [Debcudf] |
convert a debian dependency list in a cudf constraints formula
|
| load [Defaultgraphs.IntPkgGraph] |
|
| load [Defaultgraphs.MakePackageGraph] |
|
| load [Depsolver] |
initialize the solver.
|
| load_cudf [Boilerplate] |
parse a cudf file and return a triple (preamble,universe,request option).
|
| load_cudf [BoilerplateNoRpm] |
parse a cudf file and return a triple (preamble,universe,request option).
|
| load_list [Boilerplate] |
parse and merge a list of files into a cudf package list
|
| load_list [BoilerplateNoRpm] |
parse and merge a list of files into a cudf package list
|
| load_list [Debcudf] |
create a Cudf package list from a debian package representation list.
|
| load_universe [Boilerplate] |
parse and merge a list of files into a cudf universe
|
| load_universe [BoilerplateNoRpm] |
parse and merge a list of files into a cudf universe
|
| load_universe [Debcudf] |
create a Cudf universe from a debian package representation list.
|
| loc_of_lexbuf [Format822] |
|
| localbar [Strongconflicts_int] |
|
| ltocudf [Debcudf] |
convert a debian conflict list in a cudf constraints list
|
M |
| main [Challenged] |
|
| main [Outdated] |
|
| main [Apt-cudf] |
|
| main [Ceve] |
|
| main [Distcheck] |
|
| mainbar [Strongdeps_int] |
|
| make_request [Apt-cudf] |
|
| map [Flatten.Formula] |
|
| map [Flatten.PTbl] |
|
| mapi [Flatten.PTbl] |
|
| maxInDegree [Statistics.Make] |
|
| maxOutDegree [Statistics.Make] |
|
| maybe_remove [Flatten] |
|
| memo [Util] |
A generic memoization function.
|
| merge [Packages] |
|
| migrate [Evolution] |
|
| minimal [Distcheck.Options] |
|
| minimize [Diagnostic] |
|
| mktmpdir [Apt-cudf] |
see mktemp(1) for the syntax of tmp_pattern
|
N |
| native_arch [Apt-cudf.Options] |
|
| noop [Apt-cudf.Options] |
|
| normalize [Version] |
chop the epoch and binnmu component from a version.
|
| normalize [Flatten.Formula] |
|
| normalize [Flatten.Disj] |
|
| normalize_set [CudfAdd] |
|
| nr_conflicts [Ceve] |
|
| numberComponents [Statistics.Make] |
|
| numberComponentsSC [Statistics.Make] |
|
| numberComponentsWC [Statistics.Make] |
|
O |
| of_disj [Flatten.Formula] |
|
| of_package [Flatten.Conflict] |
|
| open_ch [Input] |
|
| open_file [Input] |
load a file either in gzip, bzip or not compressed format
|
| options [Boilerplate.Ot] |
|
| options [Boilerplate.MakeOptions] |
|
| options [Challenged.Options] |
|
| options [Outdated.Options] |
|
| options [Apt-cudf.Options] |
|
| options [BoilerplateNoRpm.Ot] |
|
| options [BoilerplateNoRpm.MakeOptions] |
|
| options [Ceve.Options] |
|
| options [Distcheck.Options] |
|
| out [Defaultgraphs.MakePackageGraph] |
|
| out_file [Ceve.Options] |
|
| out_option [Ceve.Options] |
|
| out_type [Ceve.Options] |
|
| outdated [Outdated] |
|
| outfile [Distcheck.Options] |
|
| output_clauses [Depsolver] |
output_clauses enc univ return a string encoded accordingly to enc
(default cnf).
|
| output_cudf [Ceve] |
|
| output_to_sqlite [Ceve] |
|
P |
| packages_parser [Edsp] |
|
| packages_parser [Packages] |
|
| parse_apt_id [Edsp] |
|
| parse_apt_pin [Edsp] |
|
| parse_arch [Sources] |
|
| parse_architecture [Packages] |
|
| parse_automatic [Edsp] |
|
| parse_binary [Sources] |
|
| parse_binarylist [Packages] |
|
| parse_bool [Packages] |
|
| parse_bool_s [Edsp] |
|
| parse_builddepsformula [Sources] |
|
| parse_builddepslist [Sources] |
|
| parse_candidate [Edsp] |
|
| parse_conf_file [Apt-cudf] |
|
| parse_cudf [Boilerplate] |
parse a cudf file and return a triple (preamble,package list,request
option).
|
| parse_cudf [BoilerplateNoRpm] |
parse a cudf file and return a triple (preamble,package list,request
option).
|
| parse_e [Packages] |
|
| parse_from_ch [Format822] |
|
| parse_hold [Edsp] |
|
| parse_input [Boilerplate] |
parse a list of uris of the same type and return a cudf packages list
|
| parse_input [BoilerplateNoRpm] |
parse a list of uris of the same type and return a cudf packages list
|
| parse_inst [Apt] |
|
| parse_inst_from_cmd [Apt] |
|
| parse_inst_from_file [Apt] |
|
| parse_installed [Edsp] |
|
| parse_int [Packages] |
|
| parse_int_s [Edsp] |
|
| parse_multiarch [Packages] |
|
| parse_name [Sources] |
|
| parse_name [Packages] |
|
| parse_package_stanza [Sources] |
|
| parse_package_stanza [Packages] |
|
| parse_packages_in [Packages] |
|
| parse_pin [Apt] |
|
| parse_pkg_req [Apt] |
|
| parse_popcon [Apt] |
|
| parse_pref_labels [Apt] |
|
| parse_pref_package [Apt] |
|
| parse_preferences_in [Apt] |
parse the apt_preferences file
|
| parse_preferences_stanza [Apt] |
|
| parse_release_in [Release] |
|
| parse_release_stanza [Release] |
|
| parse_req [Edsp] |
|
| parse_req [Apt] |
|
| parse_request_apt [Apt] |
parse a string containing an apt-get command line
|
| parse_request_aptitude [Apt] |
|
| parse_request_stanza [Edsp] |
|
| parse_s [Edsp] |
|
| parse_s [Sources] |
|
| parse_s [Packages] |
|
| parse_section [Edsp] |
|
| parse_solver_spec [Apt-cudf] |
|
| parse_source [Packages] |
|
| parse_sources_in [Sources] |
parse a debian Sources file from channel
|
| parse_string [Edsp] |
|
| parse_string [Packages] |
|
| parse_uri [Input] |
parse a uri.
|
| parse_version [Sources] |
|
| parse_version [Packages] |
|
| parse_vpkg [Packages] |
|
| parse_vpkgformula [Packages] |
|
| parse_vpkglist [Packages] |
|
| parser_wrapper_ch [Format822] |
|
| pin_regexp [Apt] |
|
| pkgcheck [Depsolver_int] |
|
| pkglist_option [Boilerplate] |
|
| pkglist_option [BoilerplateNoRpm] |
|
| pkgnames [CudfAdd] |
|
| pkgset [Challenged] |
|
| pp [Challenged] |
|
| pp_dependencies [Diagnostic] |
|
| pp_dependency [Diagnostic] |
|
| pp_list [Diagnostic] |
|
| pp_lpos [Format822] |
|
| pp_package [Diagnostic] |
|
| pp_package [CudfAdd] |
|
| pp_pkg [Apt-cudf] |
|
| pp_pkg_list [Apt-cudf] |
|
| pp_pkg_list_tran [Apt-cudf] |
|
| pp_posfname [Format822] |
|
| pp_summary [Diagnostic] |
|
| pp_summary_row [Diagnostic] |
|
| pp_timer [Util.Timer] |
|
| pp_version [CudfAdd] |
|
| pp_versions_table [Boilerplate] |
|
| pp_versions_table [BoilerplateNoRpm] |
|
| pp_vpkglist [Diagnostic] |
|
| preamble [Debcudf] |
declare the Cudf preamble used by cudf.
|
| pred_list [Defaultgraphs.MakePackageGraph] |
|
| pred_set [Defaultgraphs.MakePackageGraph] |
|
| predbar [Challenged] |
|
| preferences_parser [Apt] |
|
| print [Flatten.Formula] |
|
| print [Flatten.Disj] |
|
| print [Flatten.Package] |
|
| print_error [Apt-cudf] |
|
| print_error [Diagnostic] |
|
| print_list [Flatten] |
|
| print_progress [Apt-cudf] |
|
| print_set [Flatten] |
|
| printf [Diagnostic] |
|
| progress [Boilerplate.MakeOptions] |
|
| progress [BoilerplateNoRpm.MakeOptions] |
|
| progress [Util.Progress] |
increment the progress bar of i units
|
| progressbar_init [Depsolver_int] |
progress bar
|
| progressbar_univcheck [Depsolver_int] |
|
| propagate [EdosSolver.T] |
|
| protect [EdosSolver.T] |
|
| pset_map [Flatten] |
|
| pset_of_lst [Flatten] |
|
Q |
| quiet [Boilerplate.MakeOptions] |
|
| quiet [BoilerplateNoRpm.MakeOptions] |
|
R |
| range [Evolution] |
|
| read_deb [Boilerplate] |
read a debian Packages file - compressed or not
|
| read_deb [BoilerplateNoRpm] |
read a debian Packages file - compressed or not
|
| realversionmap [CudfAdd] |
build a hash table that associates (package name, String version) to CUDF packages
|
| reason [Strongconflicts] |
|
| release_parser [Release] |
|
| remove [Flatten.Conflict] |
|
| remove_deps [Flatten] |
|
| remove_redundant_conflicts [Flatten] |
|
| remove_self_conflicts [Flatten] |
|
| repository [Flatten] |
|
| reset [Util.Progress] |
reset the progress bar
|
| reset [EdosSolver.T] |
reset reset the state of the solver to a state that would be obtained
by re initializing the solver with an identical constraints set
|
| resolve_deps [CudfAdd] |
|
| resolve_vpkg_int [CudfAdd] |
|
| resolve_vpkgs_int [CudfAdd] |
|
| reverse_cone [Ceve.Options] |
|
| reverse_dependencies [Depsolver_int] |
reverse_dependencies index return an array that associates to a package id
i the list of all packages ids that have a dependency on i.
|
| reverse_dependencies [Depsolver] |
reverse_dependencies univ compute the reverse dependency list of all
packages in the universe univ
|
| reverse_dependency_closure [Depsolver_int] |
return the dependency closure of the reverse dependency graph.
|
| reverse_dependency_closure [Depsolver] |
reverse_dependencies_closure univ compute the reverse dependency list of all
packages in l in the universe univ
|
| rmtmpdir [Apt-cudf] |
|
| rpm_load_list [Boilerplate] |
transform a list of rpm control stanza into a cudf packages list
|
| rpm_load_list [BoilerplateNoRpm] |
transform a list of rpm control stanza into a cudf packages list
|
| rpm_load_universe [Boilerplate] |
transform a list of rpm control stanza into a cudf universe
|
| rpm_load_universe [BoilerplateNoRpm] |
transform a list of rpm control stanza into a cudf universe
|
S |
| scatteredPlotBoth [Statistics.Make] |
|
| scatteredPlotIn [Statistics.Make] |
|
| scatteredPlotOut [Statistics.Make] |
|
| sctimer [Strongconflicts_int] |
timer
|
| seedingbar [Strongconflicts_int] |
progress bar
|
| sep [Sources] |
|
| set [Flatten.PTbl] |
|
| set_options [Boilerplate.MakeDistribOptions] |
|
| set_options [BoilerplateNoRpm.MakeDistribOptions] |
|
| set_total [Util.Progress] |
set_total bar 10 : set the max width of the progress bar to 10 units
|
| simplify_formula [Flatten] |
|
| solve [Depsolver_int] |
low level call to the sat solver
|
| solve [EdosSolver.T] |
solve st v finds a variable assignment that makes v True
|
| solve_lst [EdosSolver.T] |
solve st l finds a variable assignment that makes True all variables in l
|
| solver [Apt-cudf.Options] |
|
| solver_dir [Apt-cudf] |
|
| somedisj [Strongdeps_int] |
|
| sources2packages [Sources] |
transform a list of sources into dummy packages to be then converted to cudf
|
| split [Version] |
split the debian version into its components.
|
| src [Ceve.Options] |
|
| start [Util.Timer] |
|
| stats [EdosSolver.T] |
|
| status_filter [Packages] |
|
| std_open_file [Input] |
load a non compressed file
|
| stop [Util.Timer] |
|
| str_list_option [Boilerplate] |
|
| str_list_option [BoilerplateNoRpm] |
|
| string_of [CudfAdd] |
|
| string_of_edge [Defaultgraphs.SyntacticDependencyGraph] |
|
| string_of_package [CudfAdd] |
|
| string_of_range [Evolution] |
|
| string_of_version [CudfAdd] |
|
| string_of_vertex [Defaultgraphs.SyntacticDependencyGraph] |
|
| strip [Challenged] |
|
| strip_cudf_pool [Depsolver_int] |
|
| strip_epoch_binnmu [Version] |
return a version without its epoch and without its binNMU part
|
| strip_solver_pool [Depsolver_int] |
|
| strong_depends [Strongdeps_int] |
check if p strongly depends on q.
|
| strongconflicts [Strongconflicts_int] |
|
| strongconflicts [Strongconflicts] |
|
| strongdeps [Strongdeps_int] |
|
| strongdeps [Strongdeps] |
strongdeps u l build the strong dependency graph of all packages in
l wrt the universe u
|
| strongdeps_int [Strongdeps_int] |
strongdeps l build the strong dependency graph of l
|
| strongdeps_univ [Strongdeps_int] |
|
| strongdeps_univ [Strongdeps] |
strongdeps_univ u build the strong dependency graph of
all packages in the universe u
|
| stronglist [Strongdeps_int] |
invariant : we assume the graph is NOT detransitivitized
|
| strongset [Strongdeps_int] |
|
| strongtimer [Strongdeps_int] |
|
| succ_list [Defaultgraphs.MakePackageGraph] |
|
| succ_set [Defaultgraphs.MakePackageGraph] |
|
| successes [Distcheck.Options] |
|
| summary [Outdated.Options] |
|
| summary [Distcheck.Options] |
|
| supported_formats [Boilerplate] |
|
| supported_formats [BoilerplateNoRpm] |
|
| swap [Strongconflicts_int] |
|
| sync [Outdated] |
|
| syscall [Apt-cudf] |
|
T |
| timer [Outdated] |
|
| timer [Distcheck] |
|
| timers [Boilerplate.MakeOptions] |
|
| timers [BoilerplateNoRpm.MakeOptions] |
|
| timestamp [Util] |
|
| to_lit [Flatten.Disj] |
|
| to_lits [Flatten.Disj] |
|
| to_set [Strongconflicts_int] |
|
| to_set [CudfAdd] |
Convert a list of CUDF packages to a set of CUDF packages.
|
| tocudf [Edsp] |
|
| tocudf [Debcudf] |
tocudf tbl p
convert the a debian package representation to cudf.
|
| tr_timer [Defaultgraphs] |
|
| transitive_reduction [Defaultgraphs.GraphOper] |
|
| trbar [Defaultgraphs] |
|
| triangle [Strongconflicts_int] |
|
| trim [Depsolver] |
remove uninstallable packages from the universe
|
U |
| undirect [Statistics.Make] |
|
| undirect [Defaultgraphs.MakePackageGraph] |
|
| unique [CudfAdd] |
|
| univcheck [Depsolver] |
univcheck check if all packages in the universe can be installed.
|
| unpack [Boilerplate] |
return the name of the file
|
| unpack [BoilerplateNoRpm] |
return the name of the file
|
| upgrade [Challenged] |
|
| uuid [Util] |
|
V |
| vartoint [CudfAdd] |
|
| verbose [Boilerplate.MakeOptions] |
|
| verbose [BoilerplateNoRpm.MakeOptions] |
|
| version_of_target [Challenged] |
|
| version_of_target [Outdated] |
|
| vertex_attributes [Defaultgraphs.IntPkgGraph.Display] |
|
| vertex_attributes [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| vertex_attributes [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| vertex_name [Defaultgraphs.IntPkgGraph.Display] |
|
| vertex_name [Defaultgraphs.MakePackageGraph.DisplayF] |
|
| vertex_name [Defaultgraphs.SyntacticDependencyGraph.Display] |
|
| vpkg_option [Boilerplate] |
|
| vpkg_option [BoilerplateNoRpm] |
|
| vpkglist_option [Boilerplate] |
|
| vpkglist_option [BoilerplateNoRpm] |
|
W |
| warning [Util.Logging] |
|
| weaklycomponents [Statistics.Make] |
|
| who_conflicts [CudfAdd] |
|
| who_depends [CudfAdd] |
|
| who_provides [CudfAdd] |
|
| wt [Util.Logging] |
|
Z |
| zdp [Statistics.Make] |
|