ProgramOptions.cpp

Go to the documentation of this file.

// ProgramOptions.cpp

#include "ProgramOptions.h"
#include "format_paragraph.h"
#include <iostream>
#include <sstream>

std::ostream& operator<<(std::ostream& os, const ProgramOption& po)
{
  os << "Option '" << po.GetShortOption() << "' or '" << po.GetLongOption() << "'";
  if (po.IsCaseSensitive())
    os << " (case sensitive)";
  switch(po.GetType())
  {
  case ProgramOption::opt_boolean:
    os << " with";
    if (!po.IsDefined())
      os << " default";
    os << " boolean value " << po.GetBoolValue();
    break;
  case ProgramOption::opt_string:
    os << " with";
    if (!po.IsDefined())
      os << " default";
    os << " string value '" << po.GetStringValue() << "'";
    break;
  case ProgramOption::opt_long:
    os << " with";
    if (!po.IsDefined())
      os << " default";
    os << " long value " << po.GetLongValue();
    os << " (" << po.GetLongValueMin() << ", " << po.GetLongValueMax() << ")";
    break;
  }  
  return os;
}

ProgramOptions::ProgramOptions()
{
  m_sOptionChars = "-/";
}

ProgramOptions::~ProgramOptions()
{
   for (option_iterator i = m_options.begin(); i != m_options.end(); ++i)
    delete *i;
  m_options.clear();
}

void ProgramOptions::AddBoolean(
    char cShortOption, const char* pszLongOption, bool bDefault,
    bool bCaseSensitive, const char* pszHelpText)
  {
    ProgramOption* po =
      new ProgramOption(
        cShortOption,
        pszLongOption,
        ProgramOption::opt_boolean,
        false
      );
    po->m_bValue = bDefault;
    po->m_bCaseSensitive = bCaseSensitive;
    safe_assign(po->m_sHelpText, pszHelpText);
    Add(po);
  }
  
void ProgramOptions::AddString(
    char cShortOption, const char* pszLongOption, const char* pszDefault,
    bool bCaseSensitive,
    const char* pszParameterHint, const char* pszHelpText)
  {
    ProgramOption* po =
      new ProgramOption(
        cShortOption,
        pszLongOption,
        ProgramOption::opt_string,
        true
      );
    safe_assign(po->m_sValue, pszDefault);
    po->m_bCaseSensitive = bCaseSensitive;
    safe_assign(po->m_sHelpText, pszHelpText);
    safe_assign(po->m_sParameterHint, pszParameterHint);
    Add(po);
  }
  
void ProgramOptions::AddLong(
    char cShortOption, const char* pszLongOption, long lDefault,
    long lMin, long lMax,
    bool bCaseSensitive,
    const char* pszParameterHint, const char* pszHelpText)
  {
    ProgramOption* po =
      new ProgramOption(
        cShortOption,
        pszLongOption,
        ProgramOption::opt_long,
        true
      );
    po->m_lValue = lDefault;
    po->m_lMinValue = lMin;
    po->m_lMaxValue = lMax;
    po->m_bCaseSensitive = bCaseSensitive;
    safe_assign(po->m_sHelpText, pszHelpText);
    safe_assign(po->m_sParameterHint, pszParameterHint);
    Add(po);
  }

  void ProgramOptions::PrintHelp(std::ostream& os, int width) const
  {
    char optchar = m_sOptionChars[0];
    for (ProgramOptions::const_option_iterator o = options_begin(); o != options_end(); ++o)
    {
      const ProgramOption& po = **o;
      if (po.HasShortOption())
      {
        os << optchar << po.GetShortOption();
        if (po.HasParameter() && !po.GetParameterHint().empty())
          os << " " << po.GetParameterHint();
      }
      if (po.HasLongOption())
      {
        if (po.HasShortOption())
          os << ", ";
        os << optchar << po.GetLongOption() << " ";
        if (po.HasParameter() && !po.GetParameterHint().empty())
          os << po.GetParameterHint();
      }
      os << std::endl;
      os << format_paragraph(po.GetHelpText().c_str(), 2, width-1);
    }
  }

void ProgramOptions::Add(ProgramOption* pOption)
{
  m_options.push_back(pOption);
}

void ProgramOptions::AddParameter(const char* psz)
{
  std::string s;
  safe_assign(s, psz);
  m_parameters.push_back(s);
}

