Traits.hh

Go to the documentation of this file.

//
// Copyright (c) 2020 Fraunhofer Institute for Applied Information Technology (FIT)
//                    Network Research Group (NET)
//                    Schloss Birlinghoven, 53754 Sankt Augustin, GERMANY
//                    Contact: support@wiback.org
//
// This file is part of the SENF code tree.
// It is licensed under the 3-clause BSD License (aka New BSD License).
// See LICENSE.txt in the top level directory for details or visit
// https://opensource.org/licenses/BSD-3-Clause
//


#ifndef HH_SENF_Utils_Console_Traits_
#define HH_SENF_Utils_Console_Traits_ 1

// Custom includes
#include <ostream>
#include <boost/type_traits/is_same.hpp>
#include <boost/typeof/typeof.hpp>
#include "Parse.hh"

#include "Traits.ih"
//-/////////////////////////////////////////////////////////////////////////////////////////////////

namespace senf {
namespace console {

    template <class Type>
    struct ArgumentTraits
    {
        typedef Type type;

        static bool const singleToken =
            boost::is_same< decltype(senf_console_parse_argument(
                                       *static_cast<ParseCommandInfo::TokensRange const *>(0),
                                       *static_cast<Type*>(0))),
                            bool >::value;

        static void parse(ParseCommandInfo::TokensRange const & tokens, Type & out);

        static std::string description(); 

        static std::string str(Type const & value); 

    };

    template <class Type>
    bool senf_console_parse_argument(ParseCommandInfo::TokensRange const & tokens, Type & out);


    template <class Type>
    struct ReturnValueTraits
    {
        typedef Type type;

        static void format(Type const & value, std::ostream & os);
    };

    template <class Type>
    void senf_console_format_value(Type const & value, std::ostream & os);


    template <class Type>
    void parse(ParseCommandInfo::TokensRange const & tokens, Type & out);

    template <class Type>
    std::string str(Type const & value);

    template <class Type>
    void format(Type const & value, std::ostream & os);


#   define SENF_CONSOLE_REGISTER_ENUM(Type, Values)                                     \
        SENF_CONSOLE_REGISTER_ENUM_(BOOST_PP_EMPTY(), BOOST_PP_EMPTY(), Type, Values)

#   define SENF_CONSOLE_REGISTER_STRONG_ENUM(Type, Values)                              \
        SENF_CONSOLE_REGISTER_ENUM_(BOOST_PP_EMPTY(), Type::, Type, Values)

#   define SENF_CONSOLE_REGISTER_ENUM_MEMBER(Class, Type, Values)                       \
        SENF_CONSOLE_REGISTER_ENUM_(Class::, BOOST_PP_EMPTY(), Type, Values)

#   define SENF_CONSOLE_REGISTER_STRONG_ENUM_MEMBER(Class, Type, Values)                \
        SENF_CONSOLE_REGISTER_ENUM_(Class::, Type::, Type, Values)


    void formatTrueFalse(bool value, std::ostream & os);

    void formatYesNo(bool value, std::ostream & os);

    void formatEnabledDisabled(bool value, std::ostream & os);

    void formatOnOff(bool value, std::ostream & os);

    void formatOneZero(bool value, std::ostream & os);


#   define SENF_CONSOLE_PARSE_AS_TUPLE( Type, Members )                                 \
        SENF_CONSOLE_PARSE_AS_TUPLE_(Type, Members)

#   define SENF_CONSOLE_FORMAT_AS_TUPLE( Type, Members )                                \
        SENF_CONSOLE_FORMAT_AS_TUPLE_(Type, Members)

#   define SENF_CONSOLE_PARSE_AND_FORMAT_AS_TUPLE( Type, Members )                      \
        SENF_CONSOLE_PARSE_AS_TUPLE_(Type, Members);                                    \
        SENF_CONSOLE_FORMAT_AS_TUPLE_(Type, Members);

#   define SENF_CONSOLE_PARSE_AS_MAP( Type, KeyMemberTuples )                           \
        SENF_CONSOLE_PARSE_AS_MAP_(Type, KeyMemberTuples)

#   define SENF_CONSOLE_FORMAT_AS_MAP( Type, KeyMemberTuples )                          \
        SENF_CONSOLE_FORMAT_AS_MAP_(Type, KeyMemberTuples)

#   define SENF_CONSOLE_PARSE_AND_FORMAT_AS_MAP( Type, KeyMemberTuples )                \
        SENF_CONSOLE_PARSE_AS_MAP_(Type, KeyMemberTuples);                              \
        SENF_CONSOLE_FORMAT_AS_MAP_(Type, KeyMemberTuples);

#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<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

}}

//-/////////////////////////////////////////////////////////////////////////////////////////////////
#include "Traits.cci"
#include "Traits.ct"
#include "Traits.cti"
#endif


// Local Variables:
// mode: c++
// fill-column: 100
// comment-column: 40
// c-file-style: "senf"
// indent-tabs-mode: nil
// ispell-local-dictionary: "american"
// compile-command: "scons -u test"
// End: