👤
Home Man
Search
Today's Posts
Register

Linux & Unix Commands - Search Man Pages
Man Page or Keyword Search:
Select Section of Man Page:
Select Man Page Repository:

Linux 2.6 - man page for dpkg::deps (linux section 3)

Dpkg::Deps(3)				   libdpkg-perl 			    Dpkg::Deps(3)

NAME
       Dpkg::Deps - parse and manipulate dependencies of Debian packages

DESCRIPTION
       The Dpkg::Deps module provides objects implementing various types of dependencies.

       The most important function is deps_parse(), it turns a dependency line in a set of
       Dpkg::Deps::{Simple,AND,OR,Union} objects depending on the case.

FUNCTIONS
       All the deps_* functions are exported by default.

       deps_eval_implication($rel_p, $v_p, $rel_q, $v_q)
	   ($rel_p, $v_p) and ($rel_q, $v_q) express two dependencies as (relation, version). The
	   relation variable can have the following values that are exported by Dpkg::Version:
	   REL_EQ, REL_LT, REL_LE, REL_GT, REL_GT.

	   This functions returns 1 if the "p" dependency implies the "q" dependency. It returns
	   0 if the "p" dependency implies that "q" is not satisfied. It returns undef when
	   there's no implication.

	   The $v_p and $v_q parameter should be Dpkg::Version objects.

       my $dep = deps_parse($line, %options)
	   This function parse the dependency line and returns an object, either a
	   Dpkg::Deps::AND or a Dpkg::Deps::Union. Various options can alter the behaviour of
	   that function.

	   use_arch (defaults to 1)
	       Take into account the architecture restriction part of the dependencies.  Set to 0
	       to completely ignore that information.

	   host_arch (defaults to the current architecture)
	       Define the host architecture. Needed only if the reduce_arch option is set to 1.
	       By default it uses Dpkg::Arch::get_host_arch() to identify the proper
	       architecture.

	   reduce_arch (defaults to 0)
	       If set to 1, ignore dependencies that do not concern the current host
	       architecture. This implicitely strips off the architecture restriction list so
	       that the resulting dependencies are directly applicable to the current
	       architecture.

	   union (defaults to 0)
	       If set to 1, returns a Dpkg::Deps::Union instead of a Dpkg::Deps::AND. Use this
	       when parsing non-dependency fields like Conflicts.

       deps_compare($a, $b)
	   Implements a comparison operator between two dependency objects.  This function is
	   mainly used to implement the sort() method.

