org.hawkular.inventory.base

Class BaseMetricTypes.Single<BE>

java.lang.Object

org.hawkular.inventory.base.Traversal<BE,E>

org.hawkular.inventory.base.BaseMetricTypes.Single<BE>

All Implemented Interfaces:

MetricTypes.Single, Relatable<Relationships.ReadWrite>, ResolvableToMany<MetricType>, ResolvableToSingle<MetricType,MetricType.Update>, ResolvableToSingleWithRelationships<MetricType,MetricType.Update>

Enclosing class:

BaseMetricTypes

public static class BaseMetricTypes.Single<BE>
extends Traversal<BE,E>
implements MetricTypes.Single

Field Summary

Fields inherited from class org.hawkular.inventory.base.Traversal

context

Constructor Summary

Constructors

Constructor and Description
Single(TraversalContext<BE,MetricType> context)

Method Summary

Modifier and Type	Method and Description
protected void	cleanup(BE deletedEntity) Serves the same purpose as Mutator.cleanup(Object, Object) and is called during the delete() method inside the transaction.
void	delete() Deletes the entity.
Page<E>	entities(Pager pager)
E	entity() Resolves the entity and returns it.
protected <T> Page<T>	loadEntities(Pager pager, BiFunction<BE,E,T> conversionFunction) Loads the entities given the pager and converts them using the provided conversion function to the desired type.
protected <T> T	loadEntity(BiFunction<BE,E,T> conversion) Loads the entity from the backend and let's the caller do some conversion on either the backend representation of the entity or the converted entity (both of these are required even during the loading so no unnecessary work is done by providing both of the to the caller).
Metrics.Read	metrics()
protected void	preUpdate(BE updatedEntity, U update) Hook to be run prior to update.
Relationships.ReadWrite	relationships()
Relationships.ReadWrite	relationships(Relationships.Direction direction)
void	update(U u) Updates the entity.

Methods inherited from class org.hawkular.inventory.base.Traversal

getSingle, isApplicable, mutating, readOnly

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.hawkular.inventory.api.ResolvableToSingle

delete, entity, exists, update

Methods inherited from interface org.hawkular.inventory.api.Relatable

relationships, relationships

Methods inherited from interface org.hawkular.inventory.api.ResolvableToMany

anyExists, entities

Constructor Detail

Single

public Single(TraversalContext<BE,MetricType> context)

Method Detail

metrics

public Metrics.Read metrics()

Returns:

metrics defined by the metric type(s)

relationships

public Relationships.ReadWrite relationships()

relationships

public Relationships.ReadWrite relationships(Relationships.Direction direction)

entity

public E entity()
         throws EntityNotFoundException,
                RelationNotFoundException

Description copied from interface: ResolvableToSingle

Resolves the entity and returns it.

Specified by:

entity in interface ResolvableToSingle<E extends AbstractElement<?,U>,U extends AbstractElement.Update>

Returns:

the entity at the current position in the inventory traversal

Throws:

EntityNotFoundException - if there is no entity corresponding to the traversal

RelationNotFoundException - if there is no relation corresponding to the traversal

loadEntity

protected <T> T loadEntity(BiFunction<BE,E,T> conversion)
                    throws EntityNotFoundException,
                           RelationNotFoundException

Loads the entity from the backend and let's the caller do some conversion on either the backend representation of the entity or the converted entity (both of these are required even during the loading so no unnecessary work is done by providing both of the to the caller).

Type Parameters:

T - the result type

Parameters:

conversion - the conversion function taking the backend entity as well as the model entity

Returns:

the converted result of loading the entity

Throws:

EntityNotFoundException

RelationNotFoundException

delete

public void delete()

Description copied from interface: ResolvableToSingle

Deletes the entity.

Specified by:

delete in interface ResolvableToSingle<E extends AbstractElement<?,U>,U extends AbstractElement.Update>

update

public void update(U u)
            throws EntityNotFoundException,
                   RelationNotFoundException

Description copied from interface: ResolvableToSingle

Updates the entity.

Specified by:

update in interface ResolvableToSingle<E extends AbstractElement<?,U>,U extends AbstractElement.Update>

Parameters:

u - the update to be applied

Throws:

EntityNotFoundException - if there is no entity corresponding to the traversal

RelationNotFoundException - if there is no relation corresponding to the traversal

cleanup

protected void cleanup(BE deletedEntity)

Serves the same purpose as Mutator.cleanup(Object, Object) and is called during the delete() method inside the transaction.

Parameters:

deletedEntity - the backend representation of the deleted entity

preUpdate

protected void preUpdate(BE updatedEntity,
                         U update)

Hook to be run prior to update. Serves the same purpose as Mutator.preUpdate(Object, Object, AbstractElement.Update) but is not supplied the id object that can be determined from the updated entity.

By default, this does nothing.

Parameters:

updatedEntity - the backend representation of the updated entity

update - the update object

entities

public Page<E> entities(Pager pager)

Specified by:

entities in interface ResolvableToMany<E extends AbstractElement<?,U>>

Parameters:

pager - the pager object describing the subset of the entities to return

Returns:

resolves all entities on the current position in the inventory traversal and produces a single "page" of those entities according to the provided pager

loadEntities

protected <T> Page<T> loadEntities(Pager pager,
                                   BiFunction<BE,E,T> conversionFunction)

Loads the entities given the pager and converts them using the provided conversion function to the desired type.

Note that the conversion function accepts both the backend entity and the converted entity because both of them are required anyway during the loading and thus the function can choose which one to use without any additional conversion cost.

Type Parameters:

T - the desired target type of the elements of the returned page

Parameters:

pager - the pager specifying the page of the data to load

conversionFunction - the conversion function to convert to the desired target type

Returns:

the page of the results as specified by the pager