com.hfg.util.collection.OrderedMap Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of com_hfg Show documentation
com.hfg xml, html, svg, and bioinformatics utility library
There is a newer version: 20240423
package com.hfg.util.collection;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.Function;

//------------------------------------------------------------------------------
/**
 * HashMap that preserves the key order.
 * @author J. Alex Taylor, hairyfatguy.com
 */
//------------------------------------------------------------------------------
// com.hfg Library
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// J. Alex Taylor, President, Founder, CEO, COO, CFO, OOPS hairyfatguy.com
// [email protected]
//------------------------------------------------------------------------------

public class OrderedMap extends HashMap
{
   private OrderedSet mOrderedKeys;

   //##########################################################################
   // CONSTRUCTORS
   //##########################################################################

   //--------------------------------------------------------------------------
   public OrderedMap()
   {
      super();
      mOrderedKeys = new OrderedSet<>();
   }

   //--------------------------------------------------------------------------
   public OrderedMap(int inInitialCapacity)
   {
      super(inInitialCapacity);
      mOrderedKeys = new OrderedSet<>(inInitialCapacity);
   }

   //--------------------------------------------------------------------------
   public OrderedMap(int inInitialCapacity, float loadFactor)
   {
      super(inInitialCapacity, loadFactor);
      mOrderedKeys = new OrderedSet<>(inInitialCapacity);
   }

   //--------------------------------------------------------------------------
   public OrderedMap(Map m)
   {
      super(m);
      mOrderedKeys = new OrderedSet<>(m.keySet());
   }

   //##########################################################################
   // PUBLIC METHODS
   //##########################################################################

   //--------------------------------------------------------------------------
   @Override
   public void clear()
   {
      mOrderedKeys.clear();
      super.clear();
   }

   //--------------------------------------------------------------------------
   @Override
   public V put(K inKey, V inValue)
   {
      mOrderedKeys.add(inKey);
      return super.put(inKey, inValue);
   }

   //--------------------------------------------------------------------------
   @Override
   public void putAll(Map m)
   {
      for (K key : m.keySet())
      {
         put(key, m.get(key));
      }
   }

   //--------------------------------------------------------------------------
   @Override
   public V putIfAbsent(K inKey, V inValue)
   {
      mOrderedKeys.add(inKey);
      return super.putIfAbsent(inKey, inValue);
   }

   //--------------------------------------------------------------------------
   @Override
   public V computeIfPresent(K inKey,
                             BiFunction inRemappingFunction)
   {
      mOrderedKeys.add(inKey);
      return super.computeIfPresent(inKey, inRemappingFunction);
   }

   //--------------------------------------------------------------------------
   @Override
   public V computeIfAbsent(K inKey,
                            Function inRemappingFunction)
   {
      mOrderedKeys.add(inKey);
      return super.computeIfAbsent(inKey, inRemappingFunction);
   }

   //--------------------------------------------------------------------------
   @Override
   public V compute(K inKey,
                    BiFunction inRemappingFunction)
   {
      mOrderedKeys.add(inKey);
      return super.compute(inKey, inRemappingFunction);
   }

   //--------------------------------------------------------------------------
   @Override
   public V merge(K inKey, V inValue,
                  BiFunction inRemappingFunction)
   {
      mOrderedKeys.add(inKey);
      return super.merge(inKey, inValue, inRemappingFunction);
   }

   //--------------------------------------------------------------------------
   @Override
   public Collection values()
   {
      Collection values = null;
      if (CollectionUtil.hasValues(this))
      {
         values = new ArrayList(size());
         for (K key : keySet())
         {
            values.add(get(key));
         }
      }

      return values;
   }

   //--------------------------------------------------------------------------
   @Override
   public V remove(Object inKey)
   {
      mOrderedKeys.remove(inKey);
      return super.remove(inKey);
   }

   //--------------------------------------------------------------------------
   @Override
   public OrderedSet keySet()
   {
      return mOrderedKeys;
   }

   //--------------------------------------------------------------------------
   @Override
   public Set> entrySet()
   {
      Set> orderedEntries = new OrderedSet<>(size());

      for (K key : keySet())
      {
         orderedEntries.add(new OrderedEntry(key, get(key)));
      }

      return orderedEntries;
   }

   //--------------------------------------------------------------------------
   @Override
   public void forEach(BiConsumer inAction)
   {
      for (K key : keySet())
      {
         inAction.accept(key, get(key));
      }
   }


   private class OrderedEntry implements Map.Entry
   {
      private K mKey;
      private V mValue;

      //-----------------------------------------------------------------------
      public OrderedEntry(K inKey, V inValue)
      {
         mKey = inKey;
         mValue = inValue;
      }

      //-----------------------------------------------------------------------
      @Override
      public K getKey()
      {
         return mKey;
      }

      //-----------------------------------------------------------------------
      @Override
      public V getValue()
      {
         return mValue;
      }

      //-----------------------------------------------------------------------
      @Override
      public V setValue(V inValue)
      {
         V oldValue = mValue;
         mValue = inValue;

         return oldValue;
      }
   }
}