Logo Search packages:      
Sourcecode: zeroc-ice-java version File versions  Download package

SubMap.java

// **********************************************************************
//
// Copyright (c) 2003-2006 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************

package Freeze;

//
// Sub-map of a Freeze Map or of another submap
//
//
// When it's based of an index, the key is the index key and the value
// is a Set of Map.Entry.
//

class SubMap extends java.util.AbstractMap implements java.util.SortedMap
{
    private class IndexValue extends java.util.AbstractSet
    {
      public java.util.Iterator
      iterator()
      {
          return _index.untypedFind(_myKey, true);
      }
             
      public int
      size()
      {
          return _index.untypedCount(_myKey);
      }

      public boolean equals(Object o)
      {
          if(o instanceof IndexValue)
          {
            IndexValue indexValue = (IndexValue)o;
            return indexValue._myKey.equals(_myKey);
          }
          else
          {
            return false;
          }
      }

      public int hashCode()
      {
          return _myKey.hashCode();
      }
      
      private IndexValue(Object key)
      {
          _myKey = key;
      }

      private Object
      getKey()
      {
          return _myKey;
      }

      private Object _myKey;
    }

    private class IndexEntry implements java.util.Map.Entry
    {
      public Object getKey()
      {
          return _value.getKey();
      }

      public Object getValue()
      {
          return _value;
      }
     
      public Object setValue(Object value)
      {
          throw new UnsupportedOperationException();
      } 

      public boolean equals(Object o)
      {
          if(o instanceof IndexEntry)
          {
            IndexEntry indexEntry = (IndexEntry)o;
            return indexEntry._value.equals(_value);
          }
          else
          {
            return false;
          }
      }

      public int hashCode()
      {
          return _value.hashCode();
      }
      
      SubMap parent()
      {
          return SubMap.this;
      }

      private IndexEntry(Object key)
      {
          _value = new IndexValue(key);
      }

      private IndexValue _value;
    }

    private class IndexIterator implements Map.EntryIterator
    {
      public boolean hasNext()
      {
          return _iterator.hasNext();
      }
       
      public Object next()
      {
          Map.Entry entry = (Map.Entry)_iterator.next();
          return new IndexEntry(_index.decodeKey(entry.getIndexBytes(),
                                       _map.connection().communicator()));
      }
        
      public void remove()
      {
          _iterator.remove();
      }
      
      public void close()
      {
          _iterator.close();
      }

      public void destroy()
      {
          close();
      }
      
      private IndexIterator()
      {
          assert _index != null;
          _iterator = _map.createIterator(_index, _fromKey, _toKey);
      }

      Map.EntryIterator _iterator;
    }

    SubMap(Map map, Object fromKey, Object toKey)
    {
      _fromKey = fromKey;
      _toKey = toKey;
      _map = map;
      _index = null;

      if(fromKey != null && toKey != null)
      {
          if(map.comparator().compare(fromKey, toKey) >= 0)
          {
            throw new IllegalArgumentException();
          }
      }
    }
    
    SubMap(Map.Index index, Object fromKey, Object toKey)
    {
      _fromKey = fromKey;
      _toKey = toKey;
      _map = index.parent();
      _index = index;

      if(fromKey != null && toKey != null)
      {
          if(index.comparator().compare(fromKey, toKey) >= 0)
          {
            throw new IllegalArgumentException();
          }
      }
    }
    
    private SubMap(SubMap subMap, Object fromKey, Object toKey)
    {
      _fromKey = fromKey;
      _toKey = toKey;
      _map = subMap._map;
      _index = subMap._index;

      if(fromKey != null && toKey != null)
      {
          if(comparator().compare(fromKey, toKey) >= 0)
          {
            throw new IllegalArgumentException();
          }
      }
    }

    //
    // SortedMap methods
    //
    public java.util.Comparator comparator()
    {
      if(_index != null)
      {
          return _index.comparator();
      }
      else
      {
          return _map.comparator();
      }
    }

    public Object firstKey()
    {
      return _index != null ?
          _index.firstKey(_fromKey, _toKey) :
          _map.firstKey(_fromKey, _toKey);
    }

    public Object lastKey()
    {
      return _index != null ?
          _index.lastKey(_fromKey, _toKey) :
          _map.lastKey(_fromKey, _toKey);
    }

