Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2005,2009 Ivan SZKIBA
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.ini4j;
 
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 public class BasicMultiMap<K, V> implements MultiMap<K, V>, Serializable
 {
     private static final long serialVersionUID = 4716749660560043989L;
     private final Map<K, List<V>> _impl;
 
     public BasicMultiMap()
     {
         this(new LinkedHashMap<K, List<V>>());
     }
 
     public BasicMultiMap(Map<K, List<V>> impl)
     {
          = impl;
     }
 
     @Override public List<V> getAll(Object key)
     {
         return .get(key);
     }
 
     @Override public boolean isEmpty()
     {
         return .isEmpty();
     }
 
     @Override public void add(K key, V value)
     {
         getList(keytrue).add(value);
     }
 
     @Override public void add(K key, V valueint index)
     {
         getList(keytrue).add(indexvalue);
     }
 
     @Override public void clear()
     {
         .clear();
     }
 
     @Override public boolean containsKey(Object key)
     {
         return .containsKey(key);
     }
 
     @Override public boolean containsValue(Object value)
     {
         boolean ret = false;
 
         for (List<V> all : .values())
         {
             if (all.contains(value))
             {
                 ret = true;
 
                 break;
             }
         }
 
         return ret;
     }
 
     @Override public Set<Entry<K, V>> entrySet()
     {
         Set<Entry<K, V>> ret = new HashSet<Entry<K, V>>();
 
         for (K key : keySet())
         {
             ret.add(new ShadowEntry(key));
        }
        return ret;
    }
    @Override public V get(Object key)
    {
        List<V> values = getList(keyfalse);
        return (values == null) ? null : values.get(values.size() - 1);
    }
    @Override public V get(Object keyint index)
    {
        List<V> values = getList(keyfalse);
        return (values == null) ? null : values.get(index);
    }
    @Override public Set<K> keySet()
    {
        return .keySet();
    }
    @Override public int length(Object key)
    {
        List<V> values = getList(keyfalse);
        return (values == null) ? 0 : values.size();
    }
    @Override public V put(K key, V value)
    {
        V ret = null;
        List<V> values = getList(keytrue);
        if (values.isEmpty())
        {
            values.add(value);
        }
        else
        {
            ret = values.set(values.size() - 1, value);
        }
        return ret;
    }
    @Override public V put(K key, V valueint index)
    {
        return getList(keyfalse).set(indexvalue);
    }
    @Override public void putAll(Map<? extends K, ? extends V> map)
    {
        if (map instanceof MultiMap)
        {
            MultiMap<K, V> mm = (MultiMap<K, V>) map;
            for (Object key : mm.keySet())
            {
                putAll((K) keymm.getAll(key));
            }
        }
        else
        {
            for (K key : map.keySet())
            {
                put(keymap.get(key));
            }
        }
    }
    @Override public List<V> putAll(K keyList<V> values)
    {
        List<V> ret = .get(key);
        .put(keynew ArrayList<V>(values));
        return ret;
    }
    @Override public V remove(Object key)
    {
        List<V> prev = .remove(key);
        return (prev == null) ? null : prev.get(0);
    }
    @Override public V remove(Object keyint index)
    {
        V ret = null;
        List<V> values = getList(keyfalse);
        if (values != null)
        {
            ret = values.remove(index);
            if (values.isEmpty())
            {
                .remove(key);
            }
        }
        return ret;
    }
    @Override public int size()
    {
        return .size();
    }
    @Override public String toString()
    {
        return .toString();
    }
    @Override public Collection<V> values()
    {
        List<V> all = new ArrayList<V>(.size());
        for (List<V> values : .values())
        {
            all.addAll(values);
        }
        return all;
    }
    private List<V> getList(Object keyboolean create)
    {
        List<V> values = .get(key);
        if ((values == null) && create)
        {
            values = new ArrayList<V>();
            .put((K) keyvalues);
        }
        return values;
    }
    class ShadowEntry implements Map.Entry<K, V>
    {
        private final K _key;
        ShadowEntry(K key)
        {
             = key;
        }
        @Override public K getKey()
        {
            return ;
        }
        @Override public V getValue()
        {
            return get();
        }
        @Override public V setValue(V value)
        {
            return put(value);
        }
    }
New to GrepCode? Check out our FAQ X