PathAwareEntityFinderDelegate.java
/*
* *********************************************************************************************************************
*
* blueMarine II: Semantic Media Centre
* http://tidalwave.it/projects/bluemarine2
*
* Copyright (C) 2015 - 2021 by Tidalwave s.a.s. (http://tidalwave.it)
*
* *********************************************************************************************************************
*
* 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.
*
* *********************************************************************************************************************
*
* git clone https://bitbucket.org/tidalwave/bluemarine2-src
* git clone https://github.com/tidalwave-it/bluemarine2-src
*
* *********************************************************************************************************************
*/
package it.tidalwave.bluemarine2.model.impl;
import javax.annotation.Nonnegative;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.function.Function;
import java.nio.file.Path;
import it.tidalwave.util.As;
import it.tidalwave.util.Finder;
import it.tidalwave.util.spi.FinderSupport;
import it.tidalwave.util.SupplierBasedFinder;
import it.tidalwave.role.SimpleComposite;
import it.tidalwave.bluemarine2.model.MediaFolder;
import it.tidalwave.bluemarine2.model.spi.PathAwareEntity;
import it.tidalwave.bluemarine2.model.spi.PathAwareFinder;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import static java.util.Collections.*;
import static it.tidalwave.role.SimpleComposite._SimpleComposite_;
import static lombok.AccessLevel.PRIVATE;
/***********************************************************************************************************************
*
* A decorator of an {@link Finder} of {@link PathAwareEntity} that creates a virtual tree of entities. Each entity is
* given a path, which starts with the path of a {@link MediaFolder} and continues with the id of the entity.
*
* This {@code Finder} can filtered by path. If a filter path is provided, the filtering happens in memory: this means
* that even when the delegate queries a native store, all the data are first retrieved in memory.
*
* @stereotype Finder
*
* @author Fabrizio Giudici
*
**********************************************************************************************************************/
@RequiredArgsConstructor(access = PRIVATE) @Slf4j
public class PathAwareEntityFinderDelegate extends FinderSupport<PathAwareEntity, PathAwareFinder> implements PathAwareFinder
{
private static final long serialVersionUID = 4429676480224742813L;
@Nonnull
private final MediaFolder mediaFolder;
@Nonnull
private final Finder<PathAwareEntity> delegate;
@Nonnull
private final Optional<Path> optionalPath;
/*******************************************************************************************************************
*
* Creates an instance associated to a given {@link MediaFolder} and a delegate finder.
*
* @see #PathAwareEntityFinderDelegate(it.tidalwave.bluemarine2.model.MediaFolder, java.util.function.Function)
*
* @param mediaFolder the folder associated to this finder
* @param delegate the delegate finder to provide data
*
******************************************************************************************************************/
public PathAwareEntityFinderDelegate (@Nonnull final MediaFolder mediaFolder,
@Nonnull final Finder<PathAwareEntity> delegate)
{
this(mediaFolder, delegate, Optional.empty());
}
/*******************************************************************************************************************
*
* Creates an instance associated to a given {@link MediaFolder} and a function for providing children. This
* constructor is typically used when the children are already present in memory (e.g. they are
* {@link VirtualMediaFolder}s. Because the function doesn't have the full semantics of a {@link Finder} - it can't
* optimise a query in function of search parameters, nor optimise the count of results - when a
* {@code PathAwareEntityFinderDelegate} is created in this way all operations will be performed in memory. If one
* can provide data from a native store and enjoy optimised queries, instead of this constructor use
* {@link #PathAwareEntityFinderDelegate(it.tidalwave.bluemarine2.model.MediaFolder, it.tidalwave.util.Finder)}
*
* @see #PathAwareEntityFinderDelegate(it.tidalwave.bluemarine2.model.MediaFolder, it.tidalwave.util.Finder)
*
* @param mediaFolder the folder associated to this finder
* @param function the function that provides children
*
******************************************************************************************************************/
public PathAwareEntityFinderDelegate (@Nonnull final MediaFolder mediaFolder,
@Nonnull final Function<MediaFolder, Collection<? extends PathAwareEntity>> function)
{
this(mediaFolder, new SupplierBasedFinder<>(() -> function.apply(mediaFolder)), Optional.empty());
}
/*******************************************************************************************************************
*
* Clone constructor.
*
******************************************************************************************************************/
public PathAwareEntityFinderDelegate (@Nonnull final PathAwareEntityFinderDelegate other,
@Nonnull final Object override)
{
super(other, override);
final PathAwareEntityFinderDelegate source = getSource(PathAwareEntityFinderDelegate.class, other, override);
this.mediaFolder = source.mediaFolder;
this.delegate = source.delegate;
this.optionalPath = source.optionalPath;
}
/*******************************************************************************************************************
*
* {@inheritDoc}
*
******************************************************************************************************************/
@Override @Nonnull
public PathAwareFinder withPath (@Nonnull final Path path)
{
return clonedWith(new PathAwareEntityFinderDelegate(mediaFolder, delegate, Optional.of(path)));
}
/*******************************************************************************************************************
*
* {@inheritDoc}
*
******************************************************************************************************************/
@Override @Nonnull
protected List<? extends PathAwareEntity> computeResults()
{
return new CopyOnWriteArrayList<>(optionalPath.flatMap(path -> filteredByPath(path).map(e -> singletonList(e)))
.orElse((List)delegate.results()));
}
/*******************************************************************************************************************
*
* {@inheritDoc}
*
******************************************************************************************************************/
@Override @Nonnegative
public int count()
{
optionalPath.ifPresent(path -> log.warn("Path present: {} - count won't be a native query", path));
return optionalPath.map(path -> filteredByPath(path).map(entity -> 1).orElse(0))
.orElse(delegate.count());
}
/*******************************************************************************************************************
*
*
*
******************************************************************************************************************/
@Nonnull
private Optional<? extends PathAwareEntity> filteredByPath (@Nonnull final Path path)
{
log.debug("filteredByPath({})", path);
return mediaFolder.getPath().equals(path)
? Optional.of(mediaFolder)
: childMatchingPathHead(path).flatMap(entity -> path.equals(entity.getPath())
? Optional.of(entity)
: childMatchingPath(entity, path));
}
/*******************************************************************************************************************
*
* Returns the child entity that matches the first element of the path, if present. The path can be exactly the one
* of the found entity, or it can be of one of its children.
*
* This method performs a bulk query of all children and then filters by path in memory. It is not possible to
* use a query to the native store for the path - which would be good for performance reasons - , because even
* though each segment of the path is function of some attribute of the related {@code PathAwareEntity} - typically
* the id - it is not a matter of the native store. Performance of this section relies upon memory caching. Some
* experiment showed that it's not useful to add another caching layer here, and the one in
* {@code RepositoryFinderSupport} is enough.
*
* @param path the path
* @return the entity, if present
*
******************************************************************************************************************/
@Nonnull
private Optional<PathAwareEntity> childMatchingPathHead (@Nonnull final Path path)
{
// assert filtered.size() == 1 or 0;
log.debug(">>>> bulk query to {}, filtering in memory", delegate);
return (Optional<PathAwareEntity>)delegate.results().stream()
.filter(entity -> sameHead(relative(path), relative(entity.getPath())))
.findFirst();
}
/*******************************************************************************************************************
*
* @param entity
* @param path the path
* @return the entity, if present
*
******************************************************************************************************************/
@Nonnull
private static Optional<PathAwareEntity> childMatchingPath (@Nonnull final PathAwareEntity entity,
@Nonnull final Path path)
{
return ((PathAwareFinder)asSimpleComposite(entity).findChildren()).withPath(path).optionalResult();
}
/*******************************************************************************************************************
*
*
*
******************************************************************************************************************/
@Nonnull // FIXME: this should be normally done by as()
private static SimpleComposite asSimpleComposite (@Nonnull final As object)
{
return (object instanceof SimpleComposite) ? (SimpleComposite)object : object.as(_SimpleComposite_);
}
/*******************************************************************************************************************
*
* Relativizes a path against the finder path, that is it removes the parent path. If the path can't be
* relativized, that is it doesn't start with the finder path, returns null.
*
******************************************************************************************************************/
@Nullable
private Path relative (@Nonnull final Path path)
{
return mediaFolder.getParent().isEmpty() ? path :
path.startsWith(mediaFolder.getPath()) ? path.subpath(mediaFolder.getPath().getNameCount(), path.getNameCount())
: null;
}
/*******************************************************************************************************************
*
*
*
******************************************************************************************************************/
private static boolean sameHead (@Nullable final Path path1, @Nullable final Path path2)
{
return (path1 != null) && (path2 != null) && path1.getName(0).equals(path2.getName(0));
}
}