var.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_var_h
#define INCL_evo_var_h

#include "string.h"
#include "substring.h"
#include "list.h"
#include "maplist.h"

#if defined(EVO_CPP11)
    #include <initializer_list>
#endif

namespace evo {


class Var {
public:
    typedef SizeT Size;                         
    typedef MapList<String,Var> ObjectType;     
    typedef List<Var> ListType;                 

    enum Type {
        tOBJECT,    
        tLIST,      
        tSTRING,    
        tFLOAT,     
        tUNSIGNED,  
        tINTEGER,   
        tBOOL,      
        tNULL       
    };

#if defined(EVO_CPP11)

    Var(std::initializer_list<Var> init) : type_(tNULL) {
        assert( init.size() < IntegerT<ListType::Size>::MAX );
        ListType& items = list();
        items.reserve((typename ListType::Size)init.size());
        for (const auto& val : init)
            items.add(val);
    }

    Var(Var&& src) {
        type_ = src.type_;
        switch (type_) {
            case tOBJECT:
                memcpy(buf_obj_, src.buf_obj_, sizeof(ObjectType));
                break;
            case tLIST:
                memcpy(buf_list_, src.buf_list_, sizeof(ListType));
                break;
            case tSTRING:
                memcpy(buf_str_, src.buf_str_, sizeof(String));
                break;
            case tFLOAT:
                buf_float_ = src.buf_float_;
                break;
            case tUNSIGNED:
                buf_uint_ = src.buf_uint_;
                break;
            case tINTEGER:
                buf_int_ = src.buf_int_;
                break;
            case tBOOL:
                buf_bool_ = src.buf_bool_;
                break;
            case tNULL:
                break;
        }
        src.type_ = tNULL;
    }

    Var& operator=(Var&& src) {
        free();
        type_ = src.type_;
        switch (type_) {
            case tOBJECT:
                memcpy(buf_obj_, src.buf_obj_, sizeof(ObjectType));
                break;
            case tLIST:
                memcpy(buf_list_, src.buf_list_, sizeof(ListType));
                break;
            case tSTRING:
                memcpy(buf_str_, src.buf_str_, sizeof(String));
                break;
            case tFLOAT:
                buf_float_ = src.buf_float_;
                break;
            case tUNSIGNED:
                buf_uint_ = src.buf_uint_;
                break;
            case tINTEGER:
                buf_int_ = src.buf_int_;
                break;
            case tBOOL:
                buf_bool_ = src.buf_bool_;
                break;
            case tNULL:
                break;
        }
        src.type_ = tNULL;
        return *this;
    }
#endif

    Var() : type_(tNULL) {
    }

    Var(const Var& src) {
        type_ = src.type_;
        switch (type_) {
            case tOBJECT: {
                const ObjectType* src_ptr = (const ObjectType*)src.buf_obj_;
                new((ObjectType*)buf_obj_) ObjectType(*src_ptr);
                break;
            }
            case tLIST: {
                const ListType* src_ptr = (const ListType*)src.buf_list_;
                new((ListType*)buf_list_) ListType(*src_ptr);
                break;
            }
            case tSTRING: {
                const String* src_ptr = (const String*)src.buf_str_;
                new((String*)buf_str_) String(*src_ptr);
                break;
            }
            case tFLOAT:
                buf_float_ = src.buf_float_;
                break;
            case tUNSIGNED:
                buf_uint_ = src.buf_uint_;
                break;
            case tINTEGER:
                buf_int_ = src.buf_int_;
                break;
            case tBOOL:
                buf_bool_ = src.buf_bool_;
                break;
            case tNULL:
                break;
        }
    }

    Var(const ObjectType& val) : type_(tNULL) {
        object() = val;
    }

    Var(const ListType& val) : type_(tNULL) {
        list() = val;
    }

    Var(const String& val) : type_(tNULL) {
        string() = val;
    }

    Var(const StringBase& val) : type_(tNULL) {
        string() = val;
    }

    Var(const char* val) : type_(tNULL) {
        String& str = string();
        if (val != NULL)
            str = val;
    }

    Var(double val) : type_(tNULL) {
        numf() = val;
    }

    Var(ushort val) : type_(tNULL) {
        numu() = val;
    }

    Var(uint val) : type_(tNULL) {
        numu() = val;
    }

    Var(ulong val) : type_(tNULL) {
        numu() = val;
    }