bool ProgramOptions::IsOptionChar(char c) const
{
  return (m_sOptionChars.find(c) != std::string::npos);
}

ProgramOption* ProgramOptions::GetOption(char c) const
{
  for (const_option_iterator i = options_begin(); i != options_end(); ++i)
  {
    ProgramOption* pOption = *i;
    if (pOption->IsOption(c))
      return pOption;
  }
  return 0;
}
 
ProgramOption* ProgramOptions::GetOption(const char* psz) const
{
  for (const_option_iterator i = options_begin(); i != options_end(); ++i)
  {
    ProgramOption* pOption = *i;
    if (pOption->IsOption(psz))
      return pOption;
  }
  return 0;
}

std::string ProgramOptions::GetStringParameter(const char* psz) const
{
  std::string s;
  size_t len = strlen(psz);
  if (len > 2)
  {
    const char* pszLast = psz + len-1;
    if (*psz == '\"' && *pszLast == '\"')
      s.assign(psz+1, len-2);
    else
      s.assign(psz, len);
  }
  else
  {
    safe_assign(s, psz);
  }
  return s;
}

bool ProgramOptions::Parse(int argc, char* argv[], std::locale loc)
{
  ProgramOption* pParameterOption = 0;
  for (int arg = 1; arg < argc; ++arg)
  {
    char optChar = argv[arg][0];
    if (IsOptionChar(optChar) && !pParameterOption)
    {
      // This is one or more options
      const char* pszOption = &argv[arg][1];
      ProgramOption* pOption = GetOption(pszOption);
      if (pOption)
      {
        if (pOption->HasParameter())
          pParameterOption = pOption;
        else
          pOption->SetBoolValue();
      }
      else
      {
        // Try each character as an option
        bool bFoundSomething = false;
        for (char* pOpt = &argv[arg][1]; *pOpt; ++pOpt)
        {
          pOption = GetOption(*pOpt);
          if (pOption)
          {
            bFoundSomething = true;
            if (pOption->HasParameter())
            {
              if (!pParameterOption)
              {
                pParameterOption = pOption;
              }
              else
              {
                std::cerr << "Invalid usage of two options with parameters in " << argv[arg] << std::endl;
                return false;
              }
            }
            else
              pOption->SetBoolValue();
          }
        }
        if (!bFoundSomething)
        {
          std::cerr << "Unknown option " << argv[arg] << std::endl;
          return false;
        }
      }
    }
    else
    {
      // This is a parameter or a an option value
      if (pParameterOption)
      {
        switch (pParameterOption->GetType())
        {
        case ProgramOption::opt_long:
          {
          std::istringstream is(argv[arg]);
          is.imbue(loc);
          long l;
          is >> l;
          // Stream should not have errors and no characters left
          if (!(!is.fail() && !is.good() && pParameterOption->SetLongValue(l)))
          {
            std::cerr << "Invalid parameter : " << argv[arg] << std::endl;
            std::cerr << "for " << *pParameterOption << std::endl;
            return false;
          }
          }
          break;
        case ProgramOption::opt_string:
          pParameterOption->SetStringValue(GetStringParameter(argv[arg]).c_str());
          break;
        }
      }
      else
      {
        AddParameter(GetStringParameter(argv[arg]).c_str());
      }
      pParameterOption = 0;
    }
  }
  // Last parameter should be used by now
  if (pParameterOption)
  {
    std::cerr << "Missing parameter for " << *pParameterOption << std::endl;
    return false;
  }
  return true;
}

bool ProgramOptions::GetBoolValue(char option) const
{
  ProgramOption* pOption = GetOption(option);
  if (pOption)
    return pOption->GetBoolValue();
  else
    return false;
}

bool ProgramOptions::GetBoolValue(const char* pszOption) const
{
  ProgramOption* pOption = GetOption(pszOption);
  if (pOption)
    return pOption->GetBoolValue();
  else
    return false;
}

long ProgramOptions::GetLongValue(char option) const
{
  ProgramOption* pOption = GetOption(option);
  if (pOption)
    return pOption->GetLongValue();
  else
    return 0;
}

long ProgramOptions::GetLongValue(const char* pszOption) const
{
  ProgramOption* pOption = GetOption(pszOption);
  if (pOption)
    return pOption->GetLongValue();
  else
    return 0;
}

std::string ProgramOptions::GetStringValue(char option) const
{
  ProgramOption* pOption = GetOption(option);
  if (pOption)
    return pOption->GetStringValue();
  else
    return "";
}

