metadata_t.hpp

Go to the documentation of this file.

/*
 * Title:        bits/metadata_t.hpp
 * Description:  C++ header-only wrapper for C-ABI data_t type
 * $Copyright (c) 2015-2017 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: metadata_t.hpp 298712 2017-01-05 16:12:59Z mipr $
 */

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

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

                std::string 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;
                }
                std::string value() const
                {
                   try {
                      return(convert_to<std::string>(map_iterator::operator*().second));
                   } catch (...) {
                      throw std::runtime_error("Non-stringifiable data in metadata");
                   }
                }
        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));
        }

        std::string operator[](const char *k)
        {
                iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        std::string 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();
                }
        }
        std::string operator[](const std::string &k)
        {
                iterator it = find(k);
                if (it == end()) {
                        throw std::runtime_error("Element not in map");
                } else {
                        return it.value();
                }
        }
        std::string 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(); }
};