tag_dealer.hpp

Go to the documentation of this file.

/*
Copyright© 2014 Akihiro Nishimura

This software is released under the MIT License.
http://opensource.org/licenses/mit-license.php
*/

#ifndef SIG_UTIL_TAGDEALER_HPP
#define SIG_UTIL_TAGDEALER_HPP

#include "../functional/high_order.hpp"
#include "../string/manipulate.hpp"

namespace sig
{
namespace impl
{
    template <class S> struct space{};
    template <> struct space<std::string>{ std::string operator()() const{ return " "; } };
    template <> struct space<std::wstring>{ std::wstring operator()() const{ return L" "; } };
}


template <class S>
class TagDealer
{
    const S tel_;
    const S ter_;

public:
    TagDealer(S tag_encloser_left, S tag_encloser_right) : tel_(tag_encloser_left), ter_(tag_encloser_right){};

    S encode(S const& src, S const& tag) const{
        auto tag_str = tel_ + tag + ter_;
        return tag_str + src + tag_str;
    }

    auto decode(S const& src, S const& tag) ->Maybe<S> const{
        auto tag_str = tel_ + tag + ter_;
        auto parse = split(impl::space<S>()() + src, tag_str);

        return parse.size() < 2 ? Nothing(S()) : Just<S>(parse[1]);
    }

    template < template < class T_, class Allocator = std::allocator<T_>> class Container >
    S encode(Container<S> const& src, Container<S> const& tag) const;

    template < template < class T_, class Allocator = std::allocator<T_>> class Container >
    auto decode(S const& src, Container<S> const& tag)->Maybe<Container<S>> const;

};

template <class S>
template < template < class T_, class Allocator = std::allocator<T_>> class Container >
S TagDealer<S>::encode(Container<S> const& src, Container<S> const& tag) const
{
    auto calc = zipWith([&](typename Container<S>::value_type s, typename Container<S>::value_type t){ return encode(s, t); }, src, tag);
    return std::accumulate(calc.begin(), calc.end(), S());
}

template <class S>
template < template < class T_, class Allocator = std::allocator<T_>> class Container >
auto TagDealer<S>::decode(S const& src, Container<S> const& tag) ->Maybe<Container<S>> const
{
    Container<S> result;
    for (auto const& e : tag){
        auto d = decode(src, e);
        if (sig::isJust(d)) result.push_back(sig::fromJust(std::move(d)));
    }
    return result.empty() ? Nothing(result) : Just<Container<S>>(std::move(result));
}

}

#endif