std::string ProgramOptions::GetStringValue(const char* pszOption) const
{
  ProgramOption* pOption = GetOption(pszOption);
  if (pOption)
    return pOption->GetStringValue();
  else
    return "";
}

std::ostream& operator<<(std::ostream& os, const ProgramOptions& pos)
{
  for (ProgramOptions::const_option_iterator o = pos.options_begin(); o != pos.options_end(); ++o)
    os << **o << std::endl;
  os << (unsigned long)pos.m_parameters.size() << " parameters:" << std::endl;
  for (ProgramOptions::const_parameter_iterator p = pos.parameter_begin(); p != pos.parameter_end(); ++p)
    os << *p << std::endl;
  return os;
}


#ifdef _DEBUG
void test_programoptions()
{
  ProgramOptions po1;
  po1.AddBoolean('q', "quiet", false);
  po1.AddLong('w', "timeout", 1000, 0);
  po1.AddLong('p', "pause", 1000, 0);
  po1.AddString('o', "outputfile");
  po1.AddString('g', "targetfile");
  char* t1[] = {
    "dummy",
    "-timeout",
    "999",
    "-p",
    "500",
    "-qo",
    "\"C:\\Documents and Settings\\erik\\My Documents\"",
    "localhost"
  };
  po1.Parse(8, t1);
  std::cout << po1 << std::endl;
  
  ProgramOptions po2;
  po2.AddBoolean('q', "quiet", false);
  po2.AddLong('w', "timeout", 1000, 0);
  po2.AddLong('p', "pause", 1000, 0);
  po2.AddString('o', "outputfile");
  po2.AddString('g', "targetfile");
  po2.AddLong('l', "longlimittest1", 1, 1, 5);
  po2.AddLong('L', "longlimittest2", 1, 1, 5, true);
  char* t2[] = {
    "dummy",
    "-qp",
    "1234",
    "-Lq",
    "3",
    "-longlimittest",
    "6"
  };
  po2.Parse(7, t2);
  std::cout << po2 << std::endl;

  ProgramOptions po3;
  po3.AddBoolean('q', "quiet", false);
  po3.AddLong('w', "timeout", 1000, 0);
  po3.AddLong('p', "pause", 1000, 0);
  po3.AddString('o', "outputfile");
  po3.AddString('g', "targetfile");
  char* t3[] = {
    "dummy",
    "-p",
    "1,4"
  };
  po3.Parse(3, t3);
  std::cout << po3 << std::endl;

  ProgramOptions po4;
  po4.AddBoolean('q', "quiet", false);
  po4.AddLong('w', "timeout", 1000, 0);
  po4.AddLong('p', "pause", 1000, 0);
  po4.AddString('o', "outputfile");
  po4.AddString('g', "targetfile");
  char* t4[] = {
    "dummy",
    "-p"
  };
  po4.Parse(2, t4);
  std::cout << po4 << std::endl;

  ProgramOptions po5;
  po5.AddBoolean('q', "quiet", false);
  po5.AddLong('w', "timeout", 1000, 0);
  po5.AddLong('p', "pause", 1000, 0);
  po5.AddString('o', "outputfile");
  po5.AddString('g', "targetfile");
  char* t5[] = {
    "dummy",
    "-pqw",
    "1234"
  };
  po5.Parse(3, t5);
  std::cout << po5 << std::endl;

  ProgramOptions po6;
  po6.AddBoolean(
    'q', "quiet",
    false, false,
    "Quiet operation. Only errors are sent to console."
  );
  po6.AddLong(
    'w', "timeout",
    1000, 0, LONG_MAX,
    false,
    "ms", "Time in milliseconds to wait while sending to and receiving from targets."
  );
  po6.AddLong('\0', "pause",
    1000, 0, LONG_MAX,
    false,
    "ms", "Time in milliseconds to pause between sending to and receiving from all targets."
  );
  po6.AddString(
    'o', "outputfile",
    0, false,
    "filename", ""
  );
  po6.AddString(
    'g', "targetfile",
    0, false,
    "filename", "Reads targets from file with one target per line. Targets in file are added to targets specified as parameters."
  );
  po6.PrintHelp(std::cout);
}

/*
int main(int argc, char* argv[])
{
  test_programoptions();
}
*/
#endif // _DEBUG

---