X-Git-Url: http://g0dil.de/git?a=blobdiff_plain;f=senf%2FUtils%2FConsole%2FTraits.hh;h=19565b84e324baefa450057611cbe8eb47885ea5;hb=ea5f02fb88dfab3932368bbafdc863b8ad585cc1;hp=da5eb602b2462b2dbddda9729a5e2dddb233a64e;hpb=601d1f509f5bb24df167a4dd5a20da67a0af9af8;p=senf.git

diff --git a/senf/Utils/Console/Traits.hh b/senf/Utils/Console/Traits.hh
index da5eb60..19565b8 100644
--- a/senf/Utils/Console/Traits.hh
+++ b/senf/Utils/Console/Traits.hh
@@ -30,7 +30,7 @@
 #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"
 
@@ -41,36 +41,6 @@
 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
@@ -130,57 +100,67 @@ namespace console {
     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
 
@@ -219,73 +199,65 @@ namespace console {
 #   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////////////////////////////////////////