sequential_mapper.h

Go to the documentation of this file.

/************************************************************************************
*                                                                                   *
*   Copyright (c) 2014 - 2018 Axel Menzel <info@rttr.org>                           *
*                                                                                   *
*   This file is part of RTTR (Run Time Type Reflection)                            *
*   License: MIT License                                                            *
*                                                                                   *
*   Permission is hereby granted, free of charge, to any person obtaining           *
*   a copy of this software and associated documentation files (the "Software"),    *
*   to deal in the Software without restriction, including without limitation       *
*   the rights to use, copy, modify, merge, publish, distribute, sublicense,        *
*   and/or sell copies of the Software, and to permit persons to whom the           *
*   Software is furnished to do so, subject to the following conditions:            *
*                                                                                   *
*   The above copyright notice and this permission notice shall be included in      *
*   all copies or substantial portions of the Software.                             *
*                                                                                   *
*   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR      *
*   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,        *
*   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE     *
*   AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER          *
*   LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,   *
*   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE   *
*   SOFTWARE.                                                                       *
*                                                                                   *
*************************************************************************************/

#ifndef RTTR_SEQUENTIAL_MAPPER_H_
#define RTTR_SEQUENTIAL_MAPPER_H_

#include "rttr/detail/base/core_prerequisites.h"

namespace rttr
{

template<typename T>
struct sequential_container_mapper
{
#ifndef DOXYGEN
    using is_valid      = std::false_type;
    using container_t   = T;
    using value_t       = detail::invalid_type;
#else
    using container_t = T;                          
    using key_t       = typename T::key_type;       
    using value_t     = typename T::mapped_type;    
    using itr_t       = typename T::iterator;       
    using const_itr_t = typename T::const_iterator; 


    static const key_t& get_key(const const_itr_t& itr)
    {
        return itr->first;
    }


    static value_t& get_value(itr_t& itr)
    {
        return itr->second;
    }

    static const value_t& get_value(const const_itr_t& itr)
    {
        return itr->second;
    }


    static itr_t begin(container_t& container)
    {
        return container.begin();
    }

    static const_itr_t begin(const container_t& container)
    {
        return container.begin();
    }


    static itr_t end(container_t& container)
    {
        return container.end();
    }

    static const_itr_t end(const container_t& container)
    {
        return container.end();
    }


    static itr_t find(container_t& container, const key_t& key)
    {
        return container.find(key);
    }

    static const_itr_t find(const container_t& container, const key_t& key)
    {
        return container.find(key);
    }


    static std::pair<itr_t, itr_t> equal_range(container_t& container, const key_t& key)
    {
        return container.equal_range(key);
    }

    static std::pair<const_itr_t, const_itr_t> equal_range(const container_t& container, const key_t& key)
    {
        return container.equal_range(key);
    }


    static void clear(container_t& container)
    {
        container.clear();
    }

    static bool is_empty(const container_t& container)
    {
        return container.empty();
    }

    static std::size_t get_size(const container_t& container)
    {
        return container.size();
    }

    static std::size_t erase(container_t& container, const key_t& key)
    {
        return container.erase(key);
    }

    static std::pair<itr_t, bool> insert_key(container_t& container, const key_t& key)
    {
        return { container.end(), false };
    }

    static std::pair<itr_t, bool> insert_key_value(container_t& container, const key_t& key, const value_t& value)
    {
        return container.insert(std::make_pair(key, value));
    }
#endif
};

} // end namespace rttr

#include "rttr/detail/impl/sequential_mapper_impl.h"

#endif // RTTR_SEQUENTIAL_MAPPER_H_