Attachment #492910 for bug #629900

View | Details | Raw Unified | Return to bug 629900
Collapse All | Expand All




#ifndef ROSPACK_ROSPACK_H
#define ROSPACK_ROSPACK_H

#include <boost/unordered_set.hpp>
#include <boost/unordered_map.hpp>
#include <list>
#include <map>
#include <set>

    std::string tag_;
    bool quiet_;
    std::vector<std::string> search_paths_;
    boost::unordered_map<std::string, std::vector<std::string> > dups_;
    boost::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 clearStackages();

                     int depth,
                     bool collect_profile_data,
                     std::vector<DirectoryCrawlRecord*>& profile_data,
                     boost::unordered_set<std::string>& profile_hash);
    bool isStackage(const std::string& path);
    void loadManifest(Stackage* stackage);
    void computeDeps(Stackage* stackage, bool ignore_errors=false, bool ignore_missing=false);

                    bool no_recursion_on_wet=false);
    void gatherDepsFull(Stackage* stackage, bool direct,
                        traversal_order_t order, int depth,
                        boost::unordered_set<Stackage*>& deps_hash,
                        std::vector<Stackage*>& deps,
                        bool get_indented_deps,
                        std::vector<std::string>& indented_deps,





void Rosstackage::clearStackages()
{
  for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
      it != stackages_.end();
      ++it)
  {

  search_paths_ = search_path;

  std::vector<DirectoryCrawlRecord*> dummy;
  boost::unordered_set<std::string> dummy2;
  for(std::vector<std::string>::const_iterator p = search_paths_.begin();
      p != search_paths_.end();
      ++p)

                      std::set<std::string>& packages)
{
  Rospack rp2;
  boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);
  if(it != stackages_.end())
  {
    std::vector<std::string> search_paths;

                      std::string& path)
{
  Rospack rp2;
  for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
      it != stackages_.end();
      ++it)
  {

void
Rosstackage::list(std::set<std::pair<std::string, std::string> >& list)
{
  for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
      it != stackages_.end();
      ++it)
  {

{
  dups.resize(dups_.size());
  int i = 0;
  for(boost::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();
      it != dups_.end();
      ++it)
  {

Rosstackage::listDuplicatesWithPaths(std::map<std::string, std::vector<std::string> >& dups)
{
  dups.clear();
  for(boost::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();
      it != dups_.end();
      ++it)
  {

  {
    computeDeps(stackage);
    std::vector<Stackage*> deps_vec;
    boost::unordered_set<Stackage*> deps_hash;
    std::vector<std::string> indented_deps;
    gatherDepsFull(stackage, direct, POSTORDER, 0, deps_hash, deps_vec, true, indented_deps);
    for(std::vector<std::string>::const_iterator it = indented_deps.begin();

  if(!depsOnDetail(name, true, stackages, true))
    return false;
  // Also look in the package itself
  boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);
  if(it != stackages_.end())
  {
    // don't warn here; it was done in depsOnDetail()

    std::vector<Stackage*> top_deps;
    if(!depsDetail(top, false, top_deps))
      return false;
    boost::unordered_set<Stackage*> top_deps_set;
    for(std::vector<Stackage*>::iterator it = top_deps.begin();
        it != top_deps.end();
        ++it)

  }
  try
  {
    for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
        it != stackages_.end();
        ++it)
    {

{
  double start = time_since_epoch();
  std::vector<DirectoryCrawlRecord*> dcrs;
  boost::unordered_set<std::string> dcrs_hash;
  for(std::vector<std::string>::const_iterator p = search_path.begin();
      p != search_path.end();
      ++p)

                         int depth,
                         bool collect_profile_data,
                         std::vector<DirectoryCrawlRecord*>& profile_data,
                         boost::unordered_set<std::string>& profile_hash)
{
  if(depth > MAX_CRAWL_DEPTH)
    throw Exception("maximum depth exceeded during crawl");

                        std::vector<Stackage*>& deps,
                        bool no_recursion_on_wet)
{
  boost::unordered_set<Stackage*> deps_hash;
  std::vector<std::string> indented_deps;
  gatherDepsFull(stackage, direct, order, 0,
                 deps_hash, deps, false, indented_deps, no_recursion_on_wet);

void
_gatherDepsFull(Stackage* stackage, bool direct,
                            traversal_order_t order, int depth,
                            boost::unordered_set<Stackage*>& deps_hash,
                            std::vector<Stackage*>& deps,
                            bool get_indented_deps,
                            std::vector<std::string>& indented_deps,

void
Rosstackage::gatherDepsFull(Stackage* stackage, bool direct,
                            traversal_order_t order, int depth,
                            boost::unordered_set<Stackage*>& deps_hash,
                            std::vector<Stackage*>& deps,
                            bool get_indented_deps,
                            std::vector<std::string>& indented_deps,

      {
        char *rpp = getenv("ROS_PACKAGE_PATH");
        fprintf(cache, "#ROS_PACKAGE_PATH=%s\n", (rpp ? rpp : ""));
        for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
            it != stackages_.end();
            ++it)
          fprintf(cache, "%s\n", it->second->path_.c_str());

Lines 28-34 Link Here

(-)a/src/utils.cpp (-2 / +2 lines)
28	#include <string>	28	#include <string>
29	#include <vector>	29	#include <vector>
30	#include <boost/algorithm/string.hpp>	30	#include <boost/algorithm/string.hpp>
31	#include <boost/tr1/unordered_set.hpp>	31	#include <boost/unordered_set.hpp>
32		32
33	#include "utils.h"	33	#include "utils.h"
34		34
Lines 41-47 deduplicate_tokens(const std::string& instring, Link Here
41	std::string& outstring)	41	std::string& outstring)
42	{	42	{
43	std::vector<std::string> vec;	43	std::vector<std::string> vec;
44	std::tr1::unordered_set<std::string> set;	44	boost::unordered_set<std::string> set;
45	boost::split(vec, instring,	45	boost::split(vec, instring,
46	boost::is_any_of("\t "),	46	boost::is_any_of("\t "),
47	boost::token_compress_on);	47	boost::token_compress_on);

Return to bug 629900

Lines 105-112 and Rosstack. Link Here

(-)a/include/rospack/rospack.h (-6 / +6 lines)
105	#ifndef ROSPACK_ROSPACK_H	105	#ifndef ROSPACK_ROSPACK_H
106	#define ROSPACK_ROSPACK_H	106	#define ROSPACK_ROSPACK_H
107		107
108	#include <boost/tr1/unordered_set.hpp>	108	#include <boost/unordered_set.hpp>
109	#include <boost/tr1/unordered_map.hpp>	109	#include <boost/unordered_map.hpp>
110	#include <list>	110	#include <list>
111	#include <map>	111	#include <map>
112	#include <set>	112	#include <set>
Lines 148-155 class ROSPACK_DECL Rosstackage Link Here
148	std::string tag_;	148	std::string tag_;
149	bool quiet_;	149	bool quiet_;
150	std::vector<std::string> search_paths_;	150	std::vector<std::string> search_paths_;
151	std::tr1::unordered_map<std::string, std::vector<std::string> > dups_;	151	boost::unordered_map<std::string, std::vector<std::string> > dups_;
152	std::tr1::unordered_map<std::string, Stackage*> stackages_;	152	boost::unordered_map<std::string, Stackage*> stackages_;
153	Stackage* findWithRecrawl(const std::string& name);	153	Stackage* findWithRecrawl(const std::string& name);
154	void log(const std::string& level, const std::string& msg, bool append_errno);	154	void log(const std::string& level, const std::string& msg, bool append_errno);
155	void clearStackages();	155	void clearStackages();
Lines 159-165 class ROSPACK_DECL Rosstackage Link Here
159	int depth,	159	int depth,
160	bool collect_profile_data,	160	bool collect_profile_data,
161	std::vector<DirectoryCrawlRecord*>& profile_data,	161	std::vector<DirectoryCrawlRecord*>& profile_data,
162	std::tr1::unordered_set<std::string>& profile_hash);	162	boost::unordered_set<std::string>& profile_hash);
163	bool isStackage(const std::string& path);	163	bool isStackage(const std::string& path);
164	void loadManifest(Stackage* stackage);	164	void loadManifest(Stackage* stackage);
165	void computeDeps(Stackage* stackage, bool ignore_errors=false, bool ignore_missing=false);	165	void computeDeps(Stackage* stackage, bool ignore_errors=false, bool ignore_missing=false);
Lines 171-177 class ROSPACK_DECL Rosstackage Link Here
171	bool no_recursion_on_wet=false);	171	bool no_recursion_on_wet=false);
172	void gatherDepsFull(Stackage* stackage, bool direct,	172	void gatherDepsFull(Stackage* stackage, bool direct,
173	traversal_order_t order, int depth,	173	traversal_order_t order, int depth,
174	std::tr1::unordered_set<Stackage*>& deps_hash,	174	boost::unordered_set<Stackage*>& deps_hash,
175	std::vector<Stackage*>& deps,	175	std::vector<Stackage*>& deps,
176	bool get_indented_deps,	176	bool get_indented_deps,
177	std::vector<std::string>& indented_deps,	177	std::vector<std::string>& indented_deps,

Lines 259-265 Rosstackage::~Rosstackage() Link Here

(-)a/src/rospack.cpp (-17 / +17 lines)
259		259
260	void Rosstackage::clearStackages()	260	void Rosstackage::clearStackages()
261	{	261	{
262	for(std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();	262	for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
263	it != stackages_.end();	263	it != stackages_.end();
264	++it)	264	++it)
265	{	265	{
Lines 382-388 Rosstackage::crawl(std::vector<std::string> search_path, Link Here
382	search_paths_ = search_path;	382	search_paths_ = search_path;
383		383
384	std::vector<DirectoryCrawlRecord*> dummy;	384	std::vector<DirectoryCrawlRecord*> dummy;
385	std::tr1::unordered_set<std::string> dummy2;	385	boost::unordered_set<std::string> dummy2;
386	for(std::vector<std::string>::const_iterator p = search_paths_.begin();	386	for(std::vector<std::string>::const_iterator p = search_paths_.begin();
387	p != search_paths_.end();	387	p != search_paths_.end();
388	++p)	388	++p)
Lines 447-453 Rosstackage::contents(const std::string& name, Link Here
447	std::set<std::string>& packages)	447	std::set<std::string>& packages)
448	{	448	{
449	Rospack rp2;	449	Rospack rp2;
450	std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);	450	boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);
451	if(it != stackages_.end())	451	if(it != stackages_.end())
452	{	452	{
453	std::vector<std::string> search_paths;	453	std::vector<std::string> search_paths;
Lines 474-480 Rosstackage::contains(const std::string& name, Link Here
474	std::string& path)	474	std::string& path)
475	{	475	{
476	Rospack rp2;	476	Rospack rp2;
477	for(std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();	477	for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
478	it != stackages_.end();	478	it != stackages_.end();
479	++it)	479	++it)
480	{	480	{
Lines 503-509 Rosstackage::contains(const std::string& name, Link Here
503	void	503	void
504	Rosstackage::list(std::set<std::pair<std::string, std::string> >& list)	504	Rosstackage::list(std::set<std::pair<std::string, std::string> >& list)
505	{	505	{
506	for(std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();	506	for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
507	it != stackages_.end();	507	it != stackages_.end();
508	++it)	508	++it)
509	{	509	{
Lines 519-525 Rosstackage::listDuplicates(std::vector<std::string>& dups) Link Here
519	{	519	{
520	dups.resize(dups_.size());	520	dups.resize(dups_.size());
521	int i = 0;	521	int i = 0;
522	for(std::tr1::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();	522	for(boost::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();
523	it != dups_.end();	523	it != dups_.end();
524	++it)	524	++it)
525	{	525	{
Lines 532-538 void Link Here
532	Rosstackage::listDuplicatesWithPaths(std::map<std::string, std::vector<std::string> >& dups)	532	Rosstackage::listDuplicatesWithPaths(std::map<std::string, std::vector<std::string> >& dups)
533	{	533	{
534	dups.clear();	534	dups.clear();
535	for(std::tr1::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();	535	for(boost::unordered_map<std::string, std::vector<std::string> >::const_iterator it = dups_.begin();
536	it != dups_.end();	536	it != dups_.end();
537	++it)	537	++it)
538	{	538	{
Lines 598-604 Rosstackage::depsIndent(const std::string& name, bool direct, Link Here
598	{	598	{
599	computeDeps(stackage);	599	computeDeps(stackage);
600	std::vector<Stackage*> deps_vec;	600	std::vector<Stackage*> deps_vec;
601	std::tr1::unordered_set<Stackage*> deps_hash;	601	boost::unordered_set<Stackage*> deps_hash;
602	std::vector<std::string> indented_deps;	602	std::vector<std::string> indented_deps;
603	gatherDepsFull(stackage, direct, POSTORDER, 0, deps_hash, deps_vec, true, indented_deps);	603	gatherDepsFull(stackage, direct, POSTORDER, 0, deps_hash, deps_vec, true, indented_deps);
604	for(std::vector<std::string>::const_iterator it = indented_deps.begin();	604	for(std::vector<std::string>::const_iterator it = indented_deps.begin();
Lines 1089-1095 Rosstackage::plugins(const std::string& name, const std::string& attrib, Link Here
1089	if(!depsOnDetail(name, true, stackages, true))	1089	if(!depsOnDetail(name, true, stackages, true))
1090	return false;	1090	return false;
1091	// Also look in the package itself	1091	// Also look in the package itself
1092	std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);	1092	boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.find(name);
1093	if(it != stackages_.end())	1093	if(it != stackages_.end())
1094	{	1094	{
1095	// don't warn here; it was done in depsOnDetail()	1095	// don't warn here; it was done in depsOnDetail()
Lines 1102-1108 Rosstackage::plugins(const std::string& name, const std::string& attrib, Link Here
1102	std::vector<Stackage*> top_deps;	1102	std::vector<Stackage*> top_deps;
1103	if(!depsDetail(top, false, top_deps))	1103	if(!depsDetail(top, false, top_deps))
1104	return false;	1104	return false;
1105	std::tr1::unordered_set<Stackage*> top_deps_set;	1105	boost::unordered_set<Stackage*> top_deps_set;
1106	for(std::vector<Stackage*>::iterator it = top_deps.begin();	1106	for(std::vector<Stackage*>::iterator it = top_deps.begin();
1107	it != top_deps.end();	1107	it != top_deps.end();
1108	++it)	1108	++it)
Lines 1292-1298 Rosstackage::depsOnDetail(const std::string& name, bool direct, Link Here
1292	}	1292	}
1293	try	1293	try
1294	{	1294	{
1295	for(std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();	1295	for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
1296	it != stackages_.end();	1296	it != stackages_.end();
1297	++it)	1297	++it)
1298	{	1298	{
Lines 1327-1333 Rosstackage::profile(const std::vector<std::string>& search_path, Link Here
1327	{	1327	{
1328	double start = time_since_epoch();	1328	double start = time_since_epoch();
1329	std::vector<DirectoryCrawlRecord*> dcrs;	1329	std::vector<DirectoryCrawlRecord*> dcrs;
1330	std::tr1::unordered_set<std::string> dcrs_hash;	1330	boost::unordered_set<std::string> dcrs_hash;
1331	for(std::vector<std::string>::const_iterator p = search_path.begin();	1331	for(std::vector<std::string>::const_iterator p = search_path.begin();
1332	p != search_path.end();	1332	p != search_path.end();
1333	++p)	1333	++p)
Lines 1437-1443 Rosstackage::crawlDetail(const std::string& path, Link Here
1437	int depth,	1437	int depth,
1438	bool collect_profile_data,	1438	bool collect_profile_data,
1439	std::vector<DirectoryCrawlRecord*>& profile_data,	1439	std::vector<DirectoryCrawlRecord*>& profile_data,
1440	std::tr1::unordered_set<std::string>& profile_hash)	1440	boost::unordered_set<std::string>& profile_hash)
1441	{	1441	{
1442	if(depth > MAX_CRAWL_DEPTH)	1442	if(depth > MAX_CRAWL_DEPTH)
1443	throw Exception("maximum depth exceeded during crawl");	1443	throw Exception("maximum depth exceeded during crawl");
Lines 1786-1792 Rosstackage::gatherDeps(Stackage* stackage, bool direct, Link Here
1786	std::vector<Stackage*>& deps,	1786	std::vector<Stackage*>& deps,
1787	bool no_recursion_on_wet)	1787	bool no_recursion_on_wet)
1788	{	1788	{
1789	std::tr1::unordered_set<Stackage*> deps_hash;	1789	boost::unordered_set<Stackage*> deps_hash;
1790	std::vector<std::string> indented_deps;	1790	std::vector<std::string> indented_deps;
1791	gatherDepsFull(stackage, direct, order, 0,	1791	gatherDepsFull(stackage, direct, order, 0,
1792	deps_hash, deps, false, indented_deps, no_recursion_on_wet);	1792	deps_hash, deps, false, indented_deps, no_recursion_on_wet);
Lines 1795-1801 Rosstackage::gatherDeps(Stackage* stackage, bool direct, Link Here
1795	void	1795	void
1796	_gatherDepsFull(Stackage* stackage, bool direct,	1796	_gatherDepsFull(Stackage* stackage, bool direct,
1797	traversal_order_t order, int depth,	1797	traversal_order_t order, int depth,
1798	std::tr1::unordered_set<Stackage*>& deps_hash,	1798	boost::unordered_set<Stackage*>& deps_hash,
1799	std::vector<Stackage*>& deps,	1799	std::vector<Stackage*>& deps,
1800	bool get_indented_deps,	1800	bool get_indented_deps,
1801	std::vector<std::string>& indented_deps,	1801	std::vector<std::string>& indented_deps,
Lines 1881-1887 _gatherDepsFull(Stackage* stackage, bool direct, Link Here
1881	void	1881	void
1882	Rosstackage::gatherDepsFull(Stackage* stackage, bool direct,	1882	Rosstackage::gatherDepsFull(Stackage* stackage, bool direct,
1883	traversal_order_t order, int depth,	1883	traversal_order_t order, int depth,
1884	std::tr1::unordered_set<Stackage*>& deps_hash,	1884	boost::unordered_set<Stackage*>& deps_hash,
1885	std::vector<Stackage*>& deps,	1885	std::vector<Stackage*>& deps,
1886	bool get_indented_deps,	1886	bool get_indented_deps,
1887	std::vector<std::string>& indented_deps,	1887	std::vector<std::string>& indented_deps,
Lines 2068-2074 Rosstackage::writeCache() Link Here
2068	{	2068	{
2069	char *rpp = getenv("ROS_PACKAGE_PATH");	2069	char *rpp = getenv("ROS_PACKAGE_PATH");
2070	fprintf(cache, "#ROS_PACKAGE_PATH=%s\n", (rpp ? rpp : ""));	2070	fprintf(cache, "#ROS_PACKAGE_PATH=%s\n", (rpp ? rpp : ""));
2071	for(std::tr1::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();	2071	for(boost::unordered_map<std::string, Stackage*>::const_iterator it = stackages_.begin();
2072	it != stackages_.end();	2072	it != stackages_.end();
2073	++it)	2073	++it)
2074	fprintf(cache, "%s\n", it->second->path_.c_str());	2074	fprintf(cache, "%s\n", it->second->path_.c_str());