DelegatingInventoryBackend.java

/*
 * Copyright 2015-2016 Red Hat, Inc. and/or its affiliates
 * and other contributors as indicated by the @author tags.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.hawkular.inventory.base;

import java.io.InputStream;
import java.time.Instant;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;

import org.hawkular.inventory.api.Query;
import org.hawkular.inventory.api.Relationships;
import org.hawkular.inventory.api.model.AbstractElement;
import org.hawkular.inventory.api.model.Blueprint;
import org.hawkular.inventory.api.model.Entity;
import org.hawkular.inventory.api.model.Hashes;
import org.hawkular.inventory.api.model.StructuredData;
import org.hawkular.inventory.api.paging.Page;
import org.hawkular.inventory.api.paging.Pager;
import org.hawkular.inventory.base.spi.CommitFailureException;
import org.hawkular.inventory.base.spi.Discriminator;
import org.hawkular.inventory.base.spi.ElementNotFoundException;
import org.hawkular.inventory.base.spi.EntityHistory;
import org.hawkular.inventory.base.spi.InventoryBackend;
import org.hawkular.inventory.paths.CanonicalPath;
import org.hawkular.inventory.paths.RelativePath;

/**
 * Simple delegating inventory backend impl. Useful as a base class for implementations that need to override behavior
 * of another.
 *
 * @author Lukas Krejci
 * @since 0.4.0
 */
public class DelegatingInventoryBackend<E> implements InventoryBackend<E> {

    protected final InventoryBackend<E> backend;

    public DelegatingInventoryBackend(InventoryBackend<E> backend) {
        this.backend = backend;
    }

    @Override public boolean isUniqueIndexSupported() {
        return backend.isUniqueIndexSupported();
    }

    @Override public boolean isPreferringBigTransactions() {
        return backend.isPreferringBigTransactions();
    }

    @Override
    public void commit() throws CommitFailureException {
        backend.commit();
    }

    @Override
    public <T> T convert(Discriminator discriminator, E entityRepresentation, Class<T> entityType) {
        return backend.convert(discriminator, entityRepresentation, entityType);
    }

    @Override
    public void markDeleted(Discriminator discriminator, E entity) {
        backend.markDeleted(discriminator, entity);
    }

    @Override
    public void deleteStructuredData(E dataRepresentation) {
        backend.deleteStructuredData(dataRepresentation);
    }

    @Override
    public E descendToData(Discriminator discriminator, E dataEntityRepresentation, RelativePath dataPath) {
        return backend.descendToData(discriminator, dataEntityRepresentation, dataPath);
    }

    @Override
    public CanonicalPath extractCanonicalPath(E entityRepresentation) {
        return backend.extractCanonicalPath(entityRepresentation);
    }

    @Override
    public String extractIdentityHash(Discriminator discriminator, E entityRepresentation) {
        return backend.extractIdentityHash(discriminator, entityRepresentation);
    }

    @Override public String extractContentHash(Discriminator discriminator, E entityRepresentation) {
        return backend.extractContentHash(discriminator, entityRepresentation);
    }

    @Override public String extractSyncHash(Discriminator discriminator, E entityRepresentation) {
        return backend.extractSyncHash(discriminator, entityRepresentation);
    }

    @Override
    public String extractId(E entityRepresentation) {
        return backend.extractId(entityRepresentation);
    }

    @Override
    public String extractRelationshipName(E relationship) {
        return backend.extractRelationshipName(relationship);
    }

    @Override
    public Class<?> extractType(E entityRepresentation) {
        return backend.extractType(entityRepresentation);
    }

    @Override
    public E find(Discriminator discriminator, CanonicalPath element) throws ElementNotFoundException {
        return backend.find(discriminator, element);
    }

    @Override
    public E querySingle(Discriminator discriminator, Query query) {
        return backend.querySingle(discriminator, query);
    }

    @Override
    public E traverseToSingle(Discriminator discriminator, E startingPoint, Query query) {
        return backend.traverseToSingle(discriminator, startingPoint, query);
    }