    public java.util.SortedMap headMap(Object toKey)
    {
      if(toKey == null)
      {
          throw new NullPointerException();
      }
      return new SubMap(this, _fromKey, toKey);
      
    }
    
    public java.util.SortedMap tailMap(Object fromKey)
    {
      if(fromKey == null)
      {
          throw new NullPointerException();
      }
      return new SubMap(this, fromKey, _toKey);
    } 
   
    public java.util.SortedMap subMap(Object fromKey, Object toKey)
    {
      if(fromKey == null || toKey == null )
      {
          throw new NullPointerException();
      }
      return new SubMap(this, fromKey, toKey);
    }

    //
    // java.util.Map methods
    //
    public java.util.Set
    entrySet()
    {
      if(_entrySet == null)
      {
            _entrySet = new java.util.AbstractSet()
          {
            public java.util.Iterator
            iterator()
            {
                if(_index == null)
                {
                  return _map.createIterator(_index, _fromKey, _toKey);
                }
                else
                {
                  return new IndexIterator();
                }
            }
            
            public boolean
            contains(Object o)
            {
                if(_index == null)
                {
                  //
                  // If the main map contains this object, check it's within [fromKey, toKey[
                  //
                  if(_map.entrySet().contains(o))
                  {
                      Map.Entry entry = (Map.Entry)o;
                      return inRange(entry.getKey());
                  }
                  else
                  {
                      return false;
                  }
                }
                else
                {
                  if(o instanceof IndexEntry)
                  {
                      IndexEntry indexEntry = (IndexEntry)o;
                      return indexEntry.parent() == SubMap.this && 
                        _index.containsKey(indexEntry.getKey());
                  }
                  else
                  {
                      return false;
                  }
                }
            }
                  
            public boolean
            remove(Object o)
            {
                if(_index == null)
                {
                  if(o instanceof Map.Entry)
                  {
                      Map.Entry entry = (Map.Entry)o;
                      return inRange(entry.getKey()) && _map.entrySet().remove(o);
                  }
                  else
                  {
                      return false;
                  }
                }
                else
                {
                  //
                  // Not yet implemented, should remove all objects that
                  // match this index-key
                  //
                  throw new UnsupportedOperationException();
                }
            }
            
            public int
            size()
            {
                throw new UnsupportedOperationException(); 
            }
            
            public boolean
            isEmpty()
            {
                try
                {
                  firstKey();
                  return false;
                }
                catch(NoSuchElementException e)
                {
                  return true;
                }
            }
            };
      }
        return _entrySet;
    }
    
    //
    // Put is not implemented (you have to put in the main map view)
    //


    public boolean constainsKey(Object key)
    {
      if(!inRange(key))
      {
          return false;
      }

      //
      // Then check if it's in the map
      //
      if(_index == null)
      {
          return _map.containsKey(key);
      }
      else
      {
          return _index.containsKey(key);
      }
    }
    
    
    public Object
    get(Object key)
    {
      if(!inRange(key))
      {
          return null;
      }
      
      if(_index == null)
      {
          return _map.get(key);
      }
      else
      {
          if(_index.containsKey(key))
          {
            return new IndexValue(key);
          }
          else
          {
            return null;
          }
      }
    }
    
    public Object
    remove(Object key)
    {
      if(!inRange(key))
      {
          return null;
      }
      
      if(_index == null)
      {
          return _map.remove(key);
      }
      else
      {
          //
          // Not yet implemented
          //
          throw new UnsupportedOperationException();
      }
    }

    public boolean
    fastRemove(Object key)
    {
      if(!inRange(key))
      {
          return false;
      }
      
      if(_index == null)
      {
          return _map.fastRemove(key);
      }
      else
      {
          //
          // Not yet implemented
          //
          throw new UnsupportedOperationException();
      }
    }

    
    private boolean inRange(Object key)
    {
      if(_fromKey != null && comparator().compare(_fromKey, key) > 0)
      {
          return false;
      }
      if(_toKey != null && comparator().compare(key, _toKey) >= 0)
      {
          return false;
      }
      return true;
    }

    private final Object _fromKey;
    private final Object _toKey;
    private final Map _map;
    private final Map.Index _index;
    private java.util.Set _entrySet;
}

Generated by  Doxygen 1.6.0   Back to index