sag_connectivity_cpp.hpp

Go to the documentation of this file.

/*
 * Title:        sag_connectivity_cpp.hpp
 * Description:  C++ header-only wrapper for C-ABI data_t type
 * $Copyright (c) 2015-2016 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 * @Version:     $Id: sag_connectivity_cpp.hpp 287769 2016-07-28 14:08:05Z matj $
 */

#ifndef _CPPMESSAGEDATA_H_
#define _CPPMESSAGEDATA_H_

#include <sag_connectivity_c.h>
#include <algorithm>
#include <stdexcept>
#include <cstddef>
#include <stddef.h>
#include <assert.h>
#include <string>
#include <sstream>
#include <typeinfo>
#include <string.h>

/*
 * C++ API for manipulating data in Connectivity plugins.
 *
 * This uses a C ABI under the hood, but should be manipulated via the classes
 * in this file.
 */

namespace com { 
namespace softwareag {
namespace connectivity { 

class list_t;
class map_t;
class buffer_t;
template<typename T> class custom_t;
typedef sag_underlying_decimal_t decimal_t;

class data_t: protected sag_underlying_data_t
{
        friend class map_t;
        friend class list_t;
        friend class Message;
public:

        data_t()
        {
                memset(this, 0, sizeof(sag_underlying_data_t));
                tag = SAG_DATA_EMPTY;
        }
        data_t(data_t &&other)
        {
                memset(this, 0, sizeof(sag_underlying_data_t));
                tag = SAG_DATA_EMPTY;
                swap(std::move(other));
        }

        void swap(data_t &&other);

        data_t &operator=(data_t &&other)
        {
                data_t tmp(std::move(other));
                swap(std::move(tmp));
                return *this;
        }

        ~data_t();

        bool empty() const { return tag == SAG_DATA_EMPTY; }

        data_t copy() const;

        bool operator==(const data_t &other) const;
        bool operator!=(const data_t &other) const { return !operator==(other); }

        template<typename V>
        typename V::result_type apply_visitor(const V &v) const;
        template<typename V>
        typename V::result_type apply_visitor(const V &v);

        const char *type_name() const
        {
                switch (tag) {
                        case SAG_DATA_EMPTY: return "empty";
                        case SAG_DATA_BOOLEAN: return "boolean";
                        case SAG_DATA_DOUBLE: return "double";
                        case SAG_DATA_INTEGER: return "integer";
                        case SAG_DATA_DECIMAL: return "decimal";
                        case SAG_DATA_STRING: return "string";
                        case SAG_DATA_LIST: return "list";
                        case SAG_DATA_MAP: return "map";
                        case SAG_DATA_BUFFER: return "buffer";
                        case SAG_DATA_CUSTOM: return "custom";
                        default:
                                assert(false); // shouldn't happen
                                return "Unknown";
                }
        }

        sag_data_tag type_tag() const { return tag; }

private:
        data_t(const data_t &other) { abort(); }
        data_t &operator=(const data_t &other) { abort(); }
public:
        
