FlagsPrivate.h

Go to the documentation of this file.

/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 *
 * FlagsPrivate.h
 * Command line flag (option) handling.
 * Copyright (C) 2013 Simon Newton
 */

#ifndef INCLUDE_OLA_BASE_FLAGSPRIVATE_H_
#define INCLUDE_OLA_BASE_FLAGSPRIVATE_H_

#include <getopt.h>
#include <string.h>
#include <ola/StringUtils.h>
#include <ola/base/Macro.h>
#include <map>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

namespace ola {

class FlagInterface {
 public:
 virtual ~FlagInterface() {}

 virtual const char* name() const = 0;

 virtual char short_opt() const = 0;

 virtual bool has_arg() const = 0;

 virtual const char* arg_type() const = 0;

 virtual std::string help() const = 0;

 virtual bool present() const = 0;

 virtual bool SetValue(const std::string &input) = 0;
};

class BaseFlag : public FlagInterface {
 public:
 BaseFlag(const char *arg_type, const char *short_opt, const char *help)
 : m_arg_type(arg_type),
 m_short_opt(short_opt[0]),
 m_help(help),
 m_present(false) {
 }

 char short_opt() const { return m_short_opt; }
 const char* arg_type() const { return m_arg_type; }
 std::string help() const { return m_help; }
 bool present() const { return m_present; }

 void MarkAsPresent() { m_present = true; }

 protected:
 void ReplaceUnderscoreWithHyphen(char *input);
 const char* NewCanonicalName(const char *name);

 private:
 const char *m_arg_type;
 char m_short_opt;
 const char *m_help;
 bool m_present;
};

template <typename T>
class Flag : public BaseFlag {
 public:
 Flag(const char *name, const char *arg_type, const char *short_opt,
 T default_value, const char *help,
 OLA_UNUSED const bool has_arg)
 : BaseFlag(arg_type, short_opt, help),
 m_name(name),
 m_default(default_value),
 m_value(default_value) {
 m_name = NewCanonicalName(name);
 }

 ~Flag() {
 delete[] m_name;
 }

 const char *name() const { return m_name; }
 bool has_arg() const { return true; }
 bool default_value() const { return m_default; }

 operator T() const { return m_value; }

 Flag &operator=(T v) {
 m_value = v;
 return *this;
 }

 bool SetValue(const std::string &input);

 private:
 const char *m_name;
 T m_default;
 T m_value;
};

template<>
class Flag<bool> : public BaseFlag {
 public:
 Flag(const char *name, const char *arg_type, const char *short_opt,
 bool default_value, const char *help, const bool has_arg)
 : BaseFlag(arg_type, short_opt, help),
 m_name(name),
 m_default(default_value),
 m_value(default_value),
 m_has_arg(has_arg) {
 if (!has_arg && default_value) {
 // prefix the long option with 'no'
 size_t prefix_size = strlen(NO_PREFIX);
 size_t name_size = strlen(name);
 char* new_name = new char[prefix_size + name_size + 1];
 memcpy(new_name, NO_PREFIX, prefix_size);
 memcpy(new_name + prefix_size, name, name_size);
 new_name[prefix_size + name_size] = 0;
 ReplaceUnderscoreWithHyphen(new_name);
 m_name = new_name;
 } else {
 m_name = NewCanonicalName(name);
 }
 }

 ~Flag() {
 delete[] m_name;
 }

 const char *name() const { return m_name; }
 bool has_arg() const { return m_has_arg; }
 bool default_value() const { return m_default; }

 operator bool() const { return m_value; }

 Flag &operator=(bool v) {
 m_value = v;
 return *this;
 }

 bool SetValue(const std::string &input) {
 MarkAsPresent();
 if (m_has_arg) {
 return ola::StringToBoolTolerant(input, &m_value);
 } else {
 m_value = !m_default;
 return true;
 }
 }

