namespace senf {
namespace console {
- /** \brief Customize return value formating
-
- ReturnValueTraits provides return value formatting. The default implementation provided here
- will forward the call directly to senf_console_format_value(). The default implementation of
- that function will write the \a value to \a os using standard iostream formatting.
-
- To customize this behavior for some type, either provide an implementation of
- senf_console_format_value() in the types namespace or provide a specialization of
- ReturnValueTraits.
-
- The output should \e not end in a newline since one is added automatically.
- */
- template <class Type>
- struct ReturnValueTraits
- {
- typedef Type type;
-
- static void format(Type const & value, std::ostream & os);
- ///< Write \a value to \a os
- };
-
- /** \brief Return value formatter
-
- \see ReturnValuetraits
-
- \related ReturnValueTraits
- */
- template <class Type>
- void senf_console_format_value(Type const & value, std::ostream & os);
-
/** \brief Customize argument parsing
ArgumentTraits provides argument parsing, Additionally, this class provides a way to get a
template <class Type>
bool senf_console_parse_argument(ParseCommandInfo::TokensRange const & tokens, Type & out);
+
+ /** \brief Customize return value formating
+
+ ReturnValueTraits provides return value formatting. The default implementation provided here
+ will forward the call directly to senf_console_format_value(). The default implementation of
+ that function will write the \a value to \a os using standard iostream formatting.
+
+ To customize this behavior for some type, either provide an implementation of
+ senf_console_format_value() in the types namespace or provide a specialization of
+ ReturnValueTraits.
+
+ The output should \e not end in a newline since one is added automatically.
+ */
+ template <class Type>
+ struct ReturnValueTraits
+ {
+ typedef Type type;
+
+ static void format(Type const & value, std::ostream & os);
+ ///< Write \a value to \a os
+ };
+
+ /** \brief Return value formatter
+
+ \see ReturnValuetraits
+
+ \related ReturnValueTraits
+ */
+ template <class Type>
+ void senf_console_format_value(Type const & value, std::ostream & os);
+
+
/** \brief Parse token range
This helper will invoke the correct ArgumentTraits::parse function to parse the input tokens
template <class Type>
void format(Type const & value, std::ostream & os);
-#ifndef DOXYGEN
-
- // Parse bool: true/false, yes/no, enabled/disabled, 0/1
- template <>
- struct ArgumentTraits<bool>
- {
- typedef bool type;
- static bool const singleToken = true;
-
- static void parse(ParseCommandInfo::TokensRange const & tokens, bool & out);
- static std::string description();
- static std::string str(bool value);
- };
-
- template <>
- struct ReturnValueTraits<bool>
- {
- typedef bool type;
-
- static void format(bool value, std::ostream & os);
- };
-
- template <>
- struct ArgumentTraits<std::string>
- {
- typedef std::string type;
- static bool const singleToken = true;
-
- static void parse(ParseCommandInfo::TokensRange const & tokens, std::string & out);
- static std::string description();
- static std::string str(std::string const & value);
- };
-
-#endif
-
- /** \brief Format boolean value as \c true / \c false */
- void formatTrueFalse(bool value, std::ostream & os);
-
- /** \brief Format boolean value as \c yes / \c no */
- void formatYesNo(bool value, std::ostream & os);
-
- /** \brief Format boolean value as \c enabled / \c disabled */
- void formatEnabledDisabled(bool value, std::ostream & os);
-
- /** \brief Format boolean value as \c on / \c off */
- void formatOnOff(bool value, std::ostream & os);
-
- /** \brief Format boolean value as \c 1 / \c 0 */
- void formatOneZero(bool value, std::ostream & os);
/** \brief Register enum type for argument parsing
# define SENF_CONSOLE_REGISTER_ENUM_MEMBER(Class, Type, Values) \
SENF_CONSOLE_REGISTER_ENUM_(Class::, Type, Values)
- /** \brief Bit-mask flag argument type
- senf::console::FlagCollection supplies a special argument type for use in registering
- console commands. This argument type is used to represent a bit-mask of single flags.
+ /** \brief Format boolean value as \c true / \c false */
+ void formatTrueFalse(bool value, std::ostream & os);
- \code
- // Function taking a flags argument
- void func(unsigned flags);
-
- // Enum containing all the possible flag values
- enum MyFlags { Foo = 1,
- Bar = 2,
- Baz = 4,
- Doo = 8 };
- SENF_CONSOLE_REGISTER_ENUM(MyFlags, (Foo)(Bar)(Baz)(Boo));
-
- // Register the function with a FlagCollection argument type
- consoleDir.add("func", boost::function<void (FlagCollection<MyFlags>)>(&func));
- \endcode
+ /** \brief Format boolean value as \c yes / \c no */
+ void formatYesNo(bool value, std::ostream & os);
- To use the FlagCollection class
- \li you need a function which takes a bit-mask of flags as argument
- \li you define and register an enum with all possible flag values
- \li you register the function with a FlagCollection argument type using \c boost::function
- for the conversion. This is also possible for return values.
-
- The nice thing is, that \c boot::function supports compatible argument types and does
- automatic type conversion. Since a FlagCollection is convertible to and from unsigned long,
- this conversion will work.
-
- After registering this function, you can call it with a collection of flags as argument
-
- <pre>
- console:/$ help func
- Usage:
- func arg11:MyFlags
- console:/$ func Foo
- console:/$ func (Foo Boo)
- </pre>
- */
- template <class Enum>
- struct FlagCollection
+ /** \brief Format boolean value as \c enabled / \c disabled */
+ void formatEnabledDisabled(bool value, std::ostream & os);
+
+ /** \brief Format boolean value as \c on / \c off */
+ void formatOnOff(bool value, std::ostream & os);
+
+ /** \brief Format boolean value as \c 1 / \c 0 */
+ void formatOneZero(bool value, std::ostream & os);
+
+
+#ifndef DOXYGEN
+
+ // Parse bool: true/false, yes/no, enabled/disabled, 0/1
+ template <>
+ struct ArgumentTraits<bool>
{
- operator unsigned long() const { return value; }
- FlagCollection() : value (0) {}
- FlagCollection(unsigned long value_) : value (value_) {}
- FlagCollection(Enum value_) : value (value_) {}
- unsigned long value;
+ typedef bool type;
+ static bool const singleToken = true;
+
+ static void parse(ParseCommandInfo::TokensRange const & tokens, bool & out);
+ static std::string description();
+ static std::string str(bool value);
};
- template <class Enum>
- struct ArgumentTraits< FlagCollection<Enum> >
+ template <>
+ struct ReturnValueTraits<bool>
{
- typedef FlagCollection<Enum> type;
- static bool const singleToken = false;
- static void parse(ParseCommandInfo::TokensRange const & tokens, type & out);
- static std::string description();
- static std::string str(type const & value);
+ typedef bool type;
+
+ static void format(bool value, std::ostream & os);
};
- template <class Enum>
- struct ReturnValueTraits< FlagCollection<Enum> >
+ template <>
+ struct ArgumentTraits<std::string>
{
- typedef FlagCollection<Enum> type;
- static void format(type const & value, std::ostream & os);
+ typedef std::string type;
+ static bool const singleToken = true;
+
+ static void parse(ParseCommandInfo::TokensRange const & tokens, std::string & out);
+ static std::string description();
+ static std::string str(std::string const & value);
};
+ template <> struct ArgumentTraits<char> : public detail::CharArgumentTraits<char> {};
+ template <> struct ReturnValueTraits<char> : public detail::CharReturnValueTraits<char> {};
+ template <> struct ArgumentTraits<signed char> : public detail::CharArgumentTraits<signed char> {};
+ template <> struct ReturnValueTraits<signed char> : public detail::CharReturnValueTraits<signed char> {};
+ template <> struct ArgumentTraits<unsigned char> : public detail::CharArgumentTraits<unsigned char> {};
+ template <> struct ReturnValueTraits<unsigned char> : public detail::CharReturnValueTraits<unsigned char> {};
+
+#endif
+
}}
///////////////////////////////hh.e////////////////////////////////////////