Logo
Distributed Genetic Programming Framework
print print

File org.sfc.id.HID.java

Here you can find all the information about the file org.sfc.id.HID.java. You may explore it here or download it onto your local disk.
/*
 * Copyright (c) 2006 Thomas Weise
 * 
 * E-Mail           : tweise@gmx.de
 * Creation Date    : 2006-05-25 06:45:58
 * Original Filename: org.sfc.id.HID.java
 * Version          : 1.0.0
 * Last modification: 2006-05-25
 *                by: Thomas Weise
 * 
 * License          : GNU LESSER GENERAL PUBLIC LICENSE
 *                    Version 2.1, February 1999
 *                    You should have received a copy of this license along
 *                    with this library; if not, write to the Free Software
 *                    Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *                    MA 02111-1307, USA or download the license under
 *                    http://www.gnu.org/copyleft/lesser.html.
 *                    
 * Warranty         : This software is provided "as is" 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.
 */

 
package org.sfc.id;

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

import org.sfc.collections.IVisitable;
import org.sfc.collections.IVisitor;




/**
 * Hierarchical identifier allow you to nest different types of IDs.
 * @param <Type>        The type of the objects this sort of id will
 *                      uniquely be assigned to - classes or strings are
 *                      common.
 * @param <IDType>      The type of this class.
 * @param <ChildType>   The type of the objects the children of this sort
 *                      of id will uniquely be assigned to - classes or
 *                      strings are common.
 * @param <ChildIDType> The sort of child-ids.
 *
 * @author Thomas Weise
 */

