functionView.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
#ifndef _STRUS_ANALYZER_FUNCTION_VIEW_HPP_INCLUDED
#define _STRUS_ANALYZER_FUNCTION_VIEW_HPP_INCLUDED
#include "strus/base/enable_if.hpp"
#include "strus/base/type_traits.hpp"
#include "strus/numericVariant.hpp"
#include <string>
#include <vector>
#include <map>
#include <iostream>
#include <sstream>

namespace strus {
namespace analyzer {

class FunctionView
{
public:
        typedef std::pair<std::string,std::string> NamedParameter;

        FunctionView(){}
        FunctionView( const FunctionView& o)
                :m_name(o.m_name),m_parameter(o.m_parameter){}
        FunctionView( const std::string& name_, const std::vector<NamedParameter>& params_)
                :m_name(name_),m_parameter(params_){}
        explicit FunctionView( const std::string& name_)
                :m_name(name_),m_parameter(){}

        template<typename type>
        struct is_atomic
        {
                typename strus::enable_if<
                        strus::is_arithmetic<type>::value
                        || strus::is_same<bool,type>::value
                        || strus::is_same<std::string,type>::value
                        || strus::is_same<char*,type>::value
                ,bool> value_type;
                enum {value=sizeof(value_type)};
        };

        template <typename value_type>
        typename strus::enable_if<is_atomic<value_type>::value,FunctionView&>::type operator()( const char* name_, const value_type& value_)
        {
                std::ostringstream out;
                out << value_;
                m_parameter.push_back( NamedParameter( name_, out.str()));
                return *this;
        }

        template <typename value_type>
        typename strus::enable_if<is_atomic<value_type>::value,FunctionView&>::type operator()( const char* name_, const std::map<std::string,value_type>& value_)
        {
                typename std::map<std::string,value_type>::const_iterator vi = value_.begin(), ve = value_.end();
                for (; vi != ve; ++vi)
                {
                        std::ostringstream out;
                        out << vi->second;
                        m_parameter.push_back( NamedParameter( std::string(name_)+"::"+vi->first, out.str()));
                }
                return *this;
        }

        template <typename value_type>
        typename strus::enable_if<is_atomic<value_type>::value,FunctionView&>::type operator()( const char* name_, const std::vector<value_type>& value_)
        {
                typename std::vector<value_type>::const_iterator vi = value_.begin(), ve = value_.end();
                for (; vi != ve; ++vi)
                {
                        std::ostringstream out;
                        out << *vi;
                        m_parameter.push_back( NamedParameter( std::string("[]")+name_, out.str()));
                }
                return *this;
        }

        template <typename value_type>
        typename strus::enable_if<strus::is_same<NumericVariant,value_type>::value,FunctionView&>::type operator()( const char* name_, const value_type& value_)
        {
                std::ostringstream out;
                out << value_.tostring().c_str();
                m_parameter.push_back( NamedParameter( name_, out.str()));
                return *this;
        }

        const std::string& name() const                         {return m_name;}

        const std::vector<NamedParameter>& parameter() const    {return m_parameter;}

private:
        std::string m_name;
        std::vector<NamedParameter> m_parameter;
};

}}//namespace
#endif