JArgs.hh

Go to the documentation of this file.

#ifndef __JEEP__JARGS__
#define __JEEP__JARGS__
 
#include <string>
#include <sstream>
#include <istream>
#include <ostream>
#include <vector>
 
 
/**
 * \author mdejong
 */
 
namespace JEEP {}
namespace JPP { using namespace JEEP; }
 
namespace JEEP {
 
 
  /**
   * Data structure to store command line arguments.
   */
  class JArgs :
    public std::vector<std::string>
  {
  public:
    /**
     * Default constructor.
     */
    JArgs()
    {}
 
 
    /**
     * Constructor.\n
     * The first argument (if any) is assumed to be the process name (PID).
     * 
     * \param  argc                 number of command line arguments
     * \param  argv                 array  of command line arguments
     */
    JArgs(const int argc, const char* const argv[])
    {
      if (argc > 0) {
 
        PID = argv[0];
 
        for (int i = 1; i != argc; ++i) {
          push_back(argv[i]);
        }
 
      } else {
 
        PID = "";
      }
    }
 
 
    /**
     * Constructor.\n
     * 
     * \param  PID                  process identifier
     * \param  __begin              begin of command line arguments
     * \param  __end                end   of command line arguments
     */
    JArgs(const std::string& PID, JArgs::const_iterator __begin, JArgs::const_iterator __end)
    {
      this->PID = PID;
 
      for (const_iterator i = __begin; i != __end; ++i) {
        push_back(*i);
      }
    }
 
 
    /**
     * Constructor.
     *
     * \param  buffer               input
     */
    JArgs(const std::string& buffer)
    {
      using namespace std;
 
      istringstream is(buffer);
 
      PID = "";
 
      for (string word; is >> word; ) {
        push_back(word);
      }
    }
 
 
    /**
     * Convert to string consisting of sequence of tokens separated by given white space character.
     *
     * \param  ws                   white space character
     * \return                      string
     */
    std::string str(const char ws = ' ') const
    {
      std::string buffer = PID;
 
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
        buffer += ws;
        buffer += *i;
      }
 
      return buffer;
    }
 
 
    /**
     * Convert to character array consisting of sequence of tokens separated by given white space character.
     *
     * \param  ws                   white space character
     * \return                      character array
     */
    const char* c_str(const char ws = ' ') const
    {
      static std::string buffer;
 
      buffer = this->str(ws);
 
      return buffer.c_str();
    }
 
 
    /**
     * Stream input.
     *
     * \param  in           input stream
     * \param  args         args
     * \return              input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JArgs& args)
    {
      //in >> args.PID;
 
      for (std::string buffer; in >> buffer; ) {
        args.push_back(buffer);
      } 
 
      return in;
    }
 
 
    /**
     * Stream output.
     *
     * \param  out          output stream
     * \param  args         args
     * \return              output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JArgs& args)
    {
      out << args.PID;
 
      for (JArgs::const_iterator i = args.begin(); i != args.end(); ++i) {
        out << ' ' << *i;
      }
 
      return out;
    }
 
    std::string PID;
  };
}
 
#endif