MapIterators.hh

Go to the documentation of this file.

#include <map>
#include <unordered_map>

#ifndef __DIADES__UTILS__MAPITERATORS_HH
#define __DIADES__UTILS__MAPITERATORS_HH

namespace Diades
{
        namespace Utils
        {

                // This code is more than largely inspired  from Ian and Degski, Thanks to them
                // user:2063546
                // https://stackoverflow.com/users/2063546/ian
                // user:646940 
                // https://stackoverflow.com/users/646940/degski




                template<typename Key, typename Value>
                using Map = std::map<Key, Value>;

                template<typename Key, typename Value>
                using MapIterator = typename Map<Key, Value>::iterator;

                template<typename Key, typename Value>
                class MapKeyIterator : public MapIterator<Key, Value>
                {
                public:

                        MapKeyIterator() : MapIterator<Key, Value> ()
                        {
                        };

                        MapKeyIterator(MapIterator<Key, Value> it) : MapIterator<Key, Value> (it)
                        {
                        };

                        Key *operator->()
                        {
                                return(Key * const) &(MapIterator<Key, Value>::operator->()->first);
                        }

                        Key & operator*()
                        {
                                return MapIterator<Key, Value>::operator*().first;
                        }
                };

                template<typename Key, typename Value>
                class MapValueIterator : public MapIterator<Key, Value>
                {
                public:

                        MapValueIterator() : MapIterator<Key, Value> ()
                        {
                        };

                        MapValueIterator(MapIterator<Key, Value> it_) : MapIterator<Key, Value> (it_)
                        {
                        };

                        Value *operator->()
                        {
                                return(Value * const) &(MapIterator<Key, Value>::operator->()->second);
                        }

                        Value & operator*()
                        {
                                return MapIterator<Key, Value>::operator*().second;
                        }
                };

                template<typename Key, typename Value>
                using ConstMapIterator = typename Map<Key, Value>::const_iterator;

                template<typename Key, typename Value>
                class ConstMapKeyIterator : public ConstMapIterator<Key, Value>
                {
                public:

                        ConstMapKeyIterator() : ConstMapIterator<Key, Value> ()
                        {
                        };

                        ConstMapKeyIterator(ConstMapIterator<Key, Value> it) : ConstMapIterator<Key, Value> (it)
                        {
                        };

                        const Key *operator->() const
                        {
                                return(Key * const) &(ConstMapIterator<Key, Value>::operator->()->first);
                        }

                        const Key & operator*() const
                        {
                                return ConstMapIterator<Key, Value>::operator*().first;
                        }
                };

                template<typename Key, typename Value>
                class ConstMapValueIterator : public ConstMapIterator<Key, Value>
                {
                public:

                        ConstMapValueIterator() : ConstMapIterator<Key, Value> ()
                        {
                        };

                        ConstMapValueIterator(ConstMapIterator<Key, Value> it_) : ConstMapIterator<Key, Value> (it_)
                        {
                        };

                        const Value *operator->() const
                        {
                                return(Value * const) &(ConstMapIterator<Key, Value>::operator->()->second);
                        }

                        const Value & operator*() const
                        {
                                return ConstMapIterator<Key, Value>::operator*().second;
                        }
                };

                
                
                

                template<typename Key, typename Value>
                using UnorderedMap = std::unordered_map<Key, Value>;

                template<typename Key, typename Value>
                using UnorderedMapIterator = typename UnorderedMap<Key, Value>::iterator;

                template<typename Key, typename Value>
                class UnorderedMapKeyIterator : public UnorderedMapIterator<Key, Value>
                {
                public:

                        UnorderedMapKeyIterator() : UnorderedMapIterator<Key, Value> ()
                        {
                        };

                        UnorderedMapKeyIterator(MapIterator<Key, Value> it) : UnorderedMapIterator<Key, Value> (it)
                        {
                        };

                        Key *operator->()
                        {
                                return(Key * const) &(UnorderedMapIterator<Key, Value>::operator->()->first);
                        }

                        Key & operator*()
                        {
                                return UnorderedMapIterator<Key, Value>::operator*().first;
                        }
                };

                template<typename Key, typename Value>
                class UnorderedMapValueIterator : public UnorderedMapIterator<Key, Value>
                {
                public:

                        UnorderedMapValueIterator() : UnorderedMapIterator<Key, Value> ()
                        {
                        };

                        UnorderedMapValueIterator(UnorderedMapIterator<Key, Value> it_) : UnorderedMapIterator<Key, Value> (it_)
                        {
                        };

                        Value *operator->()
                        {
                                return(Value * const) &(UnorderedMapIterator<Key, Value>::operator->()->second);
                        }

                        Value & operator*()
                        {
                                return UnorderedMapIterator<Key, Value>::operator*().second;
                        }
                };

                template<typename Key, typename Value>
                using ConstUnorderedMapIterator = typename UnorderedMap<Key, Value>::const_iterator;

                template<typename Key, typename Value>
                class ConstUnorderedMapKeyIterator : public ConstUnorderedMapIterator<Key, Value>
                {
                public:

                        ConstUnorderedMapKeyIterator() : ConstUnorderedMapIterator<Key, Value> ()
                        {
                        };

                        ConstUnorderedMapKeyIterator(ConstUnorderedMapIterator<Key, Value> it) : ConstUnorderedMapIterator<Key, Value> (it)
                        {
                        };

                        const Key *operator->() const
                        {
                                return(Key * const) &(ConstUnorderedMapIterator<Key, Value>::operator->()->first);
                        }

                        const Key & operator*() const 
                        {
                                return ConstUnorderedMapIterator<Key, Value>::operator*().first;
                        }
                };

                template<typename Key, typename Value>
                class ConstUnorderedMapValueIterator : public ConstUnorderedMapIterator<Key, Value>
                {
                public:

                        ConstUnorderedMapValueIterator() : ConstUnorderedMapIterator<Key, Value> ()
                        {
                        };

                        ConstUnorderedMapValueIterator(ConstMapIterator<Key, Value> it_) : ConstUnorderedMapIterator<Key, Value> (it_)
                        {
                        };

                        const Value *operator->() const
                        {
                                return(Value * const) &(ConstUnorderedMapIterator<Key, Value>::operator->()->second);
                        }

                        const Value & operator*() const
                        {
                                return ConstUnorderedMapIterator<Key, Value>::operator*().second;
                        }
                };








        }
}

#endif /* __DIADES__UTILS__MAPITERATORS_HH */