Option.hpp

#ifndef STK_UTIL_DIAG_Option_h
#define STK_UTIL_DIAG_Option_h
 
#include <map>
 
namespace stk_classic {
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;    
};
 
} // namespace diag
} // namespace stk_classic
 
namespace sierra {
typedef stk_classic::diag::OptionMask OptionMask;
typedef stk_classic::diag::OptionDescription OptionDescription;
typedef stk_classic::diag::Option Option;
typedef stk_classic::diag::OptionMaskName OptionMaskName;
typedef stk_classic::diag::OptionMaskNameMap OptionMaskNameMap;
typedef stk_classic::diag::OptionMaskParser OptionMaskParser;
} // namespace sierra
 
#endif // STK_UTIL_DIAG_Option_h