librospack
Public Member Functions | Protected Member Functions | List of all members
rospack::Rosstackage Class Reference

The base class for package/stack ("stackage") crawlers. Users of the library should use the functionality provided here through one of the derived classes, Rosstack or Rospack. More...

#include <rospack.h>

Inheritance diagram for rospack::Rosstackage:
rospack::Rospack rospack::Rosstack

Public Member Functions

virtual ~Rosstackage ()
 Destructor.
 
virtual const char * usage ()
 Usage string, to be overridden by derived classes. More...
 
void crawl (std::vector< std::string > search_path, bool force)
 Crawl the filesystem, accumulating a database of stackages. May read results from a cache file instead of crawling. This method should be called before any making any queries (find, list, etc.). More...
 
bool inStackage (std::string &name)
 Is the current working directory a stackage? More...
 
void setQuiet (bool quiet)
 Control warning and error console output. More...
 
const std::string & getName ()
 Get the name of the tool that's in use (e.g., "rospack" or "rosstack") More...
 
bool getSearchPathFromEnv (std::vector< std::string > &sp)
 Helper method to construct a directory search path by looking at relevant environment variables. The value of ROS_ROOT goes first, followed by each element of a colon-separated ROS_PACKAGE_PATH. More...
 
bool find (const std::string &name, std::string &path)
 Look for a stackage. More...
 
bool contents (const std::string &name, std::set< std::string > &packages)
 Compute the packages that are contained in a stack. More...
 
bool contains (const std::string &name, std::string &stack, std::string &path)
 Find the stack that contains a package. More...
 
void list (std::set< std::pair< std::string, std::string > > &list)
 List names and paths of all stackages. More...
 
void listDuplicates (std::vector< std::string > &dups)
 Identify duplicate stackages. Forces crawl. More...
 
bool deps (const std::string &name, bool direct, std::vector< std::string > &deps)
 Compute dependencies of a stackage (i.e., stackages that this stackages depends on). More...
 
bool depsOn (const std::string &name, bool direct, std::vector< std::string > &deps)
 Compute reverse dependencies of a stackage (i.e., stackages that depend on this stackage). Forces crawl. More...
 
bool depsManifests (const std::string &name, bool direct, std::vector< std::string > &manifests)
 List the manifests of a stackage's dependencies. Used by rosbuild. More...
 
bool depsMsgSrv (const std::string &name, bool direct, std::vector< std::string > &gens)
 List the marker files in a packages's dependencies that indicate that those packages contain auto-generated message and/or service code. Used by rosbuild. More...
 
bool depsIndent (const std::string &name, bool direct, std::vector< std::string > &deps)
 Generate indented list of a stackage's dependencies, including duplicates. Intended for visual debugging of dependency structures. More...
 
bool depsWhy (const std::string &from, const std::string &to, std::string &output)
 Compute all dependency chains from one stackage to another. Intended for visual debugging of dependency structures. More...
 
bool rosdeps (const std::string &name, bool direct, std::set< std::string > &rosdeps)
 Compute rosdep entries that are declared in manifest of a package and its dependencies. Used by rosmake. More...
 
bool vcs (const std::string &name, bool direct, std::vector< std::string > &vcs)
 Compute vcs entries that are declared in manifest of a package and its dependencies. Was used by Hudson build scripts; might not be needed. More...
 
bool exports (const std::string &name, const std::string &lang, const std::string &attrib, bool deps_only, std::vector< std::string > &flags)
 Compute exports declared in a package and its dependencies. Used by rosbuild. More...
 
bool plugins (const std::string &name, const std::string &attrib, const std::string &top, std::vector< std::string > &flags)
 Compute exported plugins declared in packages that depend on a package. Forces crawl. Used by rosbuild and roslib. More...
 
bool profile (const std::vector< std::string > &search_path, bool zombie_only, int length, std::vector< std::string > &dirs)
 Report on time taken to crawl for stackages. Intended for use in debugging misconfigured stackage trees. Forces crawl. More...
 
void logWarn (const std::string &msg, bool append_errno=false)
 Log a warning (usually goes to stderr). More...
 
void logError (const std::string &msg, bool append_errno=false)
 Log a error (usually goes to stderr). More...
 

Protected Member Functions

 Rosstackage (const std::string &manifest_name, const std::string &cache_name, const std::string &name, const std::string &tag)
 Constructor, only used by derived classes. More...
 

Detailed Description

The base class for package/stack ("stackage") crawlers. Users of the library should use the functionality provided here through one of the derived classes, Rosstack or Rospack.

Constructor & Destructor Documentation

rospack::Rosstackage::Rosstackage ( const std::string &  manifest_name,
const std::string &  cache_name,
const std::string &  name,
const std::string &  tag 
)
protected

Constructor, only used by derived classes.

