data_t.hpp

Go to the documentation of this file.

/*
 * Title:        bits/data_t.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: data_t.hpp 294926 2016-11-09 18:33:24Z matj $
 */

#ifndef _DATAT_BITS_INCLUDE_TAG
#error Must only be included from sag_connectivity_cpp.hpp, use that instead
#endif

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;
        }
};