rospack.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008, Morgan Quigley and Willow Garage, Inc.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *   * Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *   * Neither the names of Stanford University or Willow Garage, Inc. nor the names of its
 *     contributors may be used to endorse or promote products derived from
 *     this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef ROSPACK_ROSPACK_H
#define ROSPACK_ROSPACK_H

/* Author: Morgan Quigley, Brian Gerkey */

#if defined(WIN32)
  #if defined(ROS_STATIC)
    #define ROSPACK_EXPORT
  #elif defined(rospack_EXPORTS)
    #define ROSPACK_EXPORT __declspec(dllexport)
  #else
    #define ROSPACK_EXPORT __declspec(dllimport)
  #endif
#else
  #define ROSPACK_EXPORT
#endif

#include <string>
#include <vector>
#include <list>

#include "tinyxml-2.5.3/tinyxml.h"

namespace rospack
{

class Package;
// global helper functions
void string_split(const std::string &s, std::vector<std::string> &t, const std::string &d);
bool file_exists(const std::string &fname);
extern const char *fs_delim;
Package *g_get_pkg(const std::string &name);

typedef std::vector<Package *> VecPkg;
typedef std::list<Package*> Acc;
typedef std::list<Acc> AccList;

class ROSPACK_EXPORT Package
{
public:
  enum traversal_order_t { POSTORDER, PREORDER };
  std::string name, path;
  // These will cause warnings on Windows when compiling the DLL because they
  // are static. They should more correctly be accessed via accessor functions
  // that are exported from the class, rather than directly, in order to
  // "prevent data corruption." Since main.cpp is currently the only known
  // client and it doesn't use them, I'm not caring about the warnings yet.
  static std::vector<Package *> pkgs;
  static std::vector<Package *> deleted_pkgs;

  Package(std::string _path);
  static bool is_package(std::string path);
  static bool is_no_subdirs(std::string path);  
  const VecPkg &deps1();
  const VecPkg &deps(traversal_order_t order, int depth=0);
  std::string manifest_path();
  std::string flags(std::string lang, std::string attrib);
  std::string rosdep();
  std::string versioncontrol();
  std::vector<std::pair<std::string, std::string> > plugins();
  VecPkg descendants1();
  const std::vector<Package *> &descendants(int depth=0);
  TiXmlElement *manifest_root();
  void accumulate_deps(AccList& acc_list, Package* to);

  std::string cpp_message_flags(bool cflags, bool lflags);


private:
  bool deps_calculated, direct_deps_calculated, descendants_calculated;
  std::vector<Package *> _deps, _direct_deps, _descendants;
  TiXmlDocument manifest;
  bool manifest_loaded;

  Package(const Package &p) { } // just override the default public one
  
  bool has_parent(std::string pkg);
  const std::vector<Package *> &direct_deps(bool missing_pkg_as_warning=false);
  std::string direct_flags(std::string lang, std::string attrib);
  void load_manifest();
};

class ROSPACK_EXPORT ROSPack
{
public:
  static const char* usage();

  char *ros_root;
  
  ROSPack();

  ~ROSPack();

  Package *get_pkg(std::string pkgname);
  
  int cmd_depends_on(bool include_indirect);

  int cmd_depends_why();

  int cmd_find();

  int cmd_deps();

  int cmd_depsindent(Package* pkg, int indent);

  int cmd_deps_manifests();
  int cmd_deps_msgsrv();

  int cmd_deps1();

  /*
  int cmd_predeps(char **args, int args_len);
  */

  std::string snarf_libs(std::string flags, bool invert=false);
  std::string snarf_flags(std::string flags, std::string token, bool invert=false);

  int cmd_libs_only(std::string token);

  int cmd_cflags_only(std::string token);

  int cmd_make(char **args, int args_len);

  void export_flags(std::string pkg, std::string lang, std::string attrib);

  int cmd_versioncontrol(int depth);

  int cmd_rosdep(int depth);

  int cmd_export();

  int cmd_plugins();

  int run(int argc, char **argv);

  // Another form of run, which takes the arguments as a single string.
  // WARNING: this method does naive string-splitting on spaces.
  int run(const std::string& cmd);
  
  // Get the accumulated output
  std::string getOutput() { return output_acc; }

  // is -q (quiet) provided ?
  bool is_quiet() { return opt_quiet; }

  int cmd_print_package_list(bool print_path);
  
  int cmd_list_duplicates();

  int cmd_print_langs_list();
  
  void crawl_for_packages(bool force_crawl = false);
  VecPkg partial_crawl(const std::string &path);

  // Exposed for testing purposes only
  std::string deduplicate_tokens(const std::string& s);

  // Storage for --foo options
  // --deps-only
  bool opt_deps_only;
  // --lang=
  std::string opt_lang;
  // --attrib=
  std::string opt_attrib;
  // --length=
  std::string opt_length;
  // --top=
  std::string opt_top;
  // The package name
  std::string opt_package;
  // --target=
  std::string opt_target;
  // the number of entries to list in the profile table
  int opt_profile_length;
  // only display zombie directories in profile?
  bool opt_profile_zombie_only;
  // display warnings about missing dependencies?
  bool opt_warn_on_missing_deps;
  // display pairs of duplicate packages?
  bool opt_display_duplicate_pkgs;

private:
  // is quiet
  bool opt_quiet;
  bool cache_lock_failed;
  bool crawled;
  std::string getCachePath();
  // Storage for list of path components, used in add_package.  We keep it
  // here to avoid reallocation in every run of add_package.
  std::vector<std::string> path_components;
  // Add package, filtering out duplicates.
  Package* add_package(std::string path);
  bool cache_is_good();
  static double time_since_epoch();
  void sanitize_rppvec(std::vector<std::string> &rppvec);
  // Output accumulates here
  std::string output_acc;
  // A place to store heap-allocated argv, in case we were passed a
  // std::string in run().  It'll be freed on destruction.
  int my_argc;
  char** my_argv;
  void freeArgv();
  // Total number of packages found, including duplicates.  Used in
  // determining whether a directory is a zombie.
  int total_num_pkgs;
  // Were there any duplicate pkgs found in the crawl?
  bool duplicate_packages_found;
};

}

#endif

---

rospack
Author(s): Morgan Quigley, Brian Gerkey
autogenerated on Fri Jan 11 09:35:28 2013