 private:
 const char *m_name;
 bool m_default;
 bool m_value;
 bool m_has_arg;

 static const char NO_PREFIX[];
};

template<>
class Flag<std::string> : public BaseFlag {
 public:
 Flag(const char *name, const char *arg_type, const char *short_opt,
 std::string default_value, const char *help,
 OLA_UNUSED const bool has_arg)
 : BaseFlag(arg_type, short_opt, help),
 m_name(name),
 m_default(default_value),
 m_value(default_value) {
 m_name = NewCanonicalName(name);
 }

 ~Flag() {
 delete[] m_name;
 }

 const char *name() const { return m_name; }
 bool has_arg() const { return true; }
 std::string default_value() const { return m_default; }
 const char* arg_type() const { return "string"; }

 operator const char*() const { return m_value.c_str(); }
 operator std::string() const { return m_value; }
 std::string str() const { return m_value; }

 Flag &operator=(const std::string &v) {
 m_value = v;
 return *this;
 }

 bool SetValue(const std::string &input) {
 MarkAsPresent();
 m_value = input;
 return true;
 }

 private:
 const char *m_name;
 std::string m_default;
 std::string m_value;
};

template <typename T>
bool Flag<T>::SetValue(const std::string &input) {
 MarkAsPresent();
 return ola::StringToInt(input, &m_value, true);
}


class FlagRegistry {
 public:
 FlagRegistry() {}

 void RegisterFlag(FlagInterface *flag);
 void ParseFlags(int *argc, char **argv);

 void SetFirstLine(const std::string &help);
 void SetDescription(const std::string &help);
 void DisplayUsage();
 void DisplayVersion();
 void GenManPage();

 private:
 typedef std::map<std::string, FlagInterface*> LongOpts;
 typedef std::map<char, FlagInterface*> ShortOpts;
 typedef std::map<int, FlagInterface*> FlagMap;
 // <flag, description>
 typedef std::pair<std::string, std::string> OptionPair;

 LongOpts m_long_opts;
 ShortOpts m_short_opts;
 std::string m_argv0;
 std::string m_first_line;
 std::string m_description;

 std::string GetShortOptsString() const;
 struct option *GetLongOpts(FlagMap *flag_map);
 void PrintFlags(std::vector<std::string> *lines);
 void PrintManPageFlags(std::vector<OptionPair> *lines);
};

FlagRegistry *GetRegistry();

class FlagRegisterer {
 public:
 explicit FlagRegisterer(FlagInterface *flag) {
 GetRegistry()->RegisterFlag(flag);
 }

 FlagRegisterer(FlagInterface *flag, char *short_opt) {
 *short_opt = flag->short_opt();
 GetRegistry()->RegisterFlag(flag);
 }
};

} // namespace ola

#define DECLARE_flag(type, name) \
 namespace ola_flags { extern ola::Flag<type> FLAGS_##name; } \
 using ola_flags::FLAGS_##name;

#define DEFINE_flag(type, name, short_opt, default_value, help_str, \
 has_arg) \
 namespace ola_flags { \
 ola::Flag<type> FLAGS_##name(#name, #type, #short_opt, default_value, \
 help_str, has_arg); \
 ola::FlagRegisterer flag_registerer_##name(&FLAGS_##name); \
 } \
 using ola_flags::FLAGS_##name

#define DEFINE_flag_with_short(type, name, short_opt, default_value, help_str, \
 has_arg) \
 namespace ola_flags { char flag_short_##short_opt = 0; } \
 namespace ola_flags { \
 ola::Flag<type> FLAGS_##name(#name, #type, #short_opt, default_value, \
 help_str, has_arg); \
 ola::FlagRegisterer flag_registerer_##name( \
 &FLAGS_##name, &flag_short_##short_opt); \
 } \
 using ola_flags::FLAGS_##name

#endif // INCLUDE_OLA_BASE_FLAGSPRIVATE_H_