Parameters
manifest_nameWhat the manifest is called (e.g., "manifest.xml or stack.xml")
cache_nameWhat the cache is called (e.g., "rospack_cache" or "rosstack_cache")
nameName of the tool we're building (e.g., "rospack" or "rosstack")
tagName of the attribute we look for in a "depend" tag in a manifest (e.g., "package" or "stack")

Member Function Documentation

bool rospack::Rosstackage::contains ( const std::string &  name,
std::string &  stack,
std::string &  path 
)

Find the stack that contains a package.

Parameters
nameThe package to work on.
stackIf the containing stack is found, its name is written here.
pathIf the containing stack is found, its absolute path is written here.
Returns
True if the containing stack could be found, false otherwise.
bool rospack::Rosstackage::contents ( const std::string &  name,
std::set< std::string > &  packages 
)

Compute the packages that are contained in a stack.

Parameters
nameThe stack to work on.
packagesThe stack's constituent packages are written here.
Returns
True if the contents could be computed, false otherwise.
void rospack::Rosstackage::crawl ( std::vector< std::string >  search_path,
bool  force 
)

Crawl the filesystem, accumulating a database of stackages. May read results from a cache file instead of crawling. This method should be called before any making any queries (find, list, etc.).

Parameters
search_pathList of directories to crawl, in precenence order. Directories should be absolute paths. It's passed by value to allow callers (e.g., find()) to safely pass in search_paths_.
forceIf true, then crawl even if the cache looks valid
bool rospack::Rosstackage::deps ( const std::string &  name,
bool  direct,
std::vector< std::string > &  deps 
)

Compute dependencies of a stackage (i.e., stackages that this stackages depends on).

Parameters
nameThe stackage to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
depsIf dependencies are computed, then they're written here.
Returns
True if dependencies were computed, false otherwise.
bool rospack::Rosstackage::depsIndent ( const std::string &  name,
bool  direct,
std::vector< std::string > &  deps 
)

Generate indented list of a stackage's dependencies, including duplicates. Intended for visual debugging of dependency structures.

Parameters
nameThe stackage to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
depsList of the stackage's dependencies, with leading spaces to indicate depth, is written here. Print this list to console, with newlines separating each element. Example output:
roscpp_traits
  cpp_common
cpp_common
rostime
  cpp_common
Returns
True if the indented dependencies were computed, false otherwise.
bool rospack::Rosstackage::depsManifests ( const std::string &  name,
bool  direct,
std::vector< std::string > &  manifests 
)

List the manifests of a stackage's dependencies. Used by rosbuild.

Parameters
nameThe stackage to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
manifestsThe list of absolute paths to manifests of stackages that the given stackage depends on is written here.
Returns
True if the manifest list was computed, false otherwise.
bool rospack::Rosstackage::depsMsgSrv ( const std::string &  name,
bool  direct,
std::vector< std::string > &  gens 
)

List the marker files in a packages's dependencies that indicate that those packages contain auto-generated message and/or service code. Used by rosbuild.

Parameters
nameThe package to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
gensThe list of absolute paths to marker files (e.g., "/opt/ros/electric/stacks/ros_comm/messages/std_msgs/msg_gen/generated") is written here.
Returns
True if the list of files was generated, false otherwise.
bool rospack::Rosstackage::depsOn ( const std::string &  name,
bool  direct,
std::vector< std::string > &  deps 
)

Compute reverse dependencies of a stackage (i.e., stackages that depend on this stackage). Forces crawl.

Parameters
nameThe stackage to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
depsIf dependencies are computed, then they're written here.
Returns
True if dependencies were computed, false otherwise.
bool rospack::Rosstackage::depsWhy ( const std::string &  from,
const std::string &  to,
std::string &  output 
)

Compute all dependency chains from one stackage to another. Intended for visual debugging of dependency structures.

Parameters
fromThe stackage that depends on.
toThe stackage that is depended on.
outputA list of dependency chains. Print this list to console, with newlines separating each element. Example output:
Dependency chains from roscpp to roslib:
* roscpp -> roslib
* roscpp -> std_msgs -> roslib
* roscpp -> rosgraph_msgs -> std_msgs -> roslib
Returns
True if the dependency chains were computed, false otherwise.
bool rospack::Rosstackage::exports ( const std::string &  name,
const std::string &  lang,
const std::string &  attrib,
bool  deps_only,
std::vector< std::string > &  flags 
)

Compute exports declared in a package and its dependencies. Used by rosbuild.

Parameters
nameThe package to work on.
langThe value of the 'lang' attribute to search for.
attribThe value of the 'attrib' attribute to search for.
deps_onlyIf true, then only return information from the pacakge's dependencies; if false, then also include the package's own export information.
flagsThe accumulated flags are written here.
Returns
True if the flags were computed, false otherwise.
bool rospack::Rosstackage::find ( const std::string &  name,
std::string &  path 
)

Look for a stackage.

