// $Id$
//
-// Copyright (C) 2008
+// Copyright (C) 2008
// Fraunhofer Institute for Open Communication Systems (FOKUS)
// Competence Center NETwork research (NET), St. Augustin, GERMANY
// Stefan Bund <g0dil@berlios.de>
#include <iostream>
#include <boost/intrusive_ptr.hpp>
#include <boost/type_traits/is_same.hpp>
-#include "../../Utils/intrusive_refcount.hh"
+#include <senf/Utils/intrusive_refcount.hh>
#include "Parse.hh"
-#include "Node.hh"
#include "Traits.ih"
//#include "Traits.mpp"
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
string-description of a type and to convert a value back into it's string representation
used to display default values.
-
- The default implementation provided here
+
+ The default implementation provided here
\li will use senf_console_parse_argument() to parse a value. This functions default
implementation uses \c boost::lexical_cast and thereby \c iostreams to convert an
argument consisting of a single input token into the required type.
\li will name types by returning the last component of the fully scoped name (e.g. \c
- "string" for \c std::string).
+ "string" for \c std::string).
\li Will format values (for default value display) by forwarding the value to the
ReturnValueTraits of that type.
{
typedef Type type;
- static bool const singleToken =
+ static bool const singleToken =
boost::is_same< typeof(senf_console_parse_argument(
*static_cast<ParseCommandInfo::TokensRange const *>(0),
*static_cast<Type*>(0))),
template <class Type>
bool senf_console_parse_argument(ParseCommandInfo::TokensRange const & tokens, Type & out);
- /** \brief Parse token range
- This helper will invoke the correct ArgumentTraits::parse function to parse the input tokens
- into the passed in variable.
+ /** \brief Customize return value formating
- \see ArgumentTraits
+ 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>
- void parse(ParseCommandInfo::TokensRange const & tokens, Type & out);
+ 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 format(Type const & value, std::ostream & os);
+ void senf_console_format_value(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;
+ /** \brief Parse token range
- static void parse(ParseCommandInfo::TokensRange const & tokens, bool & out);
- static std::string description();
- static std::string str(bool value);
- };
+ This helper will invoke the correct ArgumentTraits::parse function to parse the input tokens
+ into the passed in variable.
- template <>
- struct ReturnValueTraits<bool>
- {
- typedef bool type;
+ \see ArgumentTraits
+ */
+ template <class Type>
+ void parse(ParseCommandInfo::TokensRange const & tokens, Type & out);
- static void format(bool value, std::ostream & os);
- };
+ /** \brief Format value
-#endif
+ This helper will call the correct ArgumentTraits::str function to format \a value
- /** \brief Format boolean value as \c true / \c false */
- void formatTrueFalse(bool value, std::ostream & os);
+ \see ArgumentTraits
+ */
+ template <class Type>
+ std::string str(Type const & value);
- /** \brief Format boolean value as \c yes / \c no */
- void formatYesNo(bool value, std::ostream & os);
+ /** \brief Format return value
- /** \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);
+ This helper will invoke the correct ReturnValueTraits::format function to write \a value
+ into the \a out stream.
+
+ \see ReturnValueTraits
+ */
+ template <class Type>
+ void format(Type const & 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
- Enum types need to be registered explicitly to support parsing.
+ Enum types need to be registered explicitly to support parsing.
\code
enum Foo { Foo1, Foo2 };
SENF_CONSOLE_REGISTER_ENUM( Foo, (Foo1)(Foo2) );
This macro will register an enum type and it's enumerators defined at namespace scope. See
\ref SENF_CONSOLE_REGISTER_ENUM_MEMBER to register a member enum type.
- \note All enumerator values must be unique ignoring case.
+ By default, the keys used to represent the enumerator values in the console are identical to
+ the enumerator names in C++ (In the example above \c Foo1 and \c Foo2). You may however
+ override this default key using the
+ '<tt>key("</tt><i>key</i><tt>", </tt><i>enumerator</i><tt>)</tt>' modifier:
+ \code
+ enum Foo { Foo1, Foo2 };
+ SENF_CONSOLE_REGISTER_ENUM( Foo, (key("1", Foo1), Foo2) );
+ \endcode
+ This will register the first enumerator \c Foo1 under the name '\c 1'.
+
+ \note All enumerator keys must be unique ignoring case.
The enum parser will accept any unique initial substring ignoring case as valid enum value.
/** \brief Register enum type for argument parsing
- Enum types need to be registered explicitly to support parsing.
+ Enum types need to be registered explicitly to support parsing.
\code
class SomeClass
{
# 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);
+
+ /** \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);
- 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
- {
- operator unsigned long() const { return value; }
- FlagCollection() : value (0) {}
- FlagCollection(unsigned long value_) : value (value_) {}
- FlagCollection(Enum value_) : value (value_) {}
- unsigned long value;
- };
- template <class Enum>
- struct ArgumentTraits< FlagCollection<Enum> >
+#ifndef DOXYGEN
+
+ // Parse bool: true/false, yes/no, enabled/disabled, 0/1
+ template <>
+ struct ArgumentTraits<bool>
{
- typedef FlagCollection<Enum> type;
- static bool const singleToken = false;
- static void parse(ParseCommandInfo::TokensRange const & tokens, type & out);
+ 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(type const & value);
+ static std::string str(bool value);
};
- template <class Enum>
- struct ReturnValueTraits< FlagCollection<Enum> >
+ template <>
+ struct ReturnValueTraits<bool>
{
- typedef FlagCollection<Enum> type;
- static void format(type const & value, std::ostream & os);
+ typedef bool type;
+
+ static void format(bool value, std::ostream & os);
};
+ 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////////////////////////////////////////
projects / senf.git / blobdiff