added print-cache code to the tests suite

git-svn-id: http://svn.code.sf.net/p/retroshare/code/trunk@4163 b45a01b8-16f6-495d-af2f-9b41ad6348cc

libretroshare/src/tests/printcache/argstream.h

@@ -0,0 +1,814 @@
+/* Copyright (C) 2004 Xavier Décoret <Xavier.Decoret@imag.fr>
+*
+ * argsteam is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * Foobar is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with Foobar; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
+ */
+
+#ifndef ARGSTREAM_H
+#define ARGSTREAM_H
+
+
+#include <stdlib.h>
+#include <string>
+#include <list>
+#include <deque>
+#include <map>
+#include <stdexcept>
+#include <sstream>
+#include <iostream> 
+
+namespace 
+{
+  class argstream;
+
+  template<class T>
+  class ValueHolder;
+  
+  template <typename T>
+  argstream& operator>> (argstream&, const ValueHolder<T>&);
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  // Interface of ValueHolder<T>
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  template<class T>
+  class ValueHolder
+  {
+  public:
+    ValueHolder(char s,
+		const char* l,
+		T& b,
+		const char* desc,
+		bool mandatory);
+    ValueHolder(const char* l,
+		T& b,
+		const char* desc,
+		bool mandatory);
+    ValueHolder(char s,
+		T& b,
+		const char* desc,
+		bool mandatory);
+    friend argstream& operator>><>(argstream& s,const ValueHolder<T>& v);
+    std::string name() const;
+    std::string description() const;
+  private:
+    std::string shortName_;
+    std::string longName_;
+    T*          value_;
+    T           initialValue_;
+    std::string description_;  
+    bool        mandatory_;
+  };
+  template <class T>
+  inline ValueHolder<T>
+  parameter(char s,
+	    const char* l,
+	    T& b,
+	    const char* desc="",
+	    bool mandatory = true)
+  {
+    return ValueHolder<T>(s,l,b,desc,mandatory);
+  }
+  template <class T>
+  inline ValueHolder<T>
+  parameter(char s,
+	    T& b,
+	    const char* desc="",
+	    bool mandatory = true)
+  {
+    return ValueHolder<T>(s,b,desc,mandatory);
+  }
+  template <class T>
+  inline ValueHolder<T>
+  parameter(const char* l,
+	    T& b,
+	    const char* desc="",
+	    bool mandatory = true)
+  {
+    return ValueHolder<T>(l,b,desc,mandatory);
+  }
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  // Interface of OptionHolder
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  class OptionHolder
+  {
+  public:
+    inline OptionHolder(char s,
+			const char* l,
+			bool& b,
+			const char* desc);
+    inline OptionHolder(const char* l,
+			bool& b,
+			const char* desc);
+    inline OptionHolder(char s,
+			bool& b,
+			const char* desc);
+    friend argstream& operator>>(argstream& s,const OptionHolder& v);
+    inline std::string name() const;
+    inline std::string description() const;
+  protected:
+    inline OptionHolder(char s,
+			const char* l,
+			const char* desc);  
+    friend OptionHolder help(char s='h',
+			     const char* l="help",
+			     const char* desc="Display this help");
+  private:
+    std::string shortName_;
+    std::string longName_;
+    bool*       value_;
+    std::string description_;  
+  };
+  inline OptionHolder
+  option(char s,
+	 const char* l,
+	 bool& b,
+	 const char* desc="")
+  {
+    return OptionHolder(s,l,b,desc);
+  }
+  inline OptionHolder
+  option(char s,
+	 bool& b,
+	 const char* desc="")
+  {
+    return OptionHolder(s,b,desc);
+  }
+  inline OptionHolder
+  option(const char* l,
+	 bool& b,
+	 const char* desc="")
+  {
+    return OptionHolder(l,b,desc);
+  }
+  inline OptionHolder
+  help(char s,
+       const char* l,
+       const char* desc)
+  {
+    return OptionHolder(s,l,desc);
+  }
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  // Interface of ValuesHolder
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  template<class T,class O>
+  class ValuesHolder
+  {
+  public:
+    ValuesHolder(const O& o,
+		 const char* desc,
+		 int len);
+    template<class A,class B> friend argstream& operator>>(argstream& s,const ValuesHolder<A,B>& v);
+    std::string name() const;
+    std::string description() const;
+    typedef T value_type;
+  private:
+    mutable O   value_;
+    std::string description_;  
+    int         len_;
+    char        letter_;
+  };
+  template<class T,class O>
+  inline ValuesHolder<T,O>
+  values(const O& o,
+	 const char* desc="",
+	 int len=-1)
+  {
+    return ValuesHolder<T,O>(o,desc,len);
+  }
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  // Interface of ValueParser
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  template <class T>
+  class ValueParser
+  {
+  public:
+    inline T operator()(const std::string& s) const
+      {
+	std::istringstream is(s);
+	T t;
+	is>>t;
+	return t;
+      }
+  };
+  // We need to specialize for string otherwise parsing of a value that
+  // contains space (for example a string with space passed in quotes on the
+  // command line) would parse only the first element of the value!!!
+  template <>
+  class ValueParser<std::string>
+  {
+  public:
+    inline std::string operator()(const std::string& s) const
+      {
+	return s;
+      }
+  };  
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  // Interface of argstream
+  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+  class argstream
+  {
+  public:
+    inline argstream(int argc,char** argv);
+    inline argstream(const char* c);
+    template<class T>
+    friend argstream& operator>>(argstream& s,const ValueHolder<T>& v);
+    friend inline argstream& operator>>(argstream& s,const OptionHolder& v);
+    template<class T,class O>
+    friend argstream& operator>>(argstream& s,const ValuesHolder<T,O>& v);
+
+    inline bool helpRequested() const;
+    inline bool isOk() const;
+    inline std::string errorLog() const;
+    inline std::string usage() const;
+    inline void defaultErrorHandling(bool ignoreUnused=false) const;
+    static inline char uniqueLetter();
+  protected:
+    void parse(int argc,char** argv);
+  private:
+    typedef std::list<std::string>::iterator value_iterator;
+    typedef std::pair<std::string,std::string> help_entry;
+    std::string                          progName_;
+    std::map<std::string,value_iterator> options_;
+    std::list<std::string>               values_;
+    bool                                 minusActive_;
+    bool                                 isOk_;
+    std::deque<help_entry>               argHelps_;
+    std::string                          cmdLine_;
+    std::deque<std::string>              errors_;
+    bool                                 helpRequested_;
+  };
+  //************************************************************
+  // Implementation of ValueHolder<T>
+  //************************************************************
+  template<class T>
+  ValueHolder<T>::ValueHolder(char s,
+			      const char* l,
+			      T& v,
+			      const char* desc,
+			      bool mandatory)
+    :  shortName_(1,s),
+       longName_(l),
+       value_(&v),
+       initialValue_(v),
+       description_(desc),
+       mandatory_(mandatory)
+  {
+  }
+  template<class T>
+  ValueHolder<T>::ValueHolder(const char* l,
+			      T& v,
+			      const char* desc,
+			      bool mandatory)
+    :  longName_(l),
+       value_(&v),
+       initialValue_(v),
+       description_(desc),
+       mandatory_(mandatory)
+  {
+  }
+  template<class T>
+  ValueHolder<T>::ValueHolder(char s,
+			      T& v,
+			      const char* desc,
+			      bool mandatory)
+    :  shortName_(1,s),
+       value_(&v),
+       initialValue_(v),
+       description_(desc),
+       mandatory_(mandatory)
+  {
+  }
+  template<class T>
+  std::string
+  ValueHolder<T>::name() const
+  {
+    std::ostringstream  os;
+    if (!shortName_.empty()) os<<'-'<<shortName_;
+    if (!longName_.empty()) {      
+      if (!shortName_.empty()) os<<'/';
+      os<<"--"<<longName_;
+    }
+    return os.str();
+  }
+  template<class T>
+  std::string
+  ValueHolder<T>::description() const
+  {
+    std::ostringstream  os;  
+    os<<description_;
+    if (mandatory_)
+    {
+      os<<"(mandatory)";
+    }
+    else
+    {
+      os<<"(default="<<initialValue_<<")";
+    }
+    return os.str();
+  }
+  //************************************************************
+  // Implementation of OptionHolder
+  //************************************************************
+  inline OptionHolder::OptionHolder(char s,
+				    const char* l,
+				    bool& b,
+				    const char* desc)
+    : shortName_(1,s),
+      longName_(l),
+      value_(&b),
+      description_(desc)
+  {
+  }
+  inline OptionHolder::OptionHolder(const char* l,
+				    bool& b,
+				    const char* desc)
+    : longName_(l),
+      value_(&b),
+      description_(desc)
+  {
+  }
+  inline OptionHolder::OptionHolder(char s,
+				    bool& b,
+				    const char* desc)
+    : shortName_(1,s),
+      value_(&b),
+      description_(desc)
+  {
+  }
+  inline OptionHolder::OptionHolder(char s,
+				    const char* l,
+				    const char* desc)
+    : shortName_(1,s),
+      longName_(l),
+      value_(NULL),
+      description_(desc)
+  {
+  }
+  inline std::string
+  OptionHolder::name() const
+  {
+    std::ostringstream  os;
+    if (!shortName_.empty()) os<<'-'<<shortName_;
+    if (!longName_.empty())
+    {
+      if (!shortName_.empty()) os<<'/';
+      os<<"--"<<longName_;
+    }
+    return os.str();
+  }
+  inline std::string
+  OptionHolder::description() const
+  {
+    return description_;
+  }
+  //************************************************************
+  // Implementation of ValuesHolder<T,O>
+  //************************************************************
+  template<class T,class O>
+  ValuesHolder<T,O>::ValuesHolder(const O& o,
+				  const char* desc,
+				  int len)
+    : value_(o),
+      description_(desc),
+      len_(len)
+  {
+    letter_ = argstream::uniqueLetter();
+  }
+  template <class T,class O>
+  std::string
+  ValuesHolder<T,O>::name() const
+  {
+    std::ostringstream  os;
+    os<<letter_<<"i";
+    return os.str();
+  }
+  template <class T,class O>
+  std::string
+  ValuesHolder<T,O>::description() const
+  {
+    return description_;
+  }
+  //************************************************************
+  // Implementation of argstream
+  //************************************************************
+  inline
+  argstream::argstream(int argc,char** argv)
+    : progName_(argv[0]),
+      minusActive_(true),
+      isOk_(true)
+  {
+    parse(argc,argv);
+  }
+  inline
+  argstream::argstream(const char* c)
+    : progName_(""),
+      minusActive_(true),
+      isOk_(true)
+  {
+    std::string s(c);
+    // Build argc, argv from s. We must add a dummy first element for
+    // progName because parse() expects it!!
+    std::deque<std::string> args;
+    args.push_back("");
+    std::istringstream is(s);
+    while (is.good())
+    {
+      std::string t;
+      is>>t;
+      args.push_back(t);
+    }
+    char* pargs[args.size()];
+    char** p = pargs;
+    for (std::deque<std::string>::const_iterator
+	   iter = args.begin();
+	 iter != args.end();++iter)
+    {
+      *p++ = const_cast<char*>(iter->c_str());
+    }
+    parse(args.size(),pargs);
+  }
+  inline void
+  argstream::parse(int argc,char** argv)
+  {
+    // Run thru all arguments.
+    // * it has -- in front : it is a long name option, if remainder is empty,
+    //                        it is an error
+    // * it has - in front  : it is a sequence of short name options, if
+    //                        remainder is empty, deactivates option (- will
+    //                        now be considered a char).
+    // * if any other char, or if option was deactivated
+    //                      : it is a value. Values are split in parameters
+    //                      (immediately follow an option) and pure values.
+    // Each time a value is parsed, if the previously parsed argument was an
+    // option, then the option is linked to the value in case of it is a
+    // option with parameter.  The subtle point is that when several options
+    // are given with short names (ex: -abc equivalent to -a -b -c), the last
+    // parsed option is -c).
+    // Since we use map for option, any successive call overides the previous
+    // one: foo -a -b -a hello is equivalent to foo -b -a hello
+    // For values it is not true since we might have several times the same
+    // value. 
+    value_iterator* lastOption = NULL;
+    for (char** a = argv,**astop=a+argc;++a!=astop;)
+    {
+      std::string s(*a);
+      if (minusActive_ && s[0] == '-')
+      {
+	if (s.size() > 1 && s[1] == '-')
+	{
+	  if (s.size() == 2)
+	  {
+	    minusActive_ = false;
+	    continue;
+	  }
+	  lastOption = &(options_[s.substr(2)] = values_.end());
+	}
+	else 
+	{
+	  if (s.size() > 1)
+	  {
+	    // Parse all chars, if it is a minus we have an error
+	    for (std::string::const_iterator cter = s.begin();
+		 ++cter != s.end();)
+	    {
+	      if (*cter == '-')
+	      {
+		isOk_ = false;
+		std::ostringstream os;
+		os<<"- in the middle of a switch "<<a;
+		errors_.push_back(os.str());
+		break;
+	      }
+	      lastOption = &(options_[std::string(1,*cter)] = values_.end());
+	    }
+	  }
+	  else
+	  {
+	    isOk_ = false;
+	    errors_.push_back("Invalid argument -");
+	    break;
+	  }
+	}
+      }
+      else
+      {
+	values_.push_back(s);
+	if (lastOption != NULL)
+	{
+	  *lastOption = --values_.end();
+	}
+	lastOption = NULL;
+      }
+    }
+#ifdef ARGSTREAM_DEBUG
+    for (std::map<std::string,value_iterator>::const_iterator
+	   iter = options_.begin();iter != options_.end();++iter)
+    {
+      std::cout<<"DEBUG: option "<<iter->first;
+      if (iter->second != values_.end())
+      {
+	std::cout<<" -> "<<*(iter->second);
+      }
+      std::cout<<std::endl;
+    }
+    for (std::list<std::string>::const_iterator
+	   iter = values_.begin();iter != values_.end();++iter)
+    {
+      std::cout<<"DEBUG: value  "<<*iter<<std::endl;
+    }
+#endif // ARGSTREAM_DEBUG
+  }
+  inline bool
+  argstream::isOk() const
+  {
+    return isOk_;
+  }
+  inline bool
+  argstream::helpRequested() const
+  {
+    return helpRequested_;
+  }
+  inline std::string
+  argstream::usage() const
+  {
+    std::ostringstream os;
+    os<<"usage: "<<progName_<<cmdLine_<<'\n';
+    unsigned int lmax = 0;
+    for (std::deque<help_entry>::const_iterator
+	   iter = argHelps_.begin();iter != argHelps_.end();++iter)
+    {
+      if (lmax<iter->first.size()) lmax = iter->first.size();
+    }  
+    for (std::deque<help_entry>::const_iterator
+	   iter = argHelps_.begin();iter != argHelps_.end();++iter)
+    {
+      os<<'\t'<<iter->first<<std::string(lmax-iter->first.size(),' ')
+	<<" : "<<iter->second<<'\n';
+    }
+    return os.str();
+  }
+  inline std::string
+  argstream::errorLog() const
+  {
+    std::string s;
+    for(std::deque<std::string>::const_iterator iter = errors_.begin();
+	iter != errors_.end();++iter)
+    {
+      s += *iter;
+      s += '\n';
+    }
+    return s;
+  }
+  inline char
+  argstream::uniqueLetter()
+  {
+    static unsigned int c = 'a';
+    return c++;
+  }
+  template<class T>
+  argstream&
+  operator>>(argstream& s,const ValueHolder<T>& v)
+  {
+    // Search in the options if there is any such option defined either with a
+    // short name or a long name. If both are found, only the last one is
+    // used.
+#ifdef ARGSTREAM_DEBUG    
+    std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
+#endif    
+    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
+    if (v.mandatory_)
+    {
+      if (!v.shortName_.empty())
+      {
+	s.cmdLine_ += " -";
+	s.cmdLine_ += v.shortName_;
+      }
+      else
+      {
+	s.cmdLine_ += " --";
+	s.cmdLine_ += v.longName_;
+      }
+      s.cmdLine_ += " value";
+    }
+    else
+    {
+      if (!v.shortName_.empty())
+      {
+	s.cmdLine_ += " [-";
+	s.cmdLine_ += v.shortName_;
+      }
+      else
+      {
+	s.cmdLine_ += " [--";
+	s.cmdLine_ += v.longName_;
+      }  
+      s.cmdLine_ += " value]";
+
+    }
+    std::map<std::string,argstream::value_iterator>::iterator iter =
+      s.options_.find(v.shortName_);
+    if (iter == s.options_.end())
+    {
+      iter = s.options_.find(v.longName_);
+    }
+    if (iter != s.options_.end())
+    {
+      // If we find counterpart for value holder on command line, either it
+      // has an associated value in which case we assign it, or it has not, in
+      // which case we have an error.
+      if (iter->second != s.values_.end())
+      {
+#ifdef ARGSTREAM_DEBUG
+	std::cout<<"DEBUG: found value "<<*(iter->second)<<std::endl;
+#endif	
+	ValueParser<T> p;
+	*(v.value_) = p(*(iter->second));
+	// The option and its associated value are removed, the subtle thing
+	// is that someother options might have this associated value too,
+	// which we must invalidate.
+	s.values_.erase(iter->second);      
+	for (std::map<std::string,argstream::value_iterator>::iterator
+	       jter = s.options_.begin();jter != s.options_.end();++jter)
+	{
+	  if (jter->second == iter->second)
+	  {
+	    jter->second = s.values_.end();
+	  }
+	}
+	s.options_.erase(iter);
+      }
+      else
+      {
+	s.isOk_ = false;
+	std::ostringstream  os;
+	os<<"No value following switch "<<iter->first
+	  <<" on command line";
+	s.errors_.push_back(os.str());
+      }
+    }
+    else
+    {
+      if (v.mandatory_)
+      {
+	s.isOk_ = false;
+	std::ostringstream  os;
+	os<<"Mandatory parameter ";
+	if (!v.shortName_.empty()) os<<'-'<<v.shortName_;
+	if (!v.longName_.empty())
+	{
+	  if (!v.shortName_.empty()) os<<'/';
+	  os<<"--"<<v.longName_;
+	}
+	os<<" missing";
+	s.errors_.push_back(os.str());
+      }
+    }
+    return s;
+  }
+  inline argstream&
+  operator>>(argstream& s,const OptionHolder& v)
+  {
+    // Search in the options if there is any such option defined either with a
+    // short name or a long name. If both are found, only the last one is
+    // used.
+#ifdef ARGSTREAM_DEBUG    
+    std::cout<<"DEBUG: searching "<<v.shortName_<<" "<<v.longName_<<std::endl;
+#endif
+    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
+    {
+      std::string c;
+      if (!v.shortName_.empty())
+      {
+	c += " [-";
+	c += v.shortName_;
+      }
+      else
+      {
+	c += " [--";
+	c += v.longName_;
+      }      
+      c += "]";
+      s.cmdLine_ = c+s.cmdLine_;
+    }
+    std::map<std::string,argstream::value_iterator>::iterator iter =
+      s.options_.find(v.shortName_);
+    if (iter == s.options_.end())
+    {
+      iter = s.options_.find(v.longName_);
+    }
+    if (iter != s.options_.end())
+    {
+      // If we find counterpart for value holder on command line then the
+      // option is true and if an associated value was found, it is ignored
+      if (v.value_ != NULL)
+      {
+	*(v.value_) = true;
+      }
+      else
+      {
+	s.helpRequested_ = true;
+      }
+      // The option only is removed
+      s.options_.erase(iter);
+    }
+    else
+    {
+      if (v.value_ != NULL)
+      {
+	*(v.value_) = false;
+      }
+      else
+      {
+	s.helpRequested_ = false;
+      }
+    }
+    return s;
+  }
+  template<class T,class O>
+  argstream&
+  operator>>(argstream& s,const ValuesHolder<T,O>& v)
+  {
+    s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
+    {
+      std::ostringstream os;
+      os<<' '<<v.letter_<<'1';
+      switch (v.len_)
+      {
+      case -1:
+	os<<"...";
+	break;
+      case 1:
+	break;
+      default:
+	os<<"..."<<v.letter_<<v.len_;
+	break;
+      }
+      s.cmdLine_ += os.str();
+    }
+    std::list<std::string>::iterator first = s.values_.begin();
+    // We add to the iterator as much values as we can, limited to the length
+    // specified (if different of -1)
+    int n = v.len_ != -1?v.len_:s.values_.size();
+    while (first != s.values_.end() && n-->0)
+    {
+      // Read the value from the string *first
+      ValueParser<T> p;
+      *(v.value_++) = p(*first );
+      s.argHelps_.push_back(argstream::help_entry(v.name(),v.description()));
+      // The value we just removed was maybe "remembered" by an option so we
+      // remove it now.
+      for (std::map<std::string,argstream::value_iterator>::iterator
+	     jter = s.options_.begin();jter != s.options_.end();++jter)
+      {
+	if (jter->second == first)
+	{
+	  jter->second = s.values_.end();
+	}
+      }
+      ++first;
+    }
+    // Check if we have enough values
+    if (n != 0)
+    {
+      s.isOk_ = false;
+      std::ostringstream  os;
+      os<<"Expecting "<<v.len_<<" values";
+      s.errors_.push_back(os.str());
+    }
+    // Erase the values parsed
+    s.values_.erase(s.values_.begin(),first);
+    return s;
+  }
+  inline void
+  argstream::defaultErrorHandling(bool ignoreUnused) const
+  {
+    if (helpRequested_)
+    {
+      std::cout<<usage();
+      exit(1);
+    }
+    if (!isOk_)
+    {
+      std::cerr<<errorLog();
+      exit(1);
+    }
+    if (!ignoreUnused &&
+	(!values_.empty() || !options_.empty()))
+    {
+      std::cerr<<"Unused arguments"<<std::endl;
+      exit(1);
+    }
+  }
+};
+#endif // ARGSTREAM_H
+

