WriterParser.hpp

#ifndef STK_UTIL_Diag_WriterParser_h
#define STK_UTIL_Diag_WriterParser_h

namespace stk {
namespace diag {


typedef unsigned long OptionMask;

struct OptionDescription
{
  virtual ~OptionDescription()
  {}

  virtual std::ostream &describe(std::ostream &os) const = 0;
};


struct Option : public OptionDescription
{
  Option()
    : m_name(""),
      m_envName(""),
      m_description(""),
      m_value(""),
      m_subOptionDescription(0)
  {}

  Option(const std::string &name, const std::string &env_name, const std::string &value = std::string(),
         const std::string &description = "No description available",
         const OptionDescription *sub_option_description = 0)
    : m_name(name),
      m_envName(env_name),
      m_description(description),
      m_value(value),
      m_subOptionDescription(sub_option_description)
  {}

  Option(const Option &option)
    : m_name(option.m_name),
      m_envName(option.m_envName),
      m_description(option.m_description),
      m_value(option.m_value),
      m_subOptionDescription(option.m_subOptionDescription)
  {}


  Option &operator=(const Option &option)
  {
    m_name = option.m_name;
    m_envName = option.m_envName;
    m_description = option.m_description;
    m_value = option.m_value;
    m_subOptionDescription = option.m_subOptionDescription;
    return *this;
  }

  virtual ~Option()
  {}

  const std::string &getName() const {
    return m_name;
  }

  const std::string &getValue() const {
    return m_value;
  }

  virtual std::ostream &describe(std::ostream &os) const;

  operator std::string &() {
    return m_value;
  }

  std::string      m_name;      
  std::string      m_envName;    
  std::string      m_description;    
  std::string      m_value;    
  const OptionDescription *  m_subOptionDescription;  
};


struct OptionMaskName
{
  OptionMaskName()
    : m_name(""),
      m_mask(0),
      m_description("")
  {}

  OptionMaskName(const std::string &name, const OptionMask &mask, const std::string &description = "No description available")
    : m_name(name),
      m_mask(mask),
      m_description(description)
  {}

  virtual ~OptionMaskName()
  {}

  bool operator<(const OptionMaskName &o) const {
    return m_name < o.m_name;
  }

  virtual std::ostream &describe(std::ostream &os) const;

  std::string    m_name;
  OptionMask    m_mask;
  std::string    m_description;
};


class OptionMaskNameMap: public std::map<std::string, OptionMaskName>
{
public:
  void mask(const std::string &name, const OptionMask l_mask, const std::string &description) {
    iterator it = find(name);
    if (it == end())
      insert(std::make_pair(name, OptionMaskName(name, l_mask, description)));
    else {
      (*it).second.m_mask = l_mask;
      (*it).second.m_description = description;
    }
  }
};


class OptionMaskParser : public OptionDescription
{
public:
  typedef OptionMask Mask;    

public:
  OptionMaskParser()
    : m_optionMaskNameMap(),
      m_optionMask(0),
      m_status(true)
  {}

  virtual ~OptionMaskParser()
  {}

  const OptionMaskNameMap &getOptionMaskNameMap() const {
    return m_optionMaskNameMap;
  }

  virtual Mask parse(const char *mask) const;

  virtual void parseArg(const std::string &name, const std::string &arg) const;

  Mask &operator[](const std::string &name) {
    return m_optionMaskNameMap[name].m_mask;
  }

  void mask(const std::string &name, const Mask l_mask, const std::string &description) {
    m_optionMaskNameMap.mask(name, l_mask, description);
  }

  std::ostream &describe(std::ostream &os) const;

protected:
  OptionMaskNameMap    m_optionMaskNameMap;  
  mutable OptionMask    m_optionMask;    
  mutable bool      m_status;    
};



class WriterParser : public OptionMaskParser
{
public:
  typedef OptionMaskParser::Mask  Mask;

public:
  WriterParser();

  Mask parse(const char *mask_string) const;

  virtual void parseArg(const std::string &name, const std::string &arg) const;
};


} // namespace diag
} // namespace stk

#endif // STK_UTIL_Diag_WriterParser_h