org.hawkular.inventory.base

Class BaseResources.ReadWrite<BE>

java.lang.Object

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

org.hawkular.inventory.base.BaseResources.ReadWrite<BE>

All Implemented Interfaces:

ReadInterface<Resources.Single,Resources.Multiple,String>, ResolvingToMultiple<Resources.Multiple>, ResolvingToSingle<Resources.Single,String>, Resources.ReadBase<String>, Resources.ReadContained, Resources.ReadWrite

Enclosing class:

BaseResources

public static class BaseResources.ReadWrite<BE>
extends Traversal<BE,E>
implements Resources.ReadWrite

Field Summary

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

context

Constructor Summary

Constructors

Constructor and Description
ReadWrite(TraversalContext<BE,Resource> context)

Method Summary

Modifier and Type	Method and Description
protected void	cleanup(Id id, BE entityRepresentation) A hook that can run additional clean up logic inside the delete transaction.
Resources.Single	create(Resource.Blueprint blueprint) Creates a new entity at the current position in the inventory traversal.
void	delete(Id id)
protected Query	doCreate(B blueprint) A helper method to be used in the implementation of the WriteInterface.create(Blueprint) method.
Resources.Single	get(String id) Tries to find a single entity in the current position in the inventory traversal.
Resources.Multiple	getAll(Filter[][] filters) Returns access interface to all entities conforming to the provided filters in the current position in the inventory traversal.
protected String	getProposedId(Resource.Blueprint blueprint) Extracts the proposed ID from the blueprint or identifies the ID through some other means.
protected void	preUpdate(Id id, BE entityRepresentation, U update) A hook that can run additional logic inside the update transaction before anything has been persisted to the backend database.
protected BE	relate(BE source, BE target, String relationshipName)
void	update(Id id, U update)
protected EntityAndPendingNotifications<Resource>	wireUpNewEntity(BE entity, Resource.Blueprint blueprint, CanonicalPath parentPath, BE parent) Wires up the freshly created entity in the appropriate places in inventory.

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.WriteInterface

delete, update

Methods inherited from interface org.hawkular.inventory.api.Resources.ReadBase

descend

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

getAll

Constructor Detail

ReadWrite

public ReadWrite(TraversalContext<BE,Resource> context)

Method Detail

getProposedId

protected String getProposedId(Resource.Blueprint blueprint)

Extracts the proposed ID from the blueprint or identifies the ID through some other means.

Parameters:

blueprint - the blueprint of the entity to be created

Returns:

the ID to be used for the new entity

wireUpNewEntity

protected EntityAndPendingNotifications<Resource> wireUpNewEntity(BE entity,
                                                                  Resource.Blueprint blueprint,
                                                                  CanonicalPath parentPath,
                                                                  BE parent)

Wires up the freshly created entity in the appropriate places in inventory. The "contains" relationship between the parent and the new entity will already have been created so the implementations don't need to do that again.

The wiring up might result in new relationships being created or other "notifiable" actions - the returned object needs to reflect that so that the notification can correctly be emitted.

Parameters:

entity - the freshly created, uninitialized entity

blueprint - the blueprint that it prescribes how the entity should be initialized

parentPath - the path to the parent entity

parent - the actual parent entity

Returns:

an object with the initialized and converted entity together with any pending notifications to be sent out

getAll

public Resources.Multiple getAll(Filter[][] filters)

Description copied from interface: ResolvingToMultiple

Returns access interface to all entities conforming to the provided filters in the current position in the inventory traversal.

The filters parameter is actually composed of individual sets of filters each of which is applied to the "source" entities. Each set can have multiple filters that are then applied one after another on their intermediate results. This becomes useful when you want to filter by sources having some kind of relationships with other entities and in addition filter on the sources themselves, too. E.g.:

 inventory.tenants().getAll(new Filter[][]{{Related.by("myRel"), With.type(ResourceType.class)},
 {With.id("asf")}}).entities();
 

The filter above would first check that the tenants in question have a relationship called "myRel" with some resource types and then would also check if the tenant has ID "asf".

Specified by:

getAll in interface ResolvingToMultiple<Resources.Multiple>

Parameters:

filters - the sets of filters to apply

Returns:

the access to found entities

get

public Resources.Single get(String id)
                     throws EntityNotFoundException

Description copied from interface: ResolvingToSingle

Tries to find a single entity in the current position in the inventory traversal.

Specified by:

get in interface ResolvingToSingle<Resources.Single,String>

Parameters:

id - the identification of sorts of the entity to find in the current traversal position

Returns:

access interface to the entity

Throws:

EntityNotFoundException

create

public Resources.Single create(Resource.Blueprint blueprint)
                        throws EntityAlreadyExistsException

Description copied from interface: WriteInterface

Creates a new entity at the current position in the inventory traversal.

Parameters:

blueprint - the blueprint to be used to create the new entity

Returns:

access interface to the freshly created entity

Throws:

EntityAlreadyExistsException - if the entity already exists

doCreate

protected final Query doCreate(B blueprint)

A helper method to be used in the implementation of the WriteInterface.create(Blueprint) method.

The callers may merely use the returned query and construct a new *Single instance using it.

Parameters:

blueprint - the blueprint of the new entity

Returns:

the query to the newly created entity.

update

public final void update(Id id,
                         U update)
                  throws EntityNotFoundException

Throws:

EntityNotFoundException

delete

public final void delete(Id id)
                  throws EntityNotFoundException

Throws:

EntityNotFoundException

cleanup

protected void cleanup(Id id,
                       BE entityRepresentation)

A hook that can run additional clean up logic inside the delete transaction.

This hook is called prior to anything being deleted.

By default this does nothing.

Parameters:

id - the id of the entity being deleted

entityRepresentation - the backend specific representation of the entity

preUpdate

protected void preUpdate(Id id,
                         BE entityRepresentation,
                         U update)

A hook that can run additional logic inside the update transaction before anything has been persisted to the backend database.

By default, this does nothing

Parameters:

id - the id of the entity being updated

entityRepresentation - the backend representation of the updated entity

update - the update object

relate

protected BE relate(BE source,
                    BE target,
                    String relationshipName)