libretroshare/src/tests/printcache/main.cpp

@@ -0,0 +1,110 @@
+/*
+ * main.cpp
+ *
+ *  Created on: 11 Apr 2011
+ *      Author: greyfox
+ */
+
+#include <string>
+#include <set>
+#include <iostream>
+
+#include "argstream.h"
+#include "pqi/pqistreamer.h"
+#include "pqi/pqibin.h"
+#include "serialiser/rsdistribitems.h"
+#include "pqi/pqistore.h"
+
+int main(int argc, char **argv) 
+{
+	try
+	{
+		argstream as(argc,argv) ;
+		bool full_print = false ;
+
+		std::string cacheFileName;
+
+		as >> parameter('f',"file",cacheFileName,"cache file name to read",true)
+			>> option('F',"full",full_print,"full dump of distrib items")
+			>> help() ;
+
+		as.defaultErrorHandling() ;
+
+		std::cout << "opening file: " << cacheFileName << std::endl;
+		// open file
+		BinInterface *bio = new BinFileInterface(cacheFileName.c_str(), BIN_FLAGS_READABLE);
+		RsSerialiser *rsSerialiser = new RsSerialiser();
+		RsSerialType *serialType = new RsDistribSerialiser();
+		rsSerialiser->addSerialType(serialType);
+		pqistore *store = new pqistore(rsSerialiser, "", bio, BIN_FLAGS_READABLE);
+		RsItem* item;
+
+		std::set<std::string> already ;
+		int signed_msgs = 0 ;
+		int distrib_msgs = 0 ;
+		int nb_duplicated = 0 ;
+
+		// then print out contents to screen
+		while(NULL != (item = store->GetItem()))
+		{
+			
+			if(full_print)
+				item->print(std::cout, 0);
+			else
+			{
+				{
+					RsDistribMsg *i = dynamic_cast<RsDistribMsg*>(item) ;
+					if(i!=NULL)
+					{
+						std::cerr << "Grp=" << i->grpId << ", parent=" << i->parentId << ", msgId=" << i->msgId ;
+
+						if(already.find(i->msgId)!=already.end())
+						{
+							std::cerr << " *** double ***" ;
+							++nb_duplicated ;
+						}
+						else
+							already.insert(i->msgId) ;
+						
+						std::cerr << std::endl;
+						++distrib_msgs ;
+					}
+				}
+				{
+					RsDistribSignedMsg *i = dynamic_cast<RsDistribSignedMsg*>(item) ;
+					if(i!=NULL)
+					{
+						std::cerr << "Grp=" << i->grpId << ", msgId=" << i->msgId << ", type=" << i->packet.tlvtype << ", len=" << i->packet.bin_len ;
+						
+						if(already.find(i->msgId)!=already.end())
+						{
+							std::cerr << " *** double ***" ;
+							++nb_duplicated ;
+						}
+						else
+							already.insert(i->msgId) ;
+						
+						std::cerr << std::endl;
+
+						++signed_msgs ;
+					}
+				}
+			}
+		}
+
+		std::cerr << std::endl ;
+		std::cerr << "Signed messages (RsDistribMsg)      : " << distrib_msgs << std::endl;
+		std::cerr << "Signed messages (RsDistribSignedMsg): " << signed_msgs << std::endl;
+		std::cerr << "Duplicate messages                  : " << nb_duplicated << std::endl;
+
+		return 0;
+	}
+	catch(std::exception& e)
+	{
+		std::cerr << "Unhandled exception: " << e.what() << std::endl;
+		return 1 ;
+	}
+}
+
+
+

libretroshare/src/tests/printcache/printcache.pro

@@ -0,0 +1,9 @@
+TEMPLATE = app
+CONFIG = debug
+
+SOURCES = main.cpp
+
+INCLUDEPATH *= ../..
+LIBS = -lstdc++ -lm ../../lib/libretroshare.a ../../../../libbitdht/src/lib/libbitdht.a \
+		 -lssl -lcrypto -lgpgme -lupnp -lgnome-keyring
+