projects/sgconf/options.cpp

   1 /*
   2  *    This program is free software; you can redistribute it and/or modify
   3  *    it under the terms of the GNU General Public License as published by
   4  *    the Free Software Foundation; either version 2 of the License, or
   5  *    (at your option) any later version.
   6  *
   7  *    This program is distributed in the hope that it will be useful,
   8  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  10  *    GNU General Public License for more details.
  11  *
  12  *    You should have received a copy of the GNU General Public License
  13  *    along with this program; if not, write to the Free Software
  14  *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  15  */
  16
  17 /*
  18  *    Author : Maxim Mamontov <faust@stargazer.dp.ua>
  19  */
  20
  21 #include "options.h"
  22
  23 #include "action.h"
  24 #include "parser_state.h"
  25
  26 #include "stg/common.h"
  27
  28 #include <fstream>
  29 #include <sstream>
  30 #include <iostream>
  31 #include <functional>
  32 #include <algorithm>
  33
  34 #include <unistd.h>
  35
  36 namespace
  37 {
  38
  39 template <class C>
  40 void ReadConfigFile(const std::string & filePath, void (C::* callback)(const std::string&, const std::string&), C * obj)
  41 {
  42     std::ifstream stream(filePath.c_str());
  43     std::string line;
  44     size_t num = 0;
  45     while (std::getline(stream, line))
  46     {
  47         ++num;
  48         line = Trim(line);
  49         std::string::size_type pos = line.find_first_of('#');
  50         if (pos != std::string::npos)
  51             line = line.substr(0, pos);
  52         if (line.empty())
  53             continue;
  54         pos = line.find_first_of('=');
  55         if (pos == std::string::npos)
  56         {
  57             std::ostringstream error;
  58             error << "Bad file format, missing '=' in '" << filePath << ":" << num << "'.";
  59             throw std::runtime_error(error.str().c_str());
  60         }
  61         (obj->*callback)(Trim(line.substr(0, pos)), Trim(line.substr(pos + 1, line.length() - pos - 1)));
  62     }
  63 }
  64
  65 } // namespace anonymous
  66
  67 using SGCONF::OPTION;
  68 using SGCONF::OPTION_BLOCK;
  69 using SGCONF::OPTION_BLOCKS;
  70 using SGCONF::ACTION;
  71 using SGCONF::PARSER_STATE;
  72
  73 OPTION::OPTION(const std::string & shortName,
  74                const std::string & longName,
  75                std::unique_ptr<ACTION> action,
  76                const std::string & description)
  77     : m_shortName(shortName),
  78       m_longName(longName),
  79       m_action(std::move(action)),
  80       m_description(description)
  81 {
  82 }
  83
  84 OPTION::OPTION(const std::string & longName,
  85                std::unique_ptr<ACTION> action,
  86                const std::string & description)
  87     : m_longName(longName),
  88       m_action(std::move(action)),
  89       m_description(description)
  90 {
  91 }
  92
  93 void OPTION::Help(size_t level) const
  94 {
  95     if (!m_action)
  96         throw ERROR("Option is not defined.");
  97     std::string indent(level, '\t');
  98     std::cout << indent;
  99     if (!m_shortName.empty())
 100         std::cout << "-" << m_shortName << ", ";
 101     std::cout << "--" << m_longName << " " << m_action->ParamDescription()
 102               << "\t" << m_description << m_action->DefaultDescription() << "\n";
 103     m_action->Suboptions().Help(level);
 104 }
 105
 106 bool OPTION::Check(const char * arg) const
 107 {
 108     if (arg == NULL)
 109         return false;
 110
 111     if (*arg++ != '-')
 112         return false;
 113
 114     if (*arg == '-')
 115         return m_longName == arg + 1;
 116
 117     return m_shortName == arg;
 118 }
 119
 120 PARSER_STATE OPTION::Parse(int argc, char ** argv, void * data)
 121 {
 122     if (!m_action)
 123         throw ERROR("Option is not defined.");
 124     try
 125     {
 126         return m_action->Parse(argc, argv, data);
 127     }
 128     catch (const ACTION::ERROR & ex)
 129     {
 130         if (m_longName.empty())
 131             throw ERROR("-" + m_shortName + ": " + ex.what());
 132         else
 133             throw m_shortName.empty() ? ERROR("--" + m_longName + ": " + ex.what())
 134                                       : ERROR("--" + m_longName + ", -" + m_shortName + ": " + ex.what());
 135     }
 136 }
 137
 138 void OPTION::ParseValue(const std::string & value)
 139 {
 140     if (!m_action)
 141         throw ERROR("Option is not defined.");
 142     try
 143     {
 144         return m_action->ParseValue(value);
 145     }
 146     catch (const ACTION::ERROR & ex)
 147     {
 148         throw ERROR(m_longName + ": " + ex.what());
 149     }
 150 }
 151
 152 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & shortName,
 153                                  const std::string & longName,
 154                                  std::unique_ptr<ACTION> action,
 155                                  const std::string & description)
 156 {
 157     m_options.emplace_back(shortName, longName, std::move(action), description);
 158     return *this;
 159 }
 160
 161 OPTION_BLOCK & OPTION_BLOCK::Add(const std::string & longName,
 162                                  std::unique_ptr<ACTION> action,
 163                                  const std::string & description)
 164 {
 165     m_options.emplace_back(longName, std::move(action), description);
 166     return *this;
 167 }
 168
 169 void OPTION_BLOCK::Help(size_t level) const
 170 {
 171     if (m_options.empty())
 172         return;
 173     if (!m_description.empty())
 174         std::cout << m_description << ":\n";
 175     for (const auto& option : m_options)
 176         option.Help(level + 1);
 177 }
 178
 179 PARSER_STATE OPTION_BLOCK::Parse(int argc, char ** argv, void * data)
 180 {
 181     PARSER_STATE state(false, argc, argv);
 182     if (state.argc == 0)
 183         return state;
 184     while (state.argc > 0 && !state.stop)
 185     {
 186         const auto it = std::find_if(m_options.begin(), m_options.end(), [&state](const auto& opt){ return opt.Check(*state.argv); });
 187         if (it != m_options.end())
 188             state = it->Parse(--state.argc, ++state.argv, data);
 189         else
 190             break;
 191     }
 192     return state;
 193 }
 194
 195 void OPTION_BLOCK::ParseFile(const std::string & filePath)
 196 {
 197     if (access(filePath.c_str(), R_OK))
 198         throw ERROR("File '" + filePath + "' does not exists.");
 199     ReadConfigFile(filePath, &OPTION_BLOCK::OptionCallback, this);
 200 }
 201
 202 void OPTION_BLOCK::OptionCallback(const std::string & key, const std::string & value)
 203 {
 204     for (auto& option : m_options)
 205         if (option.Name() == key)
 206             option.ParseValue(value);
 207 }
 208
 209 void OPTION_BLOCKS::Help(size_t level) const
 210 {
 211     for (const auto& block : m_blocks)
 212     {
 213         block.Help(level);
 214         std::cout << "\n";
 215     }
 216 }
 217
 218 PARSER_STATE OPTION_BLOCKS::Parse(int argc, char ** argv)
 219 {
 220     PARSER_STATE state(false, argc, argv);
 221     auto it = m_blocks.begin();
 222     while (state.argc > 0 && !state.stop && it != m_blocks.end())
 223     {
 224         state = it->Parse(state.argc, state.argv);
 225         ++it;
 226     }
 227     return state;
 228 }