org.eclipse.jgit.lib

## Class ObjectIdSubclassMap<V extends ObjectId>

- java.lang.Object
- - org.eclipse.jgit.lib.ObjectIdSubclassMap<V>

Type Parameters:
  `V` - type of subclass of ObjectId that will be stored in the map.

All Implemented Interfaces:
  Iterable<V>

    public class ObjectIdSubclassMap<V extends ObjectId>
    extends Object
    implements Iterable<V>

Fast, efficient map specifically for `ObjectId` subclasses.

This map provides an efficient translation from any ObjectId instance to a cached subclass of ObjectId that has the same value.

If object instances are stored in only one map, `ObjectIdOwnerMap` is a more efficient implementation.

### Constructor Summary

Constructors
Constructor and Description
`ObjectIdSubclassMap()` Create an empty map.

### Method Summary

Methods
`<Q extends V> void` `add(Q newValue)` Store an object for future lookup.
`<Q extends V> V` `addIfAbsent(Q newValue)` Store an object for future lookup.
`void` `clear()` Remove all entries from this map.
`boolean` `contains(AnyObjectId toFind)` Returns true if this map contains the specified object.
`V` `get(AnyObjectId toFind)` Lookup an existing mapping.
`boolean` `isEmpty()`
`Iterator<V>` `iterator()`
`int` `size()`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Constructor Detail

#### ObjectIdSubclassMap

    public ObjectIdSubclassMap()

Create an empty map.

### Method Detail

#### clear

    public void clear()

Remove all entries from this map.

#### get

    public V get(AnyObjectId toFind)

Lookup an existing mapping.

Parameters:
  `toFind` - the object identifier to find.
Returns:
  the instance mapped to toFind, or null if no mapping exists.

#### contains

    public boolean contains(AnyObjectId toFind)

Returns true if this map contains the specified object.

Parameters:
  `toFind` - object to find.
Returns:
  true if the mapping exists for this object; false otherwise.

#### add

    public <Q extends V> void add(Q newValue)

Store an object for future lookup.

An existing mapping for must not be in this map. Callers must first call `get(AnyObjectId)` to verify there is no current mapping prior to adding a new mapping, or use `addIfAbsent(ObjectId)`.

Type Parameters:
  `Q` - type of instance to store.
Parameters:
  `newValue` - the object to store.

#### addIfAbsent

    public <Q extends V> V addIfAbsent(Q newValue)

Store an object for future lookup.

Stores `newValue`, but only if there is not already an object for the same object name. Callers can tell if the value is new by checking the return value with reference equality:

     V obj = ...;
     boolean wasNew = map.addIfAbsent(obj) == obj;

Type Parameters:
  `Q` - type of instance to store.
Parameters:
  `newValue` - the object to store.
Returns:
  `newValue` if stored, or the prior value already stored and that would have been returned had the caller used `get(newValue)` first.

#### size

    public int size()

Returns:
  number of objects in map

#### isEmpty

    public boolean isEmpty()

Returns:
  true if `size()` is 0.

#### iterator

    public Iterator<V> iterator()

Specified by:
  `iterator` in interface `Iterable<V extends ObjectId>`