rospack.h

Go to the documentation of this file.

/*
 * Copyright (C) 2008, 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

#include <boost/tr1/unordered_set.hpp>
#include <boost/tr1/unordered_map.hpp>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "macros.h"

//#ifdef ROSPACK_API_BACKCOMPAT_V1
#if 1 // def ROSPACK_API_BACKCOMPAT_V1
  #include "rospack/rospack_backcompat.h"
#endif


namespace rospack
{

typedef enum
{
  POSTORDER,
  PREORDER
} traversal_order_t;

// Forward declarations
class Stackage;
class DirectoryCrawlRecord;

class ROSPACK_DECL Rosstackage
{
  private:
    std::string manifest_name_;
    std::string cache_name_;
    bool crawled_;
    std::string name_;
    std::string tag_;
    bool quiet_;
    std::vector<std::string> search_paths_;
    std::tr1::unordered_map<std::string, std::vector<std::string> > dups_;
    std::tr1::unordered_map<std::string, Stackage*> stackages_;
    Stackage* findWithRecrawl(const std::string& name);
    void log(const std::string& level, const std::string& msg, bool append_errno);
    void addStackage(const std::string& path);
    void crawlDetail(const std::string& path,
                     bool force,
                     int depth,
                     bool collect_profile_data,
                     std::vector<DirectoryCrawlRecord*>& profile_data,
                     std::tr1::unordered_set<std::string>& profile_hash);
    bool depsOnDetail(const std::string& name, bool direct,
                      std::vector<Stackage*>& deps, bool ignore_missing=false);
    bool depsDetail(const std::string& name, bool direct,
                    std::vector<Stackage*>& deps);
    bool isStackage(const std::string& path);
    void loadManifest(Stackage* stackage);
    void computeDeps(Stackage* stackage, bool ignore_errors=false, bool ignore_missing=false);
    void computeDepsInternal(Stackage* stackage, bool ignore_errors, const std::string& depend_tag, bool ignore_missing=false);
    bool isSysPackage(const std::string& pkgname);
    void gatherDeps(Stackage* stackage, bool direct,
                    traversal_order_t order,
                    std::vector<Stackage*>& deps,
                    bool no_recursion_on_wet=false);
    void gatherDepsFull(Stackage* stackage, bool direct,
                        traversal_order_t order, int depth,
                        std::tr1::unordered_set<Stackage*>& deps_hash,
                        std::vector<Stackage*>& deps,
                        bool get_indented_deps,
                        std::vector<std::string>& indented_deps,
                        bool no_recursion_on_wet=false);
    std::string getCachePath();
    bool readCache();
    void writeCache();
    FILE* validateCache();
    bool expandExportString(Stackage* stackage,
                            const std::string& instring,
                            std::string& outstring);
    void depsWhyDetail(Stackage* from,
                       Stackage* to,
                       std::list<std::list<Stackage*> >& acc_list);

    void initPython();

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

  public:
    virtual ~Rosstackage();

    virtual const char* usage() { return ""; }
    void crawl(std::vector<std::string> search_path, bool force);
    bool inStackage(std::string& name);
    void setQuiet(bool quiet);
    const std::string& getName() {return name_;}
    bool getSearchPathFromEnv(std::vector<std::string>& sp);
    bool find(const std::string& name, std::string& path);
    bool contents(const std::string& name, std::set<std::string>& packages);
    bool contains(const std::string& name,
                  std::string& stack,
                  std::string& path);

    void list(std::set<std::pair<std::string, std::string> >& list);
    void listDuplicates(std::vector<std::string>& dups);
    void listDuplicatesWithPaths(std::map<std::string, std::vector<std::string> >& dups);
    bool deps(const std::string& name, bool direct, std::vector<std::string>& deps);
    bool depsOn(const std::string& name, bool direct,
                   std::vector<std::string>& deps);
    bool depsManifests(const std::string& name, bool direct,
                       std::vector<std::string>& manifests);
    bool depsMsgSrv(const std::string& name, bool direct,
                    std::vector<std::string>& gens);
    bool depsIndent(const std::string& name, bool direct,
                    std::vector<std::string>& deps);
    bool depsWhy(const std::string& from,
                 const std::string& to,
                 std::string& output);
    bool rosdeps(const std::string& name, bool direct,
                 std::set<std::string>& rosdeps);
    void _rosdeps(Stackage* stackage, std::set<std::string>& rosdeps, const char* tag_name);
    bool vcs(const std::string& name, bool direct,
             std::vector<std::string>& vcs);
    bool cpp_exports(const std::string& name, const std::string& type,
                 const std::string& attrib, bool deps_only,
                 std::vector<std::pair<std::string, bool> >& flags);
    bool reorder_paths(const std::string& paths, std::string& reordered);
    bool exports(const std::string& name, const std::string& lang,
                 const std::string& attrib, bool deps_only,
                 std::vector<std::string>& flags);
    bool exports_dry_package(Stackage* stackage, const std::string& lang,
                         const std::string& attrib,
                         std::vector<std::string>& flags);
    bool plugins(const std::string& name, const std::string& attrib,
                 const std::string& top,
                 std::vector<std::string>& flags);
    bool profile(const std::vector<std::string>& search_path,
                 bool zombie_only,
                 int length,
                 std::vector<std::string>& dirs);
    void logWarn(const std::string& msg,
                 bool append_errno = false);
    void logError(const std::string& msg,
                  bool append_errno = false);
};

class ROSPACK_DECL Rospack : public Rosstackage
{
  public:
    Rospack();
    virtual const char* usage();
};

class ROSPACK_DECL Rosstack : public Rosstackage
{
  public:
    Rosstack();
    virtual const char* usage();
};

} // namespace rospack

#endif