public class HID<Type, ChildType, ChildIDType extends
                 LeafHID<ChildType,ChildIDType>,
                 IDType extends HID<Type, ChildType, ChildIDType, IDType>>
        extends     LeafHID<Type, IDType>
        implements  Map<ChildType, ChildIDType>,
                    Iterable<ChildIDType>,
                    IVisitable<ChildIDType>
  {
/**
 * The serial version uid.
 */

  private static final long serialVersionUID = 1;
  
/**
 * The child id manager.
 */

  final transient IDManager<ChildType, ChildIDType> m_child_ids  ;
  
/**
 * This constructor is suitable for all sorts of normal ids.
 * @param p_id  The external object this id is uniquely assigned to.
 */

  protected HID(final Type p_id)
    {
    super(p_id);
    this.m_child_ids = new IDManager<ChildType, ChildIDType>();
    }
  
/**
 * This constructor is suitable for all sorts of normal ids.
 * @param p_owner   The owning hid.
 * @param p_id      The identifying object.
 */

  protected HID(final HID<?, Type, IDType, ?>  p_owner,
                final Type                     p_id)
    {
    super(p_owner, p_id);
    this.m_child_ids = new IDManager<ChildType, ChildIDType>();
    }
  
/**
 * Obtain the manager for the ids of this type.
 * @return  The manager for the ids of this type.
 */

  @Override
  protected IDManager<Type, IDType> get_root_manager ()
    {
    return this.m_owner.m_child_ids;
    }
  
/**
 * Returns the number of key-value mappings in this map.  If the
 * map contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
 * <tt>Integer.MAX_VALUE</tt>.
 *
 * @return the number of key-value mappings in this map.
 */

  public  final int size()
    {
    return this.m_child_ids.size();
    }

/**
 * Returns <tt>true</tt> if this map contains no key-value mappings.
 *
 * @return <tt>true</tt> if this map contains no key-value mappings.
 */

  public  final boolean isEmpty()
    {
    return this.m_child_ids.isEmpty();
    }

/**
 * Returns <tt>true</tt> if this map contains a mapping for the specified
 * key.  More formally, returns <tt>true</tt> if and only if
 * this map contains a mapping for a key <tt>k</tt> such that
 * <tt>(key==null ? k==null : key.equals(k))</tt>.  (There can be
 * at most one such mapping.)
 *
 * @param p_key key whose presence in this map is to be tested.
 * @return <tt>true</tt> if this map contains a mapping for the specified
 *         key.
 * 
 * @throws ClassCastException if the key is of an inappropriate type for
 *      this map (optional).
 * @throws NullPointerException if the key is <tt>null</tt> and this map
 *            does not permit <tt>null</tt> keys (optional).
 */

  public  final boolean containsKey(final Object p_key)
    {
    return this.m_child_ids.containsKey(p_key);
    }

/**
 * Returns <tt>true</tt> if this map maps one or more keys to the
 * specified value.  More formally, returns <tt>true</tt> if and only if
 * this map contains at least one mapping to a value <tt>v</tt> such that
 * <tt>(value==null ? v==null : value.equals(v))</tt>.  This operation
 * will probably require time linear in the map size for most
 * implementations of the <tt>Map</tt> interface.
 *
 * @param p_value value whose presence in this map is to be tested.
 * @return <tt>true</tt> if this map maps one or more keys to the
 *         specified value.
 * @throws ClassCastException if the value is of an inappropriate type for
 *      this map (optional).
 * @throws NullPointerException if the value is <tt>null</tt> and this map
 *            does not permit <tt>null</tt> values (optional).
 */

  public  final boolean containsValue(final Object p_value)
    {
    return this.m_child_ids.containsValue(p_value);
    }

/**
 * Returns the value to which this map maps the specified key.  Returns
 * <tt>null</tt> if the map contains no mapping for this key.  A return
 * value of <tt>null</tt> does not <i>necessarily</i> indicate that the
 * map contains no mapping for the key; it's also possible that the map
 * explicitly maps the key to <tt>null</tt>.  The <tt>containsKey</tt>
 * operation may be used to distinguish these two cases.
 *
 * <p>More formally, if this map contains a mapping from a key
 * <tt>k</tt> to a value <tt>v</tt> such that <tt>(key==null ? k==null :
 * key.equals(k))</tt>, then this method returns <tt>v</tt>; otherwise
 * it returns <tt>null</tt>.  (There can be at most one such mapping.)
 *
 * @param p_key key whose associated value is to be returned.
 * @return the value to which this map maps the specified key, or
 *         <tt>null</tt> if the map contains no mapping for this key.
 * 
 * @throws ClassCastException if the key is of an inappropriate type for
 *      this map (optional).
 * @throws NullPointerException if the key is <tt>null</tt> and this map
 *      does not permit <tt>null</tt> keys (optional).
 * 
 * @see #containsKey(Object)
 */

  public  final ChildIDType get(final Object p_key)
    {
    return this.m_child_ids.get(p_key);
    }

// Modification Operations

/**
 * does nothing
 *
 * @param p_key useless
 * @param p_value useless
 * @return never
 * @throws UnsupportedOperationException always
 */

  public  final  ChildIDType  put(final ChildType   p_key,
                                  final ChildIDType p_value)
    {
    throw new UnsupportedOperationException();
    }

/**
 * does nothing
 *
 * @param p_key useless
 * @return never
 *
 * @throws UnsupportedOperationException always
 */

  public  final ChildIDType remove(final  Object p_key)
    {
    throw new UnsupportedOperationException();
    }


// Bulk Operations

/**
 * does nothing
 *
 * @param p_t useless
 * 
 * @throws UnsupportedOperationException always
 */

  public final void putAll(Map<? extends ChildType,? extends ChildIDType> p_t)
    {
    throw new UnsupportedOperationException();
    }

/**
 * does nothing
 *
 * @throws UnsupportedOperationException always
 */

  public  final void clear()
    {
    throw new UnsupportedOperationException();
    }


// Views

/**
 * Returns a set view of the keys contained in this map.  The set is
 * backed by the map, so changes to the map are reflected in the set, and
 * vice-versa.  If the map is modified while an iteration over the set is
 * in progress (except through the iterator's own <tt>remove</tt>
 * operation), the results of the iteration are undefined.  The set
 * supports element removal, which removes the corresponding mapping from
 * the map, via the <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
 * <tt>removeAll</tt> <tt>retainAll</tt>, and <tt>clear</tt> operations.
 * It does not support the add or <tt>addAll</tt> operations.
 *
 * @return a set view of the keys contained in this map.
 */

  public  final Set<ChildType> keySet()
    {
    return this.m_child_ids.keySet();
    }

/**
 * Returns a collection view of the values contained in this map.  The
 * collection is backed by the map, so changes to the map are reflected in
 * the collection, and vice-versa.  If the map is modified while an
 * iteration over the collection is in progress (except through the
 * iterator's own <tt>remove</tt> operation), the results of the
 * iteration are undefined.  The collection supports element removal,
 * which removes the corresponding mapping from the map, via the
 * <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>,
 * <tt>removeAll</tt>, <tt>retainAll</tt> and <tt>clear</tt> operations.
 * It does not support the add or <tt>addAll</tt> operations.
 *
 * @return a collection view of the values contained in this map.
 */

  public  final Collection<ChildIDType> values()
    {
    return this.m_child_ids.values();
    }

/**
 * Returns a set view of the mappings contained in this map.  Each element
 * in the returned set is a {@link java.util.Map.Entry}.  The set is backed
 * by the map, so changes to the map are reflected in the set, and vice-versa.
 * If the map is modified while an iteration over the set is in progress
 * (except through the iterator's own <tt>remove</tt> operation, or through
 * the <tt>setValue</tt> operation on a map entry returned by the iterator)
 * the results of the iteration are undefined.  The set supports element
 * removal, which removes the corresponding mapping from the map, via the
 * <tt>Iterator.remove</tt>, <tt>Set.remove</tt>, <tt>removeAll</tt>,
 * <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not support
 * the <tt>add</tt> or <tt>addAll</tt> operations.
 *
 * @return a set view of the mappings contained in this map.
 */

  public  final Set<Map.Entry<ChildType, ChildIDType>> entrySet()
    {
    return this.m_child_ids.entrySet();
    }    
  

/**
 * Visit all ids in this id manager.
 * @param p_visitor The visitor to be carried around.
 * @return  <code>true</code> if the visitor successfully visited all
 *          elements, <code>false</code> if it aborted its visit.
 */

  public  final boolean  visit (final IVisitor<ChildIDType> p_visitor)
    {
    return this.m_child_ids.visit(p_visitor);
    }
  

/**
 * Returns an iterator over a set of elements of type T.
 * 
 * @return an Iterator.
 */

  public  final Iterator<ChildIDType> iterator()
    {
    return this.m_child_ids.iterator();
    }
  }

File Information:

file name:HID.java
package:org.sfc.id
qualified name:org.sfc.id.HID.java
file type:Java Source File
download location:download http://dgpf.sourceforge.net/source/org/sfc/id/HID.java
size:11.104 KB (11371 B)
uploaded: 2015-07-22 04:11:11 GMT+0000
last update: 2006-05-28 13:22:41 GMT+0000
last access: 2018-01-20 18:37:18 GMT+0000

statistics online since 2006-01-02.   RSS Feed
Contact us by sending an email to tweise@gmx.de to receive further information, to report errors, or to join our project.
All content on this site (http://dgpf.sourceforge.net/) is LGPL-licensed.
http://dgpf.sourceforge.net/scripts/source/source.php last modified at 2015-07-22 04:10:53 GMT+0000 served at 2018-01-20 18:37:18 GMT+0000.
Valid CSS Valid XHTML 1.1
Valid RSS SourceForge.net Logo