Parameters
nameThe stackage to look for.
pathIf found, the absolute path to the stackage is written here.
Returns
True if the stackage is found, false otherwise.
const std::string& rospack::Rosstackage::getName ( )
inline

Get the name of the tool that's in use (e.g., "rospack" or "rosstack")

Returns
The name of the tool.
bool rospack::Rosstackage::getSearchPathFromEnv ( std::vector< std::string > &  sp)

Helper method to construct a directory search path by looking at relevant environment variables. The value of ROS_ROOT goes first, followed by each element of a colon-separated ROS_PACKAGE_PATH.

Parameters
spThe computed search path is written here.
Returns
True if a search path was computed, false otherwise (e.g., ROS_ROOT not set).
bool rospack::Rosstackage::inStackage ( std::string &  name)

Is the current working directory a stackage?

Parameters
nameIf in a stackage, then the stackage's name is written here.
Returns
True if the current working directory contains a manifest file
void rospack::Rosstackage::list ( std::set< std::pair< std::string, std::string > > &  list)

List names and paths of all stackages.

Parameters
listPairs of (name,path) are written here.
void rospack::Rosstackage::listDuplicates ( std::vector< std::string > &  dups)

Identify duplicate stackages. Forces crawl.

Parameters
dupsNames of stackages that are found more than once while crawling are written here.
void rospack::Rosstackage::logError ( const std::string &  msg,
bool  append_errno = false 
)

Log a error (usually goes to stderr).

Parameters
msgThe error.
append_errnoIf true, then append a colon, a space, and the return from 'sterror(errno)'.
void rospack::Rosstackage::logWarn ( const std::string &  msg,
bool  append_errno = false 
)

Log a warning (usually goes to stderr).

Parameters
msgThe warning.
append_errnoIf true, then append a colon, a space, and the return from 'sterror(errno)'.
bool rospack::Rosstackage::plugins ( const std::string &  name,
const std::string &  attrib,
const std::string &  top,
std::vector< std::string > &  flags 
)

Compute exported plugins declared in packages that depend on a package. Forces crawl. Used by rosbuild and roslib.

Parameters
nameThe package to work on.
attribThe value of the 'attrib' attribute to search for.
topIf non-empty, then limit the reverse dependency search to packages that 'top' depends on. Otherwise, examine all packages that depend on 'name'.
flagsThe accumulated flags are written here.
Returns
True if the flags were computed, false otherwise.
bool rospack::Rosstackage::profile ( const std::vector< std::string > &  search_path,
bool  zombie_only,
int  length,
std::vector< std::string > &  dirs 
)

Report on time taken to crawl for stackages. Intended for use in debugging misconfigured stackage trees. Forces crawl.

Parameters
search_pathDirectories to search; passed to crawl().
zombie_onlyIf false, then produce formatted output, with timing information. Example output:
Full tree crawl took 0.014954 seconds.
Directories marked with (*) contain no manifest.  You may
want to delete these directories.
To get just of list of directories without manifests,
re-run the profile with --zombie-only
-------------------------------------------------------------
0.013423   /opt/ros/electric/stacks
0.002989   /opt/ros/electric/stacks/ros_comm
If true, then produce a list of absolute paths that contain no stackages ("zombies"); these directories can likely be safely deleted. Example output:
/opt/ros/electric/stacks/pr2_controllers/trajectory_msgs
/opt/ros/electric/stacks/pr2_controllers/trajectory_msgs/msg
lengthLimit on how many directories to include in report (ordered in decreasing order of time taken to crawl).
dirsProfile output. Print this list to console, with newlines separating each element.
bool rospack::Rosstackage::rosdeps ( const std::string &  name,
bool  direct,
std::set< std::string > &  rosdeps 
)

Compute rosdep entries that are declared in manifest of a package and its dependencies. Used by rosmake.

Parameters
nameThe package to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
rosdepsList of rosdep entries found in the package and its dependencies is written here.
Returns
True if the rosdep list is computed, false otherwise.
void rospack::Rosstackage::setQuiet ( bool  quiet)

Control warning and error console output.

Parameters
quietIf true, then don't output any warnings or errors to console. If false, then output warnings and errors to stderr (default behavior).
virtual const char* rospack::Rosstackage::usage ( )
inlinevirtual

Usage string, to be overridden by derived classes.

Returns
Command-line usage statement.

Reimplemented in rospack::Rosstack, and rospack::Rospack.

bool rospack::Rosstackage::vcs ( const std::string &  name,
bool  direct,
std::vector< std::string > &  vcs 
)

Compute vcs entries that are declared in manifest of a package and its dependencies. Was used by Hudson build scripts; might not be needed.

Parameters
nameThe package to work on.
directIf true, then compute only direct dependencies. If false, then compute full (including indirect) dependencies.
vcsList of vcs entries found in the package and its dependencies is written here.
Returns
True if the vcs list is computed, false otherwise.

The documentation for this class was generated from the following file: