/*

 * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

#ifndef ORDEREDMAP_H

#define ORDEREDMAP_H

#include <map>

#include <vector>

#include <assert.h>

#include <stdexcept>

#include <iostream>

template <typename _T1, typename _T2>

struct JPPair

{

    typedef _T1 first_type;

    typedef _T2 second_type;

    first_type first;

    second_type second;

    JPPair(first_type Value1, second_type Value2) {

        first = Value1;

        second = Value2;

    }

};

template <typename TKey, typename TValue>

class OrderedMap {

public:

    typedef TKey key_type;

    typedef TValue mapped_type;

    typedef JPPair<key_type, mapped_type> container_type;

    typedef typename std::vector<container_type*>::iterator iterator;

    typedef typename std::vector<container_type*>::const_iterator const_iterator;

private:

    typedef std::map<key_type, container_type*> map_type;

    typedef std::vector<container_type*> list_type;

    map_type FMap;

    list_type FList;

    bool FAllowDuplicates;

    typename list_type::iterator FindListItem(const key_type Key) {

        typename list_type::iterator result = FList.end();

        for (typename list_type::iterator iterator =

                FList.begin(); iterator != FList.end(); iterator++) {

            container_type *item = *iterator;

            if (item->first == Key) {

                result = iterator;

                break;

            }

        }

        return result;

    }

public:

    OrderedMap() {

        FAllowDuplicates = false;

    }

    OrderedMap(const OrderedMap<key_type, mapped_type> &Value) {

        Append(Value);

        FAllowDuplicates = Value.GetAllowDuplicates();

    }

    ~OrderedMap() {

        Clear();

    }

    void SetAllowDuplicates(bool Value) {

        FAllowDuplicates = Value;

    }

    bool GetAllowDuplicates() const {

        return FAllowDuplicates;

    }

    iterator begin() {

        return FList.begin();

    }

    const_iterator begin() const {

        return FList.begin();

    }

    iterator end() {

        return FList.end();

    }

    const_iterator end() const {

        return FList.end();

    }

    void Clear() {

        for (typename list_type::iterator iterator =

                FList.begin(); iterator != FList.end(); iterator++) {

            container_type *item = *iterator;

            if (item != NULL) {

                delete item;

                item = NULL;

            }

        }

        FMap.clear();

        FList.clear();

    }

    bool ContainsKey(key_type Key) {

        bool result = false;

        if (FMap.find(Key) != FMap.end()) {

            result = true;

        }

        return result;

    }

    std::vector<key_type> GetKeys() {

        std::vector<key_type> result;

        for (typename list_type::const_iterator iterator = FList.begin();

             iterator != FList.end(); iterator++) {

            container_type *item = *iterator;

            result.push_back(item->first);

        }

        return result;

    }

    void Assign(const OrderedMap<key_type, mapped_type> &Value) {

        Clear();

        Append(Value);

    }

    void Append(const OrderedMap<key_type, mapped_type> &Value) {

        for (size_t index = 0; index < Value.FList.size(); index++) {

            container_type *item = Value.FList[index];

            Append(item->first, item->second);

        }

    }

    void Append(key_type Key, mapped_type Value) {

        container_type *item = new container_type(Key, Value);

        FMap.insert(std::pair<key_type, container_type*>(Key, item));

        FList.push_back(item);

    }

    bool RemoveByKey(key_type Key) {

        bool result = false;

        typename list_type::iterator iterator = FindListItem(Key);

        if (iterator != FList.end()) {

            FMap.erase(Key);

            FList.erase(iterator);

            result = true;

        }

        return result;

    }

    bool GetValue(key_type Key, mapped_type &Value) {

        bool result = false;

        container_type* item = FMap[Key];

        if (item != NULL) {

            Value = item->second;

            result = true;

        }

        return result;

    }

    bool SetValue(key_type Key, mapped_type &Value) {

        bool result = false;

        if ((FAllowDuplicates == false) && (ContainsKey(Key) == true)) {

            container_type *item = FMap[Key];

            if (item != NULL) {

                item->second = Value;

                result = true;

            }

        }

        else {

            Append(Key, Value);

            result = true;

        }

        return result;

    }

    bool GetKey(int index, key_type &Value) {

        if (index < 0 || index >= (int)FList.size()) {

            return false;

        }

        container_type *item = FList.at(index);

        if (item != NULL) {

            Value = item->first;

            return true;

        }

        return false;

    }

    bool GetValue(int index, mapped_type &Value) {

        if (index < 0 || index >= (int)FList.size()) {

            return false;

        }

        container_type *item = FList.at(index);

        if (item != NULL) {

            Value = item->second;

            return true;

        }

        return false;

    }

    mapped_type &operator[](key_type Key) {

        container_type* item = FMap[Key];

        assert(item != NULL);

        if (item != NULL) {

            return item->second;

        }

        throw std::invalid_argument("Key not found");

    }

    OrderedMap& operator= (OrderedMap &Value) {

        Clear();

        FAllowDuplicates = Value.GetAllowDuplicates();

        Append(Value);

        return *this;

    }

    size_t Count() {

        return FList.size();

    }

};

#endif // ORDEREDMAP_H