    @Override
    public InputStream getGraphSON(Discriminator discriminator, String tenantId) {
        return backend.getGraphSON(discriminator, tenantId);
    }

    @Override
    public E getRelationship(Discriminator discriminator, E source, E target, String relationshipName) throws ElementNotFoundException {
        return backend.getRelationship(discriminator, source, target, relationshipName);
    }

    @Override
    public Set<E> getRelationships(Discriminator discriminator, E entity, Relationships.Direction direction,
                                   String... names) {
        return backend.getRelationships(discriminator, entity, direction, names);
    }

    @Override
    public E getRelationshipSource(Discriminator discriminator, E relationship) {
        return backend.getRelationshipSource(discriminator, relationship);
    }

    @Override
    public E getRelationshipTarget(Discriminator discriminator, E relationship) {
        return backend.getRelationshipTarget(discriminator, relationship);
    }

    @Override
    public <T extends Entity<?, ?>> Iterator<T> getTransitiveClosureOver(
            Discriminator discriminator, CanonicalPath startingPoint,
            Relationships.Direction direction, Class<T> clazz,
            String... relationshipNames) {
        return backend.getTransitiveClosureOver(discriminator, startingPoint, direction, clazz, relationshipNames);
    }

    @Override
    public Iterator<E> getTransitiveClosureOver(Discriminator discriminator, E startingPoint,
                                                Relationships.Direction direction,
                                                String... relationshipNames) {
        return backend.getTransitiveClosureOver(discriminator, startingPoint, direction, relationshipNames);
    }

    @Override
    public boolean hasRelationship(Discriminator discriminator, E entity, Relationships.Direction direction,
                                   String relationshipName) {
        return backend.hasRelationship(discriminator, entity, direction, relationshipName);
    }

    @Override
    public boolean hasRelationship(Discriminator discriminator, E source, E target, String relationshipName) {
        return backend.hasRelationship(discriminator, source, target, relationshipName);
    }

    @Override
    public E persist(Discriminator discriminator, CanonicalPath path,
                     Blueprint blueprint) {
        return backend.persist(discriminator, path, blueprint);
    }

    @Override
    public E persist(StructuredData structuredData) {
        return backend.persist(structuredData);
    }

    @Override
    public Page<E> query(Discriminator discriminator, Query query, Pager pager) {
        return backend.query(discriminator, query, pager);
    }

    @Override
    public <T> Page<T> query(Discriminator discriminator, Query query, Pager pager,
                             Function<E, T> conversion,
                             Function<T, Boolean> filter) {
        return backend.query(discriminator, query, pager, conversion, filter);
    }

    @Override
    public E relate(Discriminator discriminator, E sourceEntity, E targetEntity, String name,
                    Map<String, Object> properties) {
        return backend.relate(discriminator, sourceEntity, targetEntity, name, properties);
    }

    @Override
    public void rollback() {
        backend.rollback();
    }

    @Override
    public boolean isBackendInternal(E element) {
        return backend.isBackendInternal(element);
    }

    @Override
    public InventoryBackend<E> startTransaction() {
        return backend.startTransaction();
    }

    @Override
    public Page<E> traverse(Discriminator discriminator, E startingPoint, Query query,
                            Pager pager) {
        return backend.traverse(discriminator, startingPoint, query, pager);
    }

    @Override
    public void update(Discriminator discriminator, E entity, AbstractElement.Update update) {
        backend.update(discriminator, entity, update);
    }

    @Override public void updateHashes(Discriminator discriminator, E entity, Hashes hashes) {
        backend.updateHashes(discriminator, entity, hashes);
    }

    @Override
    public void close() throws Exception {
        backend.close();
    }

    @Override public boolean requiresRollbackAfterFailure(Throwable t) {
        return backend.requiresRollbackAfterFailure(t);
    }

    @Override public void eradicate(E entity) {
        backend.eradicate(entity);
    }

    @Override public <T extends Entity<?, U>, U extends Entity.Update>
    EntityHistory<T> getHistory(E entity, Class<T> entityType, Instant from, Instant to) {
        return backend.getHistory(entity, entityType, from, to);
    }
}