net.sf.javagimmicks.collections.mapping.AbstractMappings Maven / Gradle / Ivy

Go to download
package net.sf.javagimmicks.collections.mapping;

import java.util.AbstractSet;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;

public abstract class AbstractMappings implements Mappings
{
   private static final long serialVersionUID = -8390090502631423671L;

   public Set> getMappingSet()
   {
      return new MappingSet(getLeftMap().entrySet());
   }
   
   public Iterator> iterator()
   {
      return getMappingSet().iterator();
   }

   public Mappings getInverseMappings()
   {
      return new InverseMappings(this);
   }

   public Set getRight(L left)
   {
      return getLeftMap().get(left);
   }

   public Set getLeft(R right)
   {
      return getRightMap().get(right);
   }
   
   public boolean put(L left, R right)
   {
      throw new UnsupportedOperationException();
   }
   
   public boolean putLeft(R right, Collection c)
   {
      boolean result = false;

      for(L left : c)
      {
         result |= put(left, right);
      }
      
      return result;
   }

   public boolean putRight(L left, Collection c)
   {
      boolean result = false;
      
      for(R right : c)
      {
         result |= put(left, right);
      }
      
      return result;
   }

   public boolean remove(L left, R right)
   {
      final Set mappedValuesLeft = getRight(left);
      
      return mappedValuesLeft != null ? mappedValuesLeft.remove(right) : false;
   }
   
   public boolean containsLeft(L left)
   {
      return getLeftMap().containsKey(left);
   }

   public boolean containsRight(R right)
   {
      return getRightMap().containsKey(right);
   }

   public boolean contains(L left, R right)
   {
      final Set rightSet = getRight(left);
      return rightSet != null && rightSet.contains(right);
   }

   public Set removeRight(L left)
   {
      return getLeftMap().remove(left);
   }

   public Set removeLeft(R right)
   {
      return getRightMap().remove(right);
   }
   
   public void clear()
   {
      getLeftMap().clear();
   }
   
   public int size()
   {
      return getMappingSet().size();
   }
   
   public boolean isEmpty()
   {
      return getMappingSet().isEmpty();
   }

   @Override
   public boolean equals(Object obj)
   {
      if(this == obj)
      {
         return true;
      }
      
      if(!(obj instanceof Mappings))
      {
         return false;
      }
      
      Mappings other = (Mappings)obj;
      
      return getMappingSet().equals(other.getMappingSet());
   }

   public String toString()
   {
      return new StringBuilder()
         .append(getLeftMap())
         .append(" | ")
         .append(getRightMap())
         .toString();
   }
   
   protected static class MappingSet extends AbstractSet>
   {
      protected final Set>> _entries;

      public MappingSet(Set>> entries)
      {
         _entries = entries;
      }

      @Override
      public Iterator> iterator()
      {
         return new MappingIterator(_entries.iterator());
      }

      @Override
      public int size()
      {
         int size = 0;
         for(Entry> entry : _entries)
         {
            size += entry.getValue().size();
         }
         
         return size;
      }
   }
   
   protected static class MappingIterator implements Iterator>
   {
      protected final Iterator>> _entryIterator;

      protected Iterator _valueItertor;
      protected Entry> _currentEntry;
      protected R _currentValue;
      
      protected MappingIterator(Iterator>> entryIterator)
      {
         _entryIterator = entryIterator;
      }

      public boolean hasNext()
      {
         return (_valueItertor != null && _valueItertor.hasNext()) || _entryIterator.hasNext();
      }
      
      public Mapping next()
      {
         moveNext();

         return new DefaultMapping(_currentEntry.getKey(), _currentValue);
      }
      
      public void remove()
      {
         _valueItertor.remove();
         if(_currentEntry.getValue().isEmpty())
         {
            _entryIterator.remove();
         }
      }

      private void moveNext()
      {
         if(_valueItertor == null || !_valueItertor.hasNext())
         {
            _currentEntry = _entryIterator.next();
            _valueItertor = _currentEntry.getValue().iterator();
         }

         _currentValue = _valueItertor.next();
      }
   }
   
   public static class InverseMappings extends AbstractMappings
   {
      private static final long serialVersionUID = -4525522714547396946L;
      
      protected final Mappings _partner;
      
      public InverseMappings(Mappings partner)
      {
         _partner = partner;
      }

      @Override
      public Mappings getInverseMappings()
      {
         return _partner;
      }

      @Override
      public boolean put(R left, L right)
      {
         return _partner.put(right, left);
      }

      @Override
      public void clear()
      {
         _partner.clear();
      }

      public Map> getLeftMap()
      {
         return _partner.getRightMap();
      }

      @Override
      public Set getRight(R left)
      {
         return _partner.getLeft(left);
      }

      @Override
      public Set getLeft(L right)
      {
         return _partner.getRight(right);
      }

      public Map> getRightMap()
      {
         return _partner.getLeftMap();
      }

      @Override
      public boolean remove(R left, L right)
      {
         return _partner.remove(right, left);
      }

      @Override
      public Set removeRight(R left)
      {
         return _partner.removeLeft(left);
      }

      @Override
      public Set removeLeft(L right)
      {
         return _partner.removeRight(right);
      }
   }
}