OBJECTS - Dpkg::Deps::*
       There are several kind of dependencies. A Dpkg::Deps::Simple dependency represents a
       single dependency statement (it relates to one package only).  Dpkg::Deps::Multiple
       dependencies are built on top of this object and combine several dependencies in a
       different manners. Dpkg::Deps::AND represents the logical "AND" between dependencies while
       Dpkg::Deps::OR represents the logical "OR". Dpkg::Deps::Multiple objects can contain
       Dpkg::Deps::Simple object as well as other Dpkg::Deps::Multiple objects.

       In practice, the code is only meant to handle the realistic cases which, given Debian's
       dependencies structure, imply those restrictions: AND can contain Simple or OR objects, OR
       can only contain Simple objects.

       Dpkg::Deps::KnowFacts is a special object that is used while evaluating dependencies and
       while trying to simplify them. It represents a set of installed packages along with the
       virtual packages that they might provide.

   Common functions
       $dep->is_empty()
	   Returns true if the dependency is empty and doesn't contain any useful information.
	   This is true when a Dpkg::Deps::Simple object has not yet been initialized or when a
	   (descendant of) Dpkg::Deps::Multiple contains an empty list of dependencies.

       $dep->get_deps()
	   Return a list of sub-dependencies. For Dpkg::Deps::Simple it returns itself.

       $dep->output([$fh])
       "$dep"
	   Return a string representing the dependency. If $fh is set, it prints the string to
	   the filehandle.

       $dep->implies($other_dep)
	   Returns 1 when $dep implies $other_dep. Returns 0 when $dep implies NOT($other_dep).
	   Returns undef when there's no implication. $dep and $other_dep do not need to be of
	   the same type.

       $dep->sort()
	   Sort alphabetically the internal list of dependencies. It's a no-op for
	   Dpkg::Deps::Simple objects.

       $dep->arch_is_concerned($arch)
	   Returns true if the dependency applies to the indicated architecture. For multiple
	   dependencies, it returns true if at least one of the sub-dependencies apply to this
	   architecture.

       $dep->reduce_arch($arch)
	   Simplify the dependency to contain only information relevant to the given
	   architecture. A Dpkg::Deps::Simple object can be left empty after this operation. For
	   Dpkg::Deps::Multiple objects, the non-relevant sub-dependencies are simply removed.

	   This trims off the architecture restriction list of Dpkg::Deps::Simple objects.

       $dep->get_evaluation($facts)
	   Evaluates the dependency given a list of installed packages and a list of virtual
	   packages provided. Those lists are part of the Dpkg::Deps::KnownFacts object given as
	   parameters.

	   Returns 1 when it's true, 0 when it's false, undef when some information is lacking to
	   conclude.

       $dep->simplify_deps($facts, @assumed_deps)
	   Simplify the dependency as much as possible given the list of facts (see object
	   Dpkg::Deps::KnownFacts) and a list of other dependencies that we know to be true.

       $dep->has_arch_restriction()
	   For a simple dependency, returns the package name if the dependency applies only to a
	   subset of architectures.  For multiple dependencies, it returns the list of package
	   names that have such a restriction.

   Dpkg::Deps::Simple
       Such an object has four interesting properties:

       package
	   The package name (can be undef if the dependency has not been initialized or if the
	   simplification of the dependency lead to its removal).

       relation
	   The relational operator: "=", "<<", "<=", ">=" or ">>". It can be undefined if the
	   dependency had no version restriction. In that case the following field is also
	   undefined.

       version
	   The version.

       arches
	   The list of architectures where this dependency is applicable. It's undefined when
	   there's no restriction, otherwise it's an array ref. It can contain an exclusion list,
	   in that case each architecture is prefixed with an exclamation mark.

       Methods

       $simple_dep->parse_string("dpkg-dev (>= 1.14.8) [!hurd-i386]")
	   Parse the dependency and modify internal properties to match the parsed dependency.

       $simple_dep->merge_union($other_dep)
	   Returns true if $simple_dep could be modified to represent the union of both
	   dependencies. Otherwise returns false.

   Dpkg::Deps::Multiple
       This the base class for Dpkg::Deps::{AND,OR,Union}. It contains the

       $mul->add($dep)
	   Add a new dependency object at the end of the list.

   Dpkg::Deps::AND
       This object represents a list of dependencies who must be met at the same time.

       $and->output([$fh])
	   The output method uses ", " to join the list of sub-dependencies.

   Dpkg::Deps::OR
       This object represents a list of dependencies of which only one must be met for the
       dependency to be true.

       $or->output([$fh])
	   The output method uses " | " to join the list of sub-dependencies.

   Dpkg::Deps::Union
       This object represents a list of relationships.

       $union->output([$fh])
	   The output method uses ", " to join the list of relationships.

       $union->implies($other_dep)
       $union->get_evaluation($other_dep)
	   Those methods are not meaningful for this object and always return undef.

       $union->simplify_deps($facts)
	   The simplication is done to generate an union of all the relationships.  It uses
	   $simple_dep->merge_union($other_dep) to get the its job done.

   Dpkg::Deps::KnowFacts
       This object represents a list of installed packages and a list of virtual packages
       provided (by the set of installed packages).

       my $facts = Dpkg::Deps::KnownFacts->new();
	   Create a new object.

       $facts->add_installed_package($package, $version)
	   Record that the given version of the package is installed. If $version is undefined we
	   know that the package is installed but we don't know which version it is.

       $facts->add_provided_package($virtual, $relation, $version, $by)
	   Record that the "$by" package provides the $virtual package. $relation and $version
	   correspond to the associated relation given in the Provides field. This might be used
	   in the future for versioned provides.

       my ($check, $param) = $facts->check_package($package)
	   $check is one when the package is found. For a real package, $param contains the
	   version. For a virtual package, $param contains an array reference containing the list
	   of packages that provide it (each package is listed as [ $provider, $relation,
	   $version ]).

1.16.0.3				    2012-04-17				    Dpkg::Deps(3)


All times are GMT -4. The time now is 01:58 AM.

Unix & Linux Forums Content Copyrightę1993-2018. All Rights Reserved.
×
UNIX.COM Login
Username:
Password:  
Show Password