kvp-frame.hpp

/********************************************************************\
 * kvp-frame.hpp -- Implements a key-value frame system             *
 * Copyright (C) 2014 Aaron Laws                                    *
 * Copyright 2015 John Ralls                                        *
 *                                                                  *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
\********************************************************************/
#ifndef GNC_KVP_FRAME_TYPE
#define GNC_KVP_FRAME_TYPE
 
#include "kvp-value.hpp"
#include <map>
#include <string>
#include <vector>
#include <cstring>
#include <algorithm>
#include <iostream>
using Path = std::vector<std::string>;
using KvpEntry = std::pair <std::vector <std::string>, KvpValue*>;
 
struct KvpFrameImpl
{
    class cstring_comparer
    {
    public:
    /* Returns true if one is less than two. */
    bool operator()(const char * one, const char * two) const
        {
        auto ret = std::strcmp(one, two) < 0;
        return ret;
        }
    };
    using map_type = std::map<const char *, KvpValue*, cstring_comparer>;
 
    public:
    KvpFrameImpl() noexcept {};
 
    KvpFrameImpl(const KvpFrameImpl &) noexcept;
 
    ~KvpFrameImpl() noexcept;
 
    //KvpValue* set(const char * key, KvpValue* newvalue) noexcept;
    KvpValue* set(Path path, KvpValue* newvalue) noexcept;
    KvpValue* set_path(Path path, KvpValue* newvalue) noexcept;
    std::string to_string() const noexcept;
    std::string to_string(std::string const &) const noexcept;
    std::vector<std::string> get_keys() const noexcept;
 
    KvpValue* get_slot(Path keys) noexcept;
 
    template <typename func_type, typename data_type>
    void for_each_slot_temp(func_type const &, data_type &) const noexcept;
 
    template <typename func_type>
    void for_each_slot_temp(func_type const &) const noexcept;
 
    template <typename func_type, typename data_type>
    void for_each_slot_prefix(std::string const & prefix, func_type const &, data_type &) const noexcept;
 
    template <typename func_type>
    void for_each_slot_prefix(std::string const & prefix, func_type const &) const noexcept;
 
    std::vector <KvpEntry>
    flatten_kvp(void) const noexcept;
 
    bool empty() const noexcept { return m_valuemap.empty(); }
    friend int compare(const KvpFrameImpl&, const KvpFrameImpl&) noexcept;
 
    map_type::iterator begin() { return m_valuemap.begin(); }
    map_type::iterator end() { return m_valuemap.end(); }
 
    private:
    map_type m_valuemap;
 
    KvpFrame * get_child_frame_or_nullptr (Path const &) noexcept;
    KvpFrame * get_child_frame_or_create (Path const &) noexcept;
    void flatten_kvp_impl(std::vector <std::string>, std::vector <KvpEntry> &) const noexcept;
    KvpValue * set_impl (std::string const &, KvpValue *) noexcept;
};
 
template<typename func_type, typename data_type>
void KvpFrame::for_each_slot_prefix(std::string const & prefix,
        func_type const & func, data_type & data) const noexcept
{
    std::for_each (m_valuemap.begin(), m_valuemap.end(),
        [&prefix,&func,&data](const KvpFrameImpl::map_type::value_type & a)
        {
            /* Testing for prefix matching */
            if (strncmp(a.first, prefix.c_str(), prefix.size()) == 0)
                func (&a.first[prefix.size()], a.second, data);
        }
    );
}
 
template <typename func_type>
void KvpFrame::for_each_slot_temp(func_type const & func) const noexcept
{
    std::for_each (m_valuemap.begin(), m_valuemap.end(),
        [&func](const KvpFrameImpl::map_type::value_type & a)
        {
            func (a.first, a.second);
        }
    );
}
 
template <typename func_type, typename data_type>
void KvpFrame::for_each_slot_temp(func_type const & func, data_type & data) const noexcept
{
    std::for_each (m_valuemap.begin(), m_valuemap.end(),
        [&func,&data](const KvpFrameImpl::map_type::value_type & a)
        {
            func (a.first, a.second, data);
        }
    );
}
 
int compare (const KvpFrameImpl &, const KvpFrameImpl &) noexcept;
int compare (const KvpFrameImpl *, const KvpFrameImpl *) noexcept;
#endif