        explicit data_t(int64_t d)
        {
                tag = SAG_DATA_INTEGER;
                integer = d;
        }
        data_t &operator=(int64_t d)
        {
                data_t tmp(d);
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(bool b)
        {
                tag = SAG_DATA_BOOLEAN;
                boolean = b;
        }
        data_t &operator=(bool b)
        {
                data_t tmp(b);
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(double d)
        {
                tag = SAG_DATA_DOUBLE;
                fp = d;
        }
        data_t &operator=(double d)
        {
                data_t tmp(d);
                swap(std::move(tmp));
                return *this;
        }
        template<typename T>
        explicit data_t(custom_t<T> &&d);

        template<typename T>
        data_t &operator=(custom_t<T> &&d)
        {
                data_t tmp(std::move(d));
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(decimal_t d)
        {
                tag = SAG_DATA_DECIMAL;
                decimal = d;
        }
        data_t &operator=(decimal_t d)
        {
                data_t tmp(d);
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(const char *s, size_t n);
        explicit data_t(const char *s);
        explicit data_t(const std::string &s);
        data_t &operator=(const char *s)
        {
                data_t tmp(s);
                swap(std::move(tmp));
                return *this;
        }

        data_t &operator=(const std::string &s)
        {
                data_t tmp(s);
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(list_t &&d);
        data_t &operator=(list_t &&d)
        {
                data_t tmp(std::move(d));
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(map_t &&d);
        data_t &operator=(map_t &&d)
        {
                data_t tmp(std::move(d));
                swap(std::move(tmp));
                return *this;
        }
        explicit data_t(buffer_t &&d);
        data_t &operator=(buffer_t &&d)
        {
                data_t tmp(std::move(d));
                swap(std::move(tmp));
                return *this;
        }
};

template<typename V>
inline typename V::result_type apply_visitor(const V&v, data_t& t) { return t.apply_visitor(v); }
template<typename V>
inline typename V::result_type apply_visitor(const V&v, const data_t& t) { return t.apply_visitor(v); }

template<typename T>
class custom_t: public sag_underlying_custom_t
{
        typedef custom_t this_t;
public:
        custom_t();
        custom_t(T *payload);
        ~custom_t();
        T *get() { return this->data ? reinterpret_cast<T*>(this->data->custom) : 0; }
        const T *get() const { return this->data ? reinterpret_cast<T*>(this->data->custom) : 0; }
        custom_t(custom_t &&other);
        custom_t &operator=(custom_t &&other);
        void swap(custom_t &&other);
        custom_t copy() const;
        T &operator*() { return *get(); }
        const T &operator*() const { return *get(); }
        T *operator->() { return get(); }
        const T *operator->() const { return get(); }
private:
        static void deleter(void *d) 
        {
                if (d) {
                        try {
                                delete reinterpret_cast<T*>(d); 
                        } catch (...) {
                                // enforce nothrow behaviour
                                abort();
                        }
                }
        }
        static void *copier(void *d)
        {
                try {
                        return d ? new T(*reinterpret_cast<T*>(d)) : 0; 
                } catch (...) {
                        // enforce nothrow behaviour
                        abort();
                }
        }
        custom_t(const custom_t &other) { abort(); }
        custom_t &operator=(const custom_t &other) { abort(); return *this; }
};


#include <sag_internal/convert_to.hpp>

template<typename T>
inline typename get_details::GetVisitor<const T>::result_type get(const data_t &t) { return apply_visitor(get_details::GetVisitor<const T>(), t); }
template<typename T>
inline typename get_details::GetVisitor<T>::result_type get(data_t &t) { return apply_visitor(get_details::GetVisitor<T>(), t); }
template<typename T>
inline typename get_details::GetVisitor<custom_t<T> >::result_type get_custom(data_t &t) { return apply_visitor(get_details::GetVisitor<custom_t<T> >(), t); }
template<typename T>
inline typename get_details::GetVisitor<const custom_t<T> >::result_type get_custom(const data_t &t) { return apply_visitor(get_details::GetVisitor<const custom_t<T> >(), t); }


class list_t: protected sag_underlying_vector_t
{
        friend class data_t;
        friend class map_t;
        friend class Message;
        static size_t MIN_CAPACITY() { return 10; }
public:
        template<typename DATA, typename UNDERLYING>
        struct _iterator: public std::iterator<std::random_access_iterator_tag, DATA>
        {
                typedef _iterator<DATA, UNDERLYING> iterator;
                _iterator() : ptr(0), direction(1) {}
                explicit _iterator(UNDERLYING ptr, bool forward=true)
                        : ptr(ptr), direction(forward?1:-1)
                {}
                iterator &operator+=(size_t n) { ptr += direction*n; return *this; }
                iterator &operator-=(size_t n) { ptr -= direction*n; return *this; }
                iterator operator+(size_t n) const { return iterator(ptr+(direction*n), direction>0); }
                iterator operator-(size_t n) const { return iterator(ptr+(direction*-n), direction > 0); }
                ptrdiff_t operator-(const iterator &other) const { return direction*(ptr-other.ptr); }
                DATA &operator[](size_t n) const { return static_cast<DATA&>(ptr[n*direction]); }
                bool operator<(const iterator &other) const { return direction>0 ? ptr < other.ptr : ptr > other.ptr; }
                bool operator>(const iterator &other) const { return direction>0 ? ptr > other.ptr : ptr < other.ptr; }
                bool operator>=(const iterator &other) const { return direction>0 ? ptr >= other.ptr : ptr <= other.ptr; }
                bool operator<=(const iterator &other) const { return direction>0 ? ptr <= other.ptr : ptr >= other.ptr; }
                bool operator==(const iterator &other) const { return ptr == other.ptr; }
                bool operator!=(const iterator &other) const { return !operator==(other); }
                iterator &operator++() { return operator+=(1); }
                iterator operator++(int)
                {
                        iterator tmp(*this);
                        operator++();
                        return tmp;
                }
                iterator &operator--() { return operator-=(1); }
                iterator operator--(int)
                {
                        iterator tmp(*this);
                        operator--();
                        return tmp;
                }
                DATA &operator*() const { return static_cast<DATA&>(*ptr); }
                DATA *operator->() const { return static_cast<DATA*>(ptr); }
                UNDERLYING ptr;
                int64_t direction;
        };
        typedef _iterator<data_t, sag_underlying_data_t *> iterator;
        typedef _iterator<const data_t, const sag_underlying_data_t *> const_iterator;

        list_t()
        {
                table = 0;
        }
        explicit list_t(size_t n);

        ~list_t()
        {
                clear();
        }

        list_t &operator=(list_t &&other)
        {
                list_t tmp;
                // put us in tmp
                swap(std::move(tmp));
                // put other in us (and by extension the null tmp in other)
                swap(std::move(other));
                return *this;
        }
        list_t(list_t &&other)
        {
                table = 0;
                swap(std::move(other));
        }
        void swap(list_t &&other)
        {
                std::swap(table, other.table);
        }
        list_t copy() const
        {
                list_t newlist(size());
                for (const_iterator it = begin(); it != end(); ++it) {
                        newlist.push_back(it->copy());
                }
                return newlist;
        }

private:
        list_t &operator=(const list_t &other) { abort(); }
        list_t(const list_t &other) { abort(); }
public:

        bool operator==(const list_t &other) const;

        bool operator!=(const list_t &other) const { return !operator==(other); }

        /* Iteration: 
         * begin() and end() methods, both const and non-const, forward and backward.
         */
        iterator begin() { return iterator(table?table->data:0); }
        iterator end() { return iterator(table?table->data+table->count:0); }
        const_iterator begin() const { return const_iterator(table?table->data:0); } 
        const_iterator end() const { return const_iterator(table?table->data+table->count:0); } 
        const_iterator cbegin() const { return const_iterator(table?table->data:0); } 
        const_iterator cend() const { return const_iterator(table?table->data+table->count:0); } 
        iterator rbegin() { return iterator(table?table->data+table->count-1:0, false); } 
        iterator rend() { return iterator(table?table->data-1:0, false); } 
        const_iterator rbegin() const { return const_iterator(table?table->data+table->count-1:0, false); } 
        const_iterator rend() const { return const_iterator(table?table->data-1:0, false); } 

        size_t size() const { return table?table->count:0; }
        bool empty() const { return 0 == size(); }

        const data_t &operator[](size_t n) const;
        data_t &operator[](size_t n);
        const data_t &front() const { return operator[](0); }
        const data_t &back() const { return operator[](table?table->count-1:0); }
        data_t &front() { return operator[](0); }
        data_t &back() { return operator[](table?table->count-1:0); }

        void reserve(size_t n)
        {
                if (!table) resize(n);
                if (n > table->capacity) resize(n);
        }
        void clear();

        void push_back(data_t &&d);

        void pop_back();

private:
        void resize(size_t newsize);
};

class map_t: protected sag_underlying_map_t
{
        friend class data_t;
        friend class Message;
        static size_t MIN_CAPACITY() { return 8; }
protected:
        typedef sag_underlying_map_table_entry_t item_t;
        typedef int64_t hash_t;
public:

        template<typename DATA>
        struct pair
        {
                hash_t hash;
                DATA first;
                DATA second;
        };

        template<typename DATA, typename UNDERLYING, typename PAIR>
        struct _iterator: public std::iterator<std::bidirectional_iterator_tag, DATA>
        {
                friend class map_t;
                typedef _iterator<DATA, UNDERLYING, PAIR> iterator;
                typedef PAIR element_t;

                _iterator(): tabledata(0), capacity(0), offs(0) {}
                _iterator(const UNDERLYING &tabledata, size_t capacity, int64_t offs, bool stepToItem=false)
                        : tabledata(tabledata), capacity(capacity), offs(offs)
                {
                        if (!valid() && stepToItem) {
                                operator++();
                        }
                }

                iterator &operator--() 
                {
                        if (offs > -1) {
                                do {
                                        --offs;
                                } while (!valid());
                        }
                        return *this; 
                }
                iterator operator--(int)
                {
                        iterator tmp(*this);
                        operator--();
                        return tmp;
                }
                iterator &operator++()
                {
                        if (offs < capacity) {
                                do {
                                        ++offs;
                                } while (!valid());
                        }
                        return *this; 
                }
                iterator operator++(int)
                {
                        iterator tmp(*this);
                        operator++();
                        return tmp;
                }

                DATA &key() const { return static_cast<DATA&>(tabledata[offs].key); }
                DATA &value() const { return static_cast<DATA&>(tabledata[offs].value); }

                bool operator==(const iterator &other) const 
                {
                        bool b = offs == other.offs;
                        return b;
                }
                bool operator!=(const iterator &other) const 
                {
                        bool b = !operator==(other);
                        return b;
                }
                element_t &operator*() const
                {
                        return reinterpret_cast<element_t &>(tabledata[offs]);
                }
                element_t *operator->() const
                {
                        return reinterpret_cast<element_t *>(tabledata + offs);
                }
        protected:
                bool valid() const
                {       
                        return offs >= capacity || offs < 0 || tabledata[offs].hash > 1 || SAG_DATA_EMPTY != tabledata[offs].key.tag;
                }
                UNDERLYING tabledata;
                int64_t capacity;
                int64_t offs;
        };
        typedef _iterator<data_t, sag_underlying_map_table_entry_t *, pair<data_t> > iterator;
        typedef _iterator<const data_t, sag_underlying_map_table_entry_t const *, const pair<const data_t> > const_iterator;
        typedef pair<data_t> element;
        typedef pair<const data_t> const_element;

        map_t()
        {
                table = 0;
        }
        explicit map_t(size_t n);

        ~map_t()
        {
                clear();
        }

        map_t &operator=(map_t &&other)
        {
                map_t tmp;
                // put us in tmp
                swap(std::move(tmp));
                // put other in us (and by extension the null tmp in other)
                swap(std::move(other));
                return *this;
        }
        map_t(map_t &&other)
        {
                table = 0;
                swap(std::move(other));
        }

        void swap(map_t &&other)
        {
                std::swap(table, other.table);
        }

        map_t copy() const
        {
                map_t newmap(size());
                for (const_iterator it = begin(); it != end(); ++it) {
                        newmap.insert(std::make_pair(it->first.copy(), it->second.copy()));
                }
                return newmap;
        }

private:
        map_t &operator=(const map_t &other) { abort(); }
        map_t(const map_t &other) { abort(); }
public:

        bool operator==(const map_t &other) const
        {
                if (size() != other.size()) return false;
                for (const_iterator it = begin(); it != end(); ++it) {
                        const_iterator jt = other.find(it.key());
                        if (jt == other.end()) return false;
                        if (it.value() != jt.value()) return false;
                }
                return true;
        }

        bool operator!=(const map_t &other) const { return !operator==(other); }

        /* Iteration: 
         * begin() and end() methods, both const and non-const. 
         * Unordered, so forward iteration only
         */
        iterator begin() { return iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        iterator end() { return iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }
        const_iterator begin() const { return const_iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        const_iterator end() const { return const_iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }
        const_iterator cbegin() const { return const_iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        const_iterator cend() const { return const_iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }

        size_t size() const { return table?table->count:0; }

        bool empty() const { return 0 == size(); }

        data_t &operator[](data_t &&k)
        {
                return maybe_insert(std::pair<data_t&&,data_t&&>(std::move(k), data_t())).first->second;
        }

        data_t &operator[](const data_t &k)
        {
                return maybe_insert(std::pair<const data_t&,const data_t&>(k, data_t())).first->second;
        }
        const data_t &operator[](const data_t &k) const
        {
                const_iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        iterator find(const data_t &k);

        const_iterator find(const data_t &k) const;

        std::pair<iterator, bool> insert(const std::pair<data_t&&, data_t&&> &v);

        std::pair<iterator, bool> insert(data_t&& k, data_t&& v) {
                return insert(std::make_pair(std::move(k), std::move(v)));
        }

        std::pair<iterator, bool> insert(const std::pair<data_t&&, data_t&&> &v, hash_t hash);

        size_t erase(const data_t &k);
        void erase(iterator it);
        void clear();

protected:
        void resize(size_t newsize);

        void really_insert(item_t &item, const std::pair<data_t&&, data_t&&> &v, hash_t hash);
        std::pair<iterator, bool> maybe_insert(const std::pair<const data_t&, const data_t&> &v);
        std::pair<iterator, bool> maybe_insert(const std::pair<data_t&&, data_t&&> &v);
        std::pair<map_t::const_iterator, map_t::const_iterator> find_for_insert(const data_t &k, hash_t hash) const;

        bool empty(const item_t &item) const { return 0 == item.hash && SAG_DATA_EMPTY == item.key.tag; }
        bool empty(const const_iterator::element_t &item) const { return 0 == item.hash && SAG_DATA_EMPTY == item.first.tag; }
        bool hole(const item_t &item) const { return 1 == item.hash && SAG_DATA_EMPTY == item.key.tag; }
        bool hole(const const_iterator::element_t &item) const { return 1 == item.hash && SAG_DATA_EMPTY == item.first.tag; }
        bool live(const item_t &item) const { return SAG_DATA_EMPTY != item.key.tag || item.hash > 1; }
        bool live(const const_iterator::element_t &item) const { return SAG_DATA_EMPTY != item.first.tag || item.hash > 1; }

        size_t index(hash_t hash) const
        {
                if (!table) return 0;
                return table->capacity ? hash % table->capacity : 0;
        }

#ifdef _SAG_INTERNAL_UNSUPPORTED_DEBUG
public:
        SAG_CONNECTIVITY_API static size_t clashes;
        SAG_CONNECTIVITY_API static size_t inserts;
        SAG_CONNECTIVITY_API static double resizeUsage;
        SAG_CONNECTIVITY_API static size_t resizes;
        SAG_CONNECTIVITY_API static size_t max_lookup_clash;
        SAG_CONNECTIVITY_API static size_t lookups;
        SAG_CONNECTIVITY_API static size_t lookup_clashes;
        static double getInsertClashRatio() { return (double)clashes/(double)inserts; }
        static double getAverageResizeRatio() { return resizeUsage/(double)resizes; }
        static void resetCounters() { clashes = inserts = resizeUsage = resizes = 0; }
        static double getAverageLookupProbes() { return 1.0+(double)lookup_clashes/(double)lookups; }
        static size_t getMaxLookupProbes() { return 1+max_lookup_clash; }
#endif
};

class buffer_t: protected sag_underlying_buffer_t
{
        friend class data_t;
public:
        buffer_t()
        {
                table = 0;
        }
        explicit buffer_t(size_t n);

        ~buffer_t()
        {
                clear();
        }

        buffer_t &operator=(buffer_t &&other)
        {
                buffer_t tmp;
                // put us in tmp
                swap(std::move(tmp));
                // put other in us (and by extension the null tmp in other)
                swap(std::move(other));
                return *this;
        }
        buffer_t(buffer_t &&other)
        {
                table = 0;
                swap(std::move(other));
        }
        void swap(buffer_t &&other)
        {
                std::swap(table, other.table);
        }

        buffer_t copy() const;

private:
        buffer_t &operator=(const buffer_t &other) { abort(); }
        buffer_t(const buffer_t &other) { abort(); }
public:

        typedef uint8_t *iterator;
        typedef const uint8_t *const_iterator;

        bool operator==(const buffer_t &other) const
        {
                return (this->size() == other.size() &&
                        std::equal(this->cbegin(), this->cend(), other.begin())
                );
        }
        bool operator!=(const buffer_t &other) const
        {
                return !(this->operator==(other));
        }

        /* Iteration: 
         * begin() and end() methods, both const and non-const, forward and backward.
         */
        iterator begin() { return table?table->data:0; }
        iterator end() { return table?table->data+table->length:0; }
        const_iterator begin() const { return table?table->data:0; }
        const_iterator end() const { return table?table->data+table->length:0; }
        const_iterator cbegin() const { return table?table->data:0; }
        const_iterator cend() const { return table?table->data+table->length:0; }

        size_t size() const { return table ? table->length : 0; }
        bool empty() const { return 0 == size(); }

        uint8_t &operator[](size_t n)
        {
                if (n >= size()) throw std::runtime_error("Out of bounds");
                return table->data[n];
        }
        const uint8_t &operator[](size_t n) const
        {
                if (n >= size()) throw std::runtime_error("Out of bounds");
                return table->data[n];
        }
        void clear();
};

template<typename T>
inline T convert_to(const data_t &d) 
{
        return apply_visitor(convert_to_details::_get_or_convert<T>(d.type_name()), d);
}

class MapHelper
{
public:
        // String
        static std::string getString(const map_t &map, const char *key) { return getAs<std::string>(map, key);  }
        static std::string getString(const map_t &map, const char *key, const char *defaultValue) { return getAs<std::string>(map, key, defaultValue);  }
        static std::string getString(const map_t &map, const std::string &key) { return getAs<std::string>(map, key.c_str());   }
        static std::string getString(const map_t &map, const std::string &key, const std::string &defaultValue) { return getAs<std::string>(map, key.c_str(), defaultValue);    }
        // Integer
        static int64_t getInteger(const map_t &map, const char *key) { return getAs<int64_t>(map, key); }
        static int64_t getInteger(const map_t &map, const char *key, int64_t defaultValue) { return getAs<int64_t>(map, key, defaultValue);     }
        static int64_t getInteger(const map_t &map, const std::string &key) { return getAs<int64_t>(map, key.c_str());  }
        static int64_t getInteger(const map_t &map, const std::string &key, int64_t defaultValue) { return getAs<int64_t>(map, key.c_str(), defaultValue);      }
        // Double
        static double getDouble(const map_t &map, const char *key) { return getAs<double>(map, key);    }
        static double getDouble(const map_t &map, const char *key, double defaultValue) { return getAs<double>(map, key, defaultValue); }
        static double getDouble(const map_t &map, const std::string &key) { return getAs<double>(map, key.c_str());     }
        static double getDouble(const map_t &map, const std::string &key, double defaultValue) { return getAs<double>(map, key.c_str(), defaultValue);  }
        // Boolean
        static bool getBoolean(const map_t &map, const char *key) { return getAs<bool>(map, key);       }
        static bool getBoolean(const map_t &map, const char *key, bool defaultValue) { return getAs<bool>(map, key, defaultValue);      }
        static bool getBoolean(const map_t &map, const std::string &key) { return getAs<bool>(map, key.c_str());        }
        static bool getBoolean(const map_t &map, const std::string &key, bool defaultValue) { return getAs<bool>(map, key.c_str(), defaultValue);       }
        // Map
        static const map_t &getMap(const map_t &map, const char *key) { return getAs<const map_t&>(map, key);   }
        static const map_t &getMap(const map_t &map, const char *key, const map_t &defaultValue) { return getAs<const map_t&>(map, key, defaultValue);  }
        static const map_t &getMap(const map_t &map, const std::string &key) { return getAs<const map_t&>(map, key.c_str());    }
        static const map_t &getMap(const map_t &map, const std::string &key, const map_t &defaultValue) { return getAs<const map_t&>(map, key.c_str(), defaultValue);   }
        // List
        static const list_t &getList(const map_t &map, const char *key) { return getAs<const list_t&>(map, key);        }
        static const list_t &getList(const map_t &map, const char *key, const list_t &defaultValue) { return getAs<const list_t&>(map, key, defaultValue);      }
        static const list_t &getList(const map_t &map, const std::string &key) { return getAs<const list_t&>(map, key.c_str()); }
        static const list_t &getList(const map_t &map, const std::string &key, const list_t &defaultValue) { return getAs<const list_t&>(map, key.c_str(), defaultValue);       }

private:
        template<typename T>
        static T getAs(const map_t &map, const char *key);
        template<typename T>
        static T getAs(const map_t &map, const char *key, const T &def);
};



class metadata_t: protected map_t
{
        friend class data_t;
        friend class Message;
public:
        template<typename DATA, typename UNDERLYING, typename PAIR>
        struct _iterator: public map_t::_iterator<DATA, UNDERLYING, PAIR>
        {
                typedef _iterator<DATA, UNDERLYING, PAIR> iterator;
                typedef map_t::_iterator<DATA, UNDERLYING, PAIR> map_iterator;

                _iterator(): map_iterator() {}
                _iterator(const UNDERLYING &tabledata, size_t capacity, int64_t offs, bool stepToItem=false)
                        : map_iterator(tabledata, capacity, offs, stepToItem)
                {}
                _iterator(const map_iterator &other): map_iterator(other) {}
                iterator &operator=(const map_iterator &other)
                {
                        map_iterator::tabledata = other.tabledata;
                        map_iterator::offs = other.offs;
                        map_iterator::step = other.step;
                        map_iterator::capacity = other.capacity;
                        return *this;
                }

                const char* key() const 
                {
                        assert(map_iterator::tabledata[map_iterator::offs].key.tag == SAG_DATA_STRING);
                        if (map_iterator::tabledata[map_iterator::offs].key.tag != SAG_DATA_STRING) throw std::runtime_error("Metadata key not a string");
                        return map_iterator::tabledata[map_iterator::offs].key.string;
                }
                const char* value() const
                {
                        assert(map_iterator::tabledata[map_iterator::offs].value.tag == SAG_DATA_STRING);
                        if (map_iterator::tabledata[map_iterator::offs].value.tag != SAG_DATA_STRING) throw std::runtime_error("Metadata value not a string");
                        return map_iterator::tabledata[map_iterator::offs].value.string;
                }
        private: // can't expose these as string/string so make them inaccessible
                typename map_iterator::element_t &operator*() const
                {
                        return reinterpret_cast<typename map_iterator::element_t &>(map_iterator::tabledata[map_iterator::offs]);
                }
                typename map_iterator::element_t *operator->() const
                {
                        return reinterpret_cast<typename map_iterator::element_t *>(map_iterator::tabledata + map_iterator::offs);
                }
        };
        typedef _iterator<data_t, sag_underlying_map_table_entry_t *, pair<data_t> > iterator;
        typedef _iterator<const data_t, sag_underlying_map_table_entry_t const *, const pair<const data_t> > const_iterator;

        metadata_t(): map_t() {}
        explicit metadata_t(size_t n): map_t(n) {}
        metadata_t(metadata_t &&other) : map_t(std::move(other)) {}
        metadata_t &operator=(metadata_t &&other)
        {
                metadata_t tmp;
                swap(std::move(tmp));
                swap(std::move(other));
                return *this;
        }
        metadata_t copy() const;

        using map_t::empty;
        using map_t::size;
        using map_t::clear;

        bool operator==(const metadata_t &other) const
        {
                return static_cast<const map_t&>(*this) == static_cast<const map_t&>(other);
        }
        bool operator!=(const metadata_t &other) const { return !operator==(other); }

        void swap(metadata_t &&other)
        {
                return static_cast<map_t&>(*this).swap(static_cast<map_t&&>(other));
        }

        const char *operator[](const char *k)
        {
                iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        const char *const operator[](const char *k) const
        {
                const_iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        const char *operator[](const std::string &k)
        {
                iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        const char *const operator[](const std::string &k) const
        {
                const_iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        iterator find(const char *k)
        {
                return map_t::find(data_t(k));
        }
        const_iterator find(const char *k) const
        {
                return map_t::find(data_t(k));
        }
        iterator find(const std::string &k)
        {
                return map_t::find(data_t(k));
        }
        const_iterator find(const std::string &k) const
        {
                return map_t::find(data_t(k));
        }

        iterator find(const data_t &k)
        {
                return map_t::find(k);
        }
        const_iterator find(const data_t &k) const
        {
                return map_t::find(k);
        }
        std::pair<iterator, bool> insert(const std::pair<std::string, std::string> &v)
        {
                return map_t::insert(std::make_pair(data_t(v.first), data_t(v.second)));
        }

        std::pair<iterator, bool> insert(const std::pair<const char*, const char*> &v)
        {
                return map_t::insert(std::make_pair(data_t(v.first), data_t(v.second)));
        }

        size_t erase(const std::string &k)
        {
                return map_t::erase(data_t(k));
        }
        size_t erase(const char *k)
        {
                return map_t::erase(data_t(k));
        }
        void erase(iterator it)
        {
                map_t::erase(it);
        }

        /* Iteration: 
         * begin() and end() methods, both const and non-const. Unordered so no reverse iterator
         */
        iterator begin() { return iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        iterator end() { return iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }
        const_iterator begin() const { return const_iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        const_iterator end() const { return const_iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }
        const_iterator cbegin() const { return const_iterator(table?table->table:0, table?table->capacity:0, 0, true); }
        const_iterator cend() const { return const_iterator(table?table->table:0, table?table->capacity:0, table?table->capacity:0, false); }

private:
        metadata_t &operator=(const metadata_t &other) { abort(); }
        metadata_t(const metadata_t &other) { abort(); }
};

class Message: protected sag_underlying_message_t
{
public:
        typedef com::softwareag::connectivity::metadata_t metadata_t;
        typedef data_t payload_t;
        Message();

        explicit Message(payload_t &&_payload);

        Message(payload_t &&_payload, metadata_t &&_metadata);

        ~Message();

        Message(Message &&other);

        Message &operator=(Message &&other)
        {
                Message tmp;
                swap(std::move(tmp));
                swap(std::move(other));
                return *this;
        }
        const payload_t &getPayload() const;
        const metadata_t &getMetadata() const;

        payload_t &getPayload() { return static_cast<payload_t&>(payload); }
        metadata_t &getMetadata() { return static_cast<metadata_t&>(metadata); }

        void setPayload(payload_t &&_payload);
        void setMetadata(metadata_t &&_metadata);

        void swap(Message &&other);

        Message copy() const
        {
                return Message(getPayload().copy(), getMetadata().copy());
        }

        static const char *HOST_MESSAGE_TYPE() {
                        return "sag.type";
        }

        static const char *CHANNEL() {
                        return "sag.channel";
        }

        Message &putMetadataValue(const char *key, const char *value);

        Message &putMetadataValue(data_t &&key, data_t &&value);

        Message &putMetadataValue(const std::string &key, const std::string &value) { return putMetadataValue(key.c_str(), value.c_str()); }
private:
        Message(const Message &other) { abort(); }
        Message &operator=(const Message &other) { abort(); }
};


template<typename DERIVED, typename RV>
class visitor
{
public:
        typedef RV result_type;
        typedef DERIVED derived_t;

        result_type operator()() const { return derived().visitEmpty(); }
        result_type visitEmpty() const { return derived().error("empty"); }

        result_type operator()(int64_t &i) const { return derived().visitInteger(i); }
        result_type visitInteger(int64_t &i) const { return derived().error("integer"); }

        result_type operator()(double &i) const { return derived().visitDouble(i); }
        result_type visitDouble(double &i) const { return derived().error("double"); }

        result_type operator()(bool &i) const { return derived().visitBoolean(i); }
        result_type visitBoolean(bool &i) const { return derived().error("boolean"); }

        result_type operator()(const char *&i) const { return derived().visitString(i); }
        result_type visitString(const char *&i) const { return derived().error("string"); }

        result_type operator()(decimal_t &i) const { return derived().visitDecimal(i); }
        result_type visitDecimal(decimal_t &i) const { return derived().error("decimal"); }

        result_type operator()(buffer_t &i) const { return derived().visitBuffer(i); }
        result_type visitBuffer(buffer_t &i) const { return derived().error("buffer"); }

        result_type operator()(list_t &i) const { return derived().visitList(i); }
        result_type visitList(list_t &i) const { return derived().error("list"); }

        result_type operator()(map_t &i) const { return derived().visitMap(i); }
        result_type visitMap(map_t &i) const { return derived().error("map"); }

        result_type operator()(sag_underlying_custom_t &i) const { return derived().visitCustom(i); }
        result_type visitCustom(sag_underlying_custom_t &i) const { return derived().error("custom"); }

protected:
        result_type error(const std::string &reason) const { throw std::runtime_error("Visit type error: "+reason); }
private:
        const derived_t &derived() const { return static_cast<const derived_t&>(*this); }
};

template<typename DERIVED, typename RV>
class const_visitor
{
public:
        typedef RV result_type;
        typedef DERIVED derived_t;

        result_type operator()() const { return derived().visitEmpty(); }
        result_type visitEmpty() const { return derived().error("empty"); }

        result_type operator()(int64_t i) const { return derived().visitInteger(i); }
        result_type visitInteger(int64_t i) const { return derived().error("integer"); }

        result_type operator()(double i) const { return derived().visitDouble(i); }
        result_type visitDouble(double i) const { return derived().error("double"); }

        result_type operator()(bool i) const { return derived().visitBoolean(i); }
        result_type visitBoolean(bool i) const { return derived().error("boolean"); }

        result_type operator()(const char *i) const { return derived().visitString(i); }
        result_type visitString(const char *i) const { return derived().error("string"); }

        result_type operator()(const decimal_t &i) const { return derived().visitDecimal(i); }
        result_type visitDecimal(const decimal_t &i) const { return derived().error("decimal"); }

        result_type operator()(const buffer_t &i) const { return derived().visitBuffer(i); }
        result_type visitBuffer(const buffer_t &i) const { return derived().error("buffer"); }

        result_type operator()(const list_t &i) const { return derived().visitList(i); }
        result_type visitList(const list_t &i) const { return derived().error("list"); }

        result_type operator()(const map_t &i) const { return derived().visitMap(i); }
        result_type visitMap(const map_t &i) const { return derived().error("map"); }

        result_type operator()(const sag_underlying_custom_t &i) const { return derived().visitCustom(i); }
        result_type visitCustom(const sag_underlying_custom_t &i) const { return derived().error("custom"); }

protected:
        result_type error(const std::string &reason) const { throw std::runtime_error("Visit type error: "+reason); }
private:
        const derived_t &derived() const { return static_cast<const derived_t&>(*this); }
};


}}} // com.softwareag.connectivity

// internal implementation details in here
#include <sag_internal/data.hpp>

#endif // _CPPMESSAGEDATA_H_