## org.biojava.bio
Class AbstractAnnotation

    java.lang.Object
      org.biojava.utils.AbstractChangeable
          org.biojava.bio.AbstractAnnotation

All Implemented Interfaces:
  Serializable, Annotation, Changeable

Direct Known Subclasses:
  AnnotationChanger, AnnotationRenamer, BeanAsAnnotation, ReferenceAnnotation, SimpleAnnotation, SmallAnnotation

    public abstract class AbstractAnnotation

extends AbstractChangeable
implements Annotation, Serializable

A utility class to ease the problem of implementing an Annotation to that of providing an apropreate implementation of Map. Where possible implementations This class is only intended as a way to implement Annotation. If you are not trying to do that, then don't read on. If you are reading the documentation for an Annotation implementation that extends this, then don't read on. There is nothing to see here. If you are still reading this, then you must be trying to implement Annotation. To do that, extend this class and implement `getProperties()` and `propertiesAllocated()`. Where possible implementations should be backed with a `LinkedHashMap` or similar so properties are iterated in the order they were added.

Since:
  1.0
Author:
  Matthew Pocock, Greg Cox
See Also:
  Serialized Form

Field Summary

Fields inherited from interface org.biojava.bio.Annotation
`EMPTY_ANNOTATION, PROPERTY`

Constructor Summary
`protected` `AbstractAnnotation()` Protected no-args constructor intended for sub-classes.
`protected` `AbstractAnnotation(Annotation ann)` Copy-constructor.
`` `AbstractAnnotation(Map annMap)` Create a new Annotation by copying the key-value pairs from a map.

Method Summary
`Map` `asMap()` Return a map that contains the same key/values as this Annotation.
`boolean` `containsProperty(Object key)` Returns whether there the property is defined.
`boolean` `equals(Object o)`
`protected abstract Map` `getProperties()` Implement this to return the Map delegate.
`Object` `getProperty(Object key)` Retrieve the value of a property by key.
`int` `hashCode()`
`Set` `keys()` Get a set of key objects.
`protected abstract boolean` `propertiesAllocated()` A convenience method to see if we have allocated the properties Map.
`void` `removeProperty(Object key)` Delete a property.
`void` `setProperty(Object key, Object value)` Set the value of a property.
`String` `toString()`

Methods inherited from class org.biojava.utils.AbstractChangeable
`addChangeListener, addChangeListener, generateChangeSupport, getChangeSupport, hasListeners, hasListeners, isUnchanging, removeChangeListener, removeChangeListener`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface org.biojava.utils.Changeable
`addChangeListener, addChangeListener, isUnchanging, removeChangeListener, removeChangeListener`

Constructor Detail

### AbstractAnnotation

    protected AbstractAnnotation()

  Protected no-args constructor intended for sub-classes. This class is abstract and can not be directly instantiated.

### AbstractAnnotation

    protected AbstractAnnotation(Annotation ann)

  Copy-constructor.

  This does a shallow copy of the annotation. The result is an annotation with the same properties and values, but which is independant of the original annotation.

  Parameters:
    `ann` - the Annotation to copy

### AbstractAnnotation

    public AbstractAnnotation(Map annMap)

  Create a new Annotation by copying the key-value pairs from a map. The resulting Annotation is independant of the map.

  Parameters:
    `annMap` - the Map to copy from.

Method Detail

### getProperties

    protected abstract Map getProperties()

  Implement this to return the Map delegate. Modifying this return value will modify the properties associated with this annotation. From code in the 1.2 version of AbstractAnnotation This is required for the implementation of an Annotation that extends AbstractAnnotation. Where possible implementations should be backed with a `LinkedHashMap` or similar so properties are iterated in the order they were added.

  Returns:
    a Map containing all properties

### propertiesAllocated

    protected abstract boolean propertiesAllocated()

  A convenience method to see if we have allocated the properties Map. This is required for the implementation of an Annotation that extends AbstractAnnotation.

  Returns:
    true if the properties have been allocated, false otherwise

### getProperty

    public Object getProperty(Object key)
                       throws NoSuchElementException

  Description copied from interface: `Annotation`

  Retrieve the value of a property by key.

  Unlike the Map collections, it will complain if the key does not exist. It will only return null if the key is defined and has value null.

  Normal raw access to the property. For cleverer access, use methods in AnnotationType.

  Specified by:
    `getProperty` in interface `Annotation`
  Parameters:
    `key` - the key of the property to retrieve
  Returns:
    the object associated with that key
  Throws:
    `NoSuchElementException` - if there is no property with the key

### setProperty

    public void setProperty(Object key,
                            Object value)
                     throws ChangeVetoException

  Description copied from interface: `Annotation`

  Set the value of a property.

  This method throws an exception if either properties can not be added to this object, or that this particular property is immutable or illegal within the implementation.

  Normal raw access to the property. For cleverer access, use methods in AnnotationType.

  Specified by:
    `setProperty` in interface `Annotation`
  Parameters:
    `key` - the key object
    `value` - the new value for this key
  Throws:
    `ChangeVetoException` - if this annotation object can't be changed, or if the change was vetoed.

### removeProperty

    public void removeProperty(Object key)
                        throws ChangeVetoException,
                               NoSuchElementException

  Description copied from interface: `Annotation`
  Delete a property. Normal raw access to the property. For cleverer access, use methods in AnnotationType.

  Specified by:
    `removeProperty` in interface `Annotation`
  Parameters:
    `key` - the key object
  Throws:
    `ChangeVetoException` - if the change is vetoed
    `NoSuchElementException` - if the property doesn't exist

### containsProperty

    public boolean containsProperty(Object key)

  Description copied from interface: `Annotation`
  Returns whether there the property is defined. Normal raw access to the property. For cleverer access, use methods in AnnotationType.

  Specified by:
    `containsProperty` in interface `Annotation`
  Parameters:
    `key` - the key Object to search for
  Returns:
    true if this Annotation knows about the key, false otherwise

### keys

    public Set keys()

  Description copied from interface: `Annotation`
  Get a set of key objects.

  Specified by:
    `keys` in interface `Annotation`
  Returns:
    a Set of key objects

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### asMap

    public Map asMap()

  Description copied from interface: `Annotation`
  Return a map that contains the same key/values as this Annotation.

  If the annotation changes, the map may not reflect this. The Map may be unmodifiable.

  Specified by:
    `asMap` in interface `Annotation`
  Returns:
    a Map

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `Object`

### equals

    public boolean equals(Object o)

  Overrides:
    `equals` in class `Object`