map_extractor.hpp

Go to the documentation of this file.

/*
 * Title:                       bits/map_extractor.hpp
 * Description:         Helper class for extracting values from the map_t type
 * $Copyright (c) 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
 */

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

class MapExtractor
{
public:
        MapExtractor(const map_t &map, const std::string &displayName)
                : map(map), keysAlreadyAccessed(), displayName(displayName)
        {
                if (displayName.empty())
                {
                        throw std::runtime_error("displayName cannot be empty");
                }
        }

        MapExtractor(const MapExtractor &) = delete;
        MapExtractor &operator=(const MapExtractor &) = delete;
        MapExtractor &operator=(MapExtractor &&) = delete;
        ~MapExtractor() = default;

        MapExtractor(MapExtractor &&other) : 
                map(other.map), 
                keysAlreadyAccessed(std::move(other.keysAlreadyAccessed)), 
                displayName(std::move(other.displayName))
        {}

        bool empty()
        {
                return map.empty();
        }

        const map_t& getUnderlyingMap()
        {
                return map;
        }

        std::string getDisplayName()
        {
                return displayName;
        }

        std::string toString();

        void checkNoItemsRemaining()
        {
                std::vector<std::string> remaining;
                for (auto it = map.begin(); it != map.end(); ++it)
                {
                        if (keysAlreadyAccessed.find(it->first) == keysAlreadyAccessed.end())
                        {
                                remaining.push_back(stringifyKey(it->first));
                        }
                }
                if (remaining.empty()) return;

                std::stringstream ss;
                for (auto it = remaining.begin(); it != remaining.end(); ++it)
                {
                        ss << "'" << *it << "'" << " ";
                }
                throw std::runtime_error("Found unexpected items in the map '" + displayName + "': " + ss.str());
        }

        template<typename T>
        const is_not_convertable_t<T> &get(const data_t& key)
        {
                return com::softwareag::connectivity::get<T>(doGet(key));
        }

        template<typename T>
        const is_convertable_t<T> get(const data_t& key)
        {
                return com::softwareag::connectivity::convert_to<T>(doGet(key));
        }

        template<typename T>
        const T get(const data_t& key, const T defaultValue)
        {
                try
                {
                        return get<T>(key);
                }
                catch (const std::exception &)
                {
                        return defaultValue;
                }
        }


        MapExtractor getMap(const data_t& key, bool emptyIfMissing)
        {
                try 
                {       
                        return MapExtractor(get<map_t>(key), displayName + "." + stringifyKey(key));
                } 
                catch (const std::exception &) 
                {
                        if (emptyIfMissing)
                        {
                                return MapExtractor(emptyMap, displayName + "." + stringifyKey(key));
                        }
                        throw;
                }
        }

        std::string getStringDisallowEmpty(const data_t& key)
        {
                std::string ret = get<const char*>(key);
                if (ret.empty())
                {
                        throw std::runtime_error("The string value associated with key '" + stringifyKey(key) + "' in " + displayName + " is empty");
                }
                return ret;
        }

        std::string getStringDisallowEmpty(const data_t& key, std::string defaultValue)
        {
                try {
                        return getStringDisallowEmpty(key);
                } catch (const std::exception &) {
                        return defaultValue;
                }
        }

        std::string getStringAllowEmpty(const data_t& key)
        {
                return get<const char*>(key);
        }

        std::string getStringAllowEmpty(const data_t& key, std::string defaultValue)
        {
                try {
                        return getStringAllowEmpty(key);
                } catch (const std::exception &) {
                        return defaultValue;
                }
        }

private:
        const data_t& doGet(const data_t& key)
        {
                keysAlreadyAccessed[key.copy()] = data_t();

                auto it = map.find(key);
                if (it == map.end())
                {
                        throw std::runtime_error("Key '" + stringifyKey(key) + "' not found in " + displayName);
                }
                if (it->second.type_tag() == SAG_DATA_EMPTY)
                {
                        throw std::runtime_error("Key '" + stringifyKey(key) + "' has an empty value in " + displayName);
                }
                return it->second;
        }

        std::string stringifyKey(const data_t& data);

        const map_t& map;
        map_t keysAlreadyAccessed;
        const std::string displayName;
        const map_t emptyMap;
};