    Var(ulongl val) : type_(tNULL) {
        numu() = val;
    }

    Var(short val) : type_(tNULL) {
        numi() = val;
    }

    Var(int val) : type_(tNULL) {
        numi() = val;
    }

    Var(long val) : type_(tNULL) {
        numi() = val;
    }

    Var(longl val) : type_(tNULL) {
        numi() = val;
    }

    Var(bool val) : type_(tNULL) {
        boolref() = val;
    }

    Var(ValNull) : type_(tNULL) {
    }

    ~Var() {
        free();
    }

    Type type() const {
        return type_;
    }

    bool is_container() const {
        switch (type_) {
            case tOBJECT:
            case tLIST:
                return true;
            default:
                break;
        }
        return false;
    }

    bool is_object() const {
        return (type_ == tOBJECT);
    }

    bool is_list() const {
        return (type_ == tLIST);
    }

    bool is_string() const {
        return (type_ == tSTRING);
    }

    bool is_number() const {
        switch (type_) {
            case tFLOAT:
            case tUNSIGNED:
            case tINTEGER:
                return true;
            default:
                break;
        }
        return false;
    }

    bool is_float() const {
        return (type_ == tFLOAT);
    }

    bool is_integer() const {
        switch (type_) {
            case tUNSIGNED:
            case tINTEGER:
                return true;
            default:
                break;
        }
        return false;
    }

    bool is_unsigned() const {
        return (type_ == tUNSIGNED);
    }

    bool is_signed() const {
        return (type_ == tINTEGER);
    }

    bool is_bool() const {
        return (type_ == tBOOL);
    }

    bool shared() const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                return p->shared();
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                return p->shared();
            }
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->shared();
            }
            default:
                break;
        }
        return false;
    }

    bool shared_scan() const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                const ObjectType& obj = *p;
                if (obj.shared())
                    return true;
                for (ObjectType::Iter iter(obj); iter; ++iter)
                    if (iter->key().shared() || iter->value().shared_scan())
                        return true;
                break;
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                const ListType& list = *p;
                if (list.shared())
                    return true;
                for (ListType::Iter iter(list); iter; ++iter)
                    if (iter->shared_scan())
                        return true;
                break;
            }
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->shared();
            }
            default:
                break;
        }
        return false;
    }

    bool null() const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                return p->null();
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                return p->null();
            }
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->null();
            }
            case tNULL:
                return true;
            default:
                break;
        }
        return false;
    }

    bool empty() const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                return p->empty();
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                return p->empty();
            }
            default:
                break;
        }
        return true;
    }

    Size size() const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                return p->size();
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                return p->size();
            }
            default:
                break;
        }
        return 0;
    }

    Var& set() {
        free();
        type_ = tNULL;
        return *this;
    }

    Var& clear() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->clear();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->clear();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->clear();
                break;
            }
            case tFLOAT:
                buf_float_ = 0.0;
                break;
            case tUNSIGNED:
                buf_uint_ = 0;
                break;
            case tINTEGER:
                buf_int_ = 0;
                break;
            case tBOOL:
                buf_bool_ = false;
                break;
            default:
                break;
        }
        return *this;
    }

    Var& unshare() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->unshare();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->unshare();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->unshare();
                break;
            }
            default:
                break;
        }
        return *this;
    }

    Var& unshare_all() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                ObjectType& obj = *p;
                obj.unshare();
                for (ObjectType::IterM iter(obj); iter; ++iter) {
                    ((String&)iter->key()).unshare(); // key is const to prevent reordering, need to override const to unshare()
                    iter->value().unshare_all();
                }
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                ListType& list = *p;
                list.unshare();
                for (ListType::IterM iter(list); iter; ++iter)
                    iter->unshare_all();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->unshare();
                break;
            }
            default:
                break;
        }
        return *this;
    }

    const Var& childref(const StringBase& key) const {
        if (type_ == tOBJECT) {
            const ObjectType* p = (ObjectType*)buf_obj_;
            const Var* v = p->find(key);
            if (v != NULL)
                return *v;
        }
        return null_var();
    }

    const Var& childref(Size index) const {
        if (type_ == tLIST) {
            const ListType* l = (ListType*)buf_list_;
            if (l != NULL && index < l->size())
                return l->item(index);
        }
        return null_var();
    }

    const Var* child(const StringBase& key) const {
        if (type_ == tOBJECT) {
            const ObjectType* p = (const ObjectType*)buf_obj_;
            return p->find(key);
        }
        return NULL;
    }

    const Var* child(Size index) const {
        if (type_ == tLIST) {
            const ListType* l = (const ListType*)buf_list_;
            if (l != NULL && index < l->size())
                return &l->item(index);
        }
        return NULL;
    }

    Var* childM(const StringBase& key) {
        if (type_ == tOBJECT) {
            ObjectType* p = (ObjectType*)buf_obj_;
            return p->findM(key);
        }
        return NULL;
    }

    Var* childM(Size index) {
        if (type_ == tLIST) {
            ListType* l = (ListType*)buf_list_;
            return &l->itemM(index);
        }
        return NULL;
    }

    ObjectType& object() {
        ObjectType* ptr = (ObjectType*)buf_obj_;
        switch (type_) {
            case tOBJECT:
                return *ptr;
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            default:
                break;
        }
        type_ = tOBJECT;
        new(ptr) ObjectType();
        ptr->setempty();
        return *ptr;
    }

    ListType& list() {
        ListType* ptr = (ListType*)buf_obj_;
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST:
                return *ptr;
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            default:
                break;
        }
        type_ = tLIST;
        new(ptr) ListType();
        ptr->setempty();
        return *ptr;
    }

    String& string() {
        String* ptr = (String*)buf_str_;
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING:
                return *ptr;
            default:
                break;
        }
        type_ = tSTRING;
        new(ptr) String();
        ptr->setempty();
        return *ptr;
    }

    uint64& numu() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            case tFLOAT: {
                const uint64 num = (uint64)buf_float_;
                type_ = tUNSIGNED;
                buf_uint_ = num;
                return buf_uint_;
            }
            case tINTEGER:
                type_ = tUNSIGNED;
            case tUNSIGNED:
                return buf_uint_;
            case tBOOL:
            case tNULL:
                break;
        }
        type_ = tUNSIGNED;
        buf_uint_ = 0;
        return buf_uint_;
    }

    int64& numi() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            case tFLOAT: {
                const int64 num = (int64)buf_float_;
                type_ = tINTEGER;
                buf_int_ = num;
                return buf_int_;
            }
            case tUNSIGNED:
                type_ = tINTEGER;
            case tINTEGER:
                return buf_int_;
            case tBOOL:
            case tNULL:
                break;
        }
        type_ = tINTEGER;
        buf_int_ = 0;
        return buf_int_;
    }

    double& numf() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            case tFLOAT:
                return buf_float_;
            case tUNSIGNED: {
                const double num = (double)buf_uint_;
                type_ = tFLOAT;
                buf_float_ = num;
                return buf_float_;
            }
            case tINTEGER: {
                const double num = (double)buf_int_;
                type_ = tFLOAT;
                buf_float_ = num;
                return buf_float_;
            }
            case tBOOL:
            case tNULL:
                break;
        }
        type_ = tFLOAT;
        buf_float_ = 0.0;
        return buf_float_;
    }

    bool& boolref() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            case tUNSIGNED:
            case tINTEGER:
            case tFLOAT:
            case tNULL:
                break;
            case tBOOL:
                return buf_bool_;
        }
        type_ = tBOOL;
        buf_bool_ = false;
        return buf_bool_;
    }

    bool get_val(String& val) const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                if (p->null()) {
                    val.set();
                    return true;
                }
                break;
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                if (p->null()) {
                    val.set();
                    return true;
                }
                break;
            }
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                val = *p;
                return true;
            }
            case tFLOAT:
                val.setn(buf_float_);
                return true;
            case tUNSIGNED:
                val.setn(buf_uint_);
                return true;
            case tINTEGER:
                val.setn(buf_int_);
                return true;
            case tBOOL:
                if (buf_bool_)
                    val.set("true", 4);
                else
                    val.set("false", 5);
                return true;
            case tNULL:
                break;
        }
        return false;
    }

    const ObjectType& get_object() const {
        if (type_ != tOBJECT) {
            static const ObjectType DEF;
            return DEF;
        }
        const ObjectType* p = (const ObjectType*)buf_obj_;
        return *p;
    }

    const ListType& get_list() const {
        if (type_ != tLIST) {
            static const ListType DEF;
            return DEF;
        }
        const ListType* p = (const ListType*)buf_list_;
        return *p;
    }

    const String& get_str() const {
        if (type_ != tSTRING) {
            static const String DEF;
            return DEF;
        }
        const String* p = (const String*)buf_str_;
        return *p;
    }

    double get_float() const {
        switch (type_) {
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->getnumf<double>();
            }
            case tFLOAT:
                return buf_float_;
            case tUNSIGNED:
                return (double)buf_uint_;
            case tINTEGER:
                return (double)buf_int_;
            case tBOOL:
                return (double)buf_bool_;
            default:
                break;
        }
        return 0.0;
    }

    uint64 get_uint() const {
        switch (type_) {
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->getnum<uint64>();
            }
            case tFLOAT:
                return (uint64)buf_float_;
            case tUNSIGNED:
            case tINTEGER:
                return buf_uint_;
            case tBOOL:
                return (uint64)buf_bool_;
            default:
                break;
        }
        return 0;
    }

    int64 get_int() const {
        switch (type_) {
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->getnum<int64>();
            }
            case tFLOAT:
                return (int64)buf_float_;
            case tUNSIGNED:
            case tINTEGER:
                return buf_int_;
            case tBOOL:
                return (int64)buf_bool_;
            default:
                break;
        }
        return 0;
    }

    bool get_bool() const {
        switch (type_) {
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                return p->getbool<bool>();
            }
            case tFLOAT:
                return (buf_float_ != 0.0);
            case tUNSIGNED:
            case tINTEGER:
                return (buf_int_ != 0);
            case tBOOL:
                return buf_bool_;
            default:
                break;
        }
        return false;
    }

    Var& operator=(const Var& src) {
        free();
        type_ = src.type_;
        switch (type_) {
            case tOBJECT: {
                const ObjectType* src_p = (const ObjectType*)src.buf_obj_;
                new((ObjectType*)buf_obj_) ObjectType(*src_p);
                break;
            }
            case tLIST: {
                const ListType* src_p = (const ListType*)src.buf_list_;
                new((ListType*)buf_list_) ListType(*src_p);
                break;
            }
            case tSTRING: {
                const String* src_p = (const String*)src.buf_str_;
                new((String*)buf_str_) String(*src_p);
                break;
            }
            case tFLOAT:
                buf_float_ = src.buf_float_;
                break;
            case tUNSIGNED:
                buf_uint_ = src.buf_uint_;
                break;
            case tINTEGER:
                buf_int_ = src.buf_int_;
                break;
            case tBOOL:
                buf_bool_ = src.buf_bool_;
                break;
            case tNULL:
                break;
        }
        return *this;
    }

    Var& operator=(const ObjectType& val) {
        object() = val;
        return *this;
    }

    Var& operator=(const ListType& val) {
        list() = val;
        return *this;
    }

    Var& operator=(const String& val) {
        string() = val;
        return *this;
    }

    Var& operator=(const StringBase& val) {
        string() = val;
        return *this;
    }

    Var& operator=(const char* val) {
        String& str = string();
        if (val == NULL)
            str.clear();
        else
            str = val;
        return *this;
    }

    Var& operator=(double val) {
        numf() = val;
        return *this;
    }

    Var& operator=(ushort val) {
        numu() = val;
        return *this;
    }

    Var& operator=(uint val) {
        numu() = val;
        return *this;
    }

    Var& operator=(ulong val) {
        numu() = val;
        return *this;
    }

    Var& operator=(ulongl val) {
        numu() = val;
        return *this;
    }

    Var& operator=(short val) {
        numi() = val;
        return *this;
    }

    Var& operator=(int val) {
        numi() = val;
        return *this;
    }

    Var& operator=(long val) {
        numi() = val;
        return *this;
    }

    Var& operator=(longl val) {
        numi() = val;
        return *this;
    }

    Var& operator=(bool val) {
        boolref() = val;
        return *this;
    }

    Var& operator=(ValNull) {
        set();
        return *this;
    }

    Var& operator[](const StringBase& key) {
        return object()[key];
    }

    Var& operator[](Size index) {
        return list().addmin(index + 1).itemM(index);
    }

    template<class T>
    T& dump(T& out, const NewlineValue& newline=NL, uint indent=0) const {
        dump_impl(out, newline, indent);
        return out;
    }

private:
    Type type_;

    union {
        // Map/List size not affected by item/value size, sizeof(Var) not yet known
        char buf_obj_[sizeof(MapList<String,char>)];
        char buf_list_[sizeof(List<char>)];
        char buf_str_[sizeof(String)];
        double buf_float_;
        uint64 buf_uint_;
        int64  buf_int_;
        bool   buf_bool_;
    };

    void free() {
        switch (type_) {
            case tOBJECT: {
                ObjectType* p = (ObjectType*)buf_obj_;
                p->~ObjectType();
                break;
            }
            case tLIST: {
                ListType* p = (ListType*)buf_list_;
                p->~ListType();
                break;
            }
            case tSTRING: {
                String* p = (String*)buf_str_;
                p->~String();
                break;
            }
            default:
                break;
        }
    }

    const Var& null_var() const {
        static const Var NULL_VAR;
        return NULL_VAR;
    }

    template<class T>
    void dump_val(T& out, char end_delim) const {
        switch (type_) {
            case tSTRING: {
                const String* p = (const String*)buf_str_;
                const String& str = *p;
                out.writequoted(str.data(), str.size(), end_delim);
                break;
            }
            case tFLOAT:
                out << buf_float_;
                break;
            case tUNSIGNED:
                out << buf_uint_;
                break;
            case tINTEGER:
                out << buf_int_;
                break;
            case tBOOL:
                if (buf_bool_)
                    out.writetext("true", 4);
                else
                    out.writetext("false", 5);
                break;
            case tNULL:
                out.writetext("null", 4);
                break;
            default:
                break; // COV: never happens
        }
    }

    template<class T, class TNL>
    void dump_impl(T& out, const TNL& newline, uint indent, bool first=true) const {
        switch (type_) {
            case tOBJECT: {
                const ObjectType* p = (const ObjectType*)buf_obj_;
                const ObjectType& obj = *p;
                if (obj.empty()) {
                    out << "{}";
                } else {
                    indent += 2;
                    out << '{' << newline;
                    char delim = ',';
                    typename ObjectType::Iter iter(obj);
                    if (iter) {
                        for (;;) {
                            const typename ObjectType::Iter::Item& item = *iter;
                            if (!++iter)
                                delim = '}';

                            out.writechar(' ', indent);
                            const String& key = item.key();
                            out.writequoted(key.data(), key.size(), ':', true);
                            out << ':';

                            const Var& val = item.value();
                            if (val.is_container())
                                val.dump_impl(out, newline, indent, false);
                            else
                                val.dump_val(out, delim);

                            if (delim != ',')
                                break;
                            out << ',' << newline;
                        }
                    }
                    out << newline;
                    indent -= 2;
                    out.writechar(' ', indent);
                    out << '}';
                }
                break;
            }
            case tLIST: {
                const ListType* p = (const ListType*)buf_list_;
                const ListType& list = *p;
                if (list.empty()) {
                    out << "[]";
                } else {
                    out << '[';
                    char delim = ',';
                    typename ListType::Iter iter(list);
                    if (iter) {
                        for (;;) {
                            const Var& val = *iter;
                            if (!++iter)
                                delim = ']';
                            if (val.is_container())
                                val.dump_impl(out, newline, indent, false);
                            else
                                val.dump_val(out, delim);

                            if (delim != ',')
                                break;
                            out << ',';
                        }
                    }
                    out << ']';
                }
                break;
            }
            default:
                dump_val(out, ',');
                break;
        }
        if (first)
            out << newline;
    }
};

#if defined(EVO_CPP11)

class VarObject : public Var {
public:
    struct InitPair {
        String key;     
        Var value;      

        template<class T>
        InitPair(const String& key, const T& value) : key(key), value(value) {
        }

        template<class T>
        InitPair(const StringBase& key, const T& value) : key(key), value(value) {
        }

        template<class T>
        InitPair(const char* key, const T& value) : key(key), value(value) {
        }
    };

    VarObject() {
        object();
    }

    VarObject(std::initializer_list<InitPair> init) {
        assert( init.size() < IntegerT<ObjectType::Size>::MAX );
        ObjectType& map = object();
        map.reserve((typename ObjectType::Size)init.size());
        for (const auto& val : init)
            map[val.key] = val.value;
    }

    VarObject(VarObject&& src) : Var(std::move(src)) {
    }

    Var& operator=(VarObject&& src) {
        return Var::operator=(std::move(src));
    }

    // Disable copying
    VarObject(const VarObject&) = delete;
    VarObject& operator=(const VarObject&) = delete;
};

typedef Var VarList;
#endif

}
#endif