Using boost::container::small_vector as the storage container.

[avautour]

Much like the boost::interprocess::vector example, I am trying to have an implementation policy that uses boost::container::small_vector and having trouble using it. Small vector is a vector where, up to a given size, the elements are statically allocated, and passed that size, they are dynamically allocated. The main problem seems to be that, unlike std::vector and boost::interprocess::vector, boost::container::small_vector needs to know the size of the template type at template instantiation time. That seems to cause a problem because basic_json needs the array declaration to get at the array::iterator declaration, and the array needs basic_json to figure out the size of the elements for static allocation.

Context is that I am trying to avoid heap allocations for coordinates for large GeoJSON objects that have several coordinates. I have considered using a custom allocator instead to avoid the repeated heap allocations, but I don't really have a good spot to manage the allocation pool and would have preferred simply avoiding the heap altogether for small objects. Worst case, I will likely fallback to the custom pool, but the small vector feels cleaner to me, so I figured I'd ask if anyone has something I hadn't considered to offer.

Any advise as to how I might be able proceed?

#include <boost/container/small_vector.hpp>
#include <jsoncons/basic_json.hpp>

template <class T, class Allocator>
using small_vector = boost::container::small_vector<T, 5, Allocator>;

struct sorted_policy : public jsoncons::sorted_policy
{
    template <class KeyT, class Json>
    using object = jsoncons::sorted_json_object<KeyT, Json, small_vector>;

    template <class Json>
    using array = jsoncons::json_array<Json, small_vector>;
};

using small_json = jsoncons::basic_json<char, sorted_policy, std::allocator<char>>;
small_json myJSON;

[danielaparker]

Interesting idea. The issue appears to be that std::vector<C>::iterator is okay with an incomplete type, but boost::container::small_vector<C,5>::iterator is not.

class C;

using t1 = std::vector<C>::iterator; // OK

using t2 = boost::container::small_vector<C,5>::iterator; // Incomplete type is not allowed

[danielaparker]

Currently, basic_json defines

 using object_iterator = jsoncons::detail::random_access_iterator_wrapper<typename object::iterator>;              

where the iterator wrapper holds an object::iterator.

[avautour]

I managed to get it working. It is not the iterator that needs the type to be fully defined, it is the container itself. Problem is that it is doing the template instantiation of the of container when getting its iterator definition. So, what I did is I moved the array_iterator definition to the implementation policy, so that I can specify the iterator type directly for my case:

    struct sorted_policy 
    {
        // ...

        template <class Json>
        using array = json_array<Json,std::vector>;

        template <class Json>
        using array_iterator = typename array<Json>::iterator;

        template <class Json>
        using const_array_iterator = typename array<Json>::const_iterator;

        // ...
    };

    
    template <class CharT, class ImplementationPolicy, class Allocator>
    class basic_json
    {
    public:
        // ...
        using array_iterator = typename ImplementationPolicy::template array_iterator<basic_json>;
        using const_array_iterator = typename ImplementationPolicy::template const_array_iterator<basic_json>;

and I specified my implementation policy to be:

template <class T, class Allocator>
using small_vector = boost::container::small_vector<T, 5, Allocator>;

struct small_sorted_policy
{
    // ...

    template <class Json>
    using array = jsoncons::json_array<Json, small_vector>;

    template <class Json>
    using json_allocator_type = typename std::allocator_traits<typename Json::allocator_type>:: template rebind_alloc<Json>;

    template <class Json>
    using array_iterator = boost::container::vec_iterator<typename json_allocator_type<Json>::pointer, false>;

    template <class Json>
    using const_array_iterator = boost::container::vec_iterator<typename json_allocator_type<Json>::pointer, false>;

    // ...
};

This is obviously a bit of a hack, so I have no expectations in terms of the library changing to accommodate this. I just wanted to record it in case someone else runs into it.

[avautour]

Oh, I ran into another problem that I feel should be fixed in the library. In json_array.hpp, should the rhs of the equal/less-than operators and swap() include the container. That is, should it be:
bool operator<(const json_array<Json, SequenceContainer>& rhs) const noexcept
?

[danielaparker]

Yes! Thanks. Although in the body of the json_array class, json_array<Json, SequenceContainer> can be written simply as json_array.

Regarding your earlier point, I don't think I'd want to require e.g. SortedPolicy to define iterator types separately from the container. However, for cases like yours, I think we can allow basic_json to define iterator types conditionally, and use the ones defined in the ImplementationPolicy if present (for both array and object types.)

[danielaparker]

These last issues fixed on master