File Coverage

src/xs/typemap/containers.h

Criterion	Covered	Total	%
statement	26	26	100.0
branch	44	76	57.8
condition			n/a
subroutine			n/a
pod			n/a
total	70	102	68.6

#pragma once
#include "base.h"
#include "../Hash.h"
#include "../Array.h"
#include "../Simple.h"
#include
#include
#include

namespace xs {

namespace typemap { namespace containers {
    inline const panda::string& to_key (const panda::string& value) { return value; }
    inline panda::string_view   to_key (const std::string& value)   { return panda::string_view(value.data(), value.size()); }

    template
    panda::string to_key (T&& value) { return panda::to_string(std::forward(value)); }
}}

template  struct VectorTypemap : TypemapBase> {
    static Sv out(const std::vector& data, const Sv& = {}){
        auto out = Array::create(data.size());
        for(const auto& i : data){
            out.push(xs::out(i));
        }
        return Ref::create(out);
    }

    static std::vector in (Array arg){
        std::vector out;
        out.reserve(arg.size());
        for(const auto& i : arg){
            out.emplace_back(xs::in(i));
        }
        return out;
    }
};

template  struct Typemap> : VectorTypemap {};

template  struct Typemap, std::map> : TypemapBase> {
    static Sv out (const std::map& data, const Sv& = {}) {
        auto out = Hash::create(data.size());
        for(const auto& i : data){
            auto key = typemap::containers::to_key(i.first);
            out.store(key, xs::out(i.second));
        }
        return Ref::create(out);
    }

    static std::map in (Hash arg) {
        std::map out;
        for (const auto& element : arg){
            K key = xs::in(Simple(element.key()));
            V value = xs::in(element.value());
            out.emplace(key, value);
        }
        return out;
    }
};

template  struct Typemap, std::unordered_map> : TypemapBase> {
    static Sv out (const std::unordered_map& data, const Sv& = {}) {
        auto out = Hash::create(data.size());
        for(const auto& i : data){
            auto key = typemap::containers::to_key(i.first);
            out.store(key, xs::out(i.second));
        }
        return Ref::create(out);
    }

    static std::unordered_map in (Hash arg) {
        std::unordered_map out;
        for (const auto& element : arg){
            K key = xs::in(Simple(element.key()));
            V value = xs::in(element.value());
            out.emplace(key, value);
        }
        return out;
    }

};

}