EntityReferenceSet.java

/*
 * See the NOTICE file distributed with this work for additional
 * information regarding copyright ownership.
 *
 * This is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this software; if not, write to the Free
 * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
 */
package org.xwiki.model.reference;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.xwiki.model.EntityType;

/**
 * A set of entities references.
 * 
 * @version $Id: 0c462c78d7420c277617c7e165c2a423e62abfec $
 * @since 5.2M2
 */
public class EntityReferenceSet
{
    private static class EntityReferenceEntryChildren
    {
        public EntityType childrenType;

        public Map<String, EntityReferenceEntry> children;

        public EntityReferenceEntry add(String name, Map<String, Serializable> entityParameters)
        {
            if (this.children == null) {
                this.children = new HashMap<String, EntityReferenceEntry>();
            }

            EntityReferenceEntry entry = this.children.get(name);

            if (entry == null) {
                entry = new EntityReferenceEntry(this.childrenType, name);

                if (entityParameters != null) {
                    entry.addParameters(entityParameters);
                }

                this.children.put(name, entry);
            } else {
                if (!entry.matches(entityParameters)) {
                    entry.addParameters(entityParameters);
                }
            }

            return entry;
        }

        @Override
        public String toString()
        {
            StringBuilder builder = new StringBuilder();

            builder.append(this.childrenType);
            builder.append('(');
            builder.append(this.children);

            return builder.toString();
        }
    }

    private static class EntityReferenceEntry
    {
        public EntityType type;

        public String name;

        public List<Map<String, Serializable>> parameters;

        public Map<EntityType, EntityReferenceEntryChildren> children;

        public EntityReferenceEntry()
        {
        }

        public EntityReferenceEntry(EntityType type, String name)
        {
            this.type = type;
            this.name = name;
        }

        public EntityReferenceEntry add()
        {
            return add(null, null, null);
        }

        public EntityReferenceEntryChildren getChildren(EntityType entityType, boolean create)
        {
            if (this.children == null) {
                if (!create) {
                    return null;
                }

                this.children = new HashMap<>();
            }

            EntityReferenceEntryChildren child = this.children.get(entityType);

            if (child == null) {
                if (!create) {
                    return null;
                }

                child = new EntityReferenceEntryChildren();
                child.childrenType = entityType;
                this.children.put(entityType, child);
            }

            return child;
        }

        public EntityReferenceEntryChildren getClosestChildren(EntityType entityType)
        {
            EntityReferenceEntryChildren typedChildren = getChildren(entityType, false);

            if (typedChildren != null) {
                return typedChildren;
            }

            // Search for the closest

            if (this.children == null) {
                return null;
            }

            for (Map.Entry<EntityType, EntityReferenceEntryChildren> entry : this.children.entrySet()) {
                EntityReferenceEntryChildren typedChilrendEntry = entry.getValue();

                if (typedChilrendEntry.childrenType.ordinal() > entityType.ordinal()) {
                    // Only return a potential child of the passed type
                    if (typedChildren == null
                        || typedChildren.childrenType.ordinal() > typedChilrendEntry.childrenType.ordinal()) {
                        typedChildren = typedChilrendEntry;
                    }
                }
            }

            return typedChildren;
        }

        public EntityReferenceEntry add(EntityType entityType, String entityName,
            Map<String, Serializable> entityParameters)
        {
            EntityReferenceEntryChildren child = getChildren(entityType, true);

            return child.add(entityName, entityParameters);
        }

        private void addParameters(Map<String, Serializable> entityParameters)
        {
            if (!entityParameters.isEmpty()) {
                if (this.parameters == null) {
                    this.parameters = new ArrayList<Map<String, Serializable>>();
                }

                this.parameters.add(entityParameters);
            }
        }

        public boolean matches(EntityReference reference)
        {
            return matches(reference.getParameters());
        }

        public boolean matches(Map<String, Serializable> referenceParameters)
        {
            if (parameters == null) {
                return true;
            }

            boolean matches = parameters.isEmpty();

            for (Map<String, Serializable> parametersMap : parameters) {
                matches |= matches(referenceParameters, parametersMap);
            }

            return matches;
        }

        private boolean matches(Map<String, Serializable> referenceParameters, Map<String, Serializable> map)
        {
            for (Map.Entry<String, Serializable> entry : map.entrySet()) {
                if (referenceParameters.containsKey(entry.getKey())) {
                    if (!Objects.equals(entry.getValue(), referenceParameters.get(entry.getKey()))) {
                        return false;
                    }
                }
            }

            return true;
        }

        @Override
        public String toString()
        {
            StringBuilder builder = new StringBuilder();

            if (this.type != null) {
                builder.append(this.type);
                builder.append(':');
                builder.append(this.name);
            }

            if (this.children != null) {
                builder.append('(');
                builder.append(this.children);
                builder.append(')');
            }

            return builder.toString();
        }
    }

    private EntityReferenceEntry includes;

    private EntityReferenceEntry excludes;

    private void add(EntityReference reference, EntityReferenceEntry entry)
    {
        EntityReferenceEntry currentEntry = entry;

        for (EntityReference element : reference.getReversedReferenceChain()) {
            // Move the first element to the right level in the tree
            if (currentEntry == entry) {
                while (currentEntry.children != null && currentEntry.getClosestChildren(element.getType()) == null) {
                    currentEntry = currentEntry.add();
                }
            }

            currentEntry = currentEntry.add(element.getType(), element.getName(), element.getParameters());
        }
    }

    /**
     * @param reference the reference
     * @return the entity reference set
     */
    public EntityReferenceSet includes(EntityReference reference)
    {
        if (this.includes == null) {
            this.includes = new EntityReferenceEntry();
        }

        add(reference, this.includes);

        return this;
    }

    /**
     * @param reference the reference
     * @return the entity reference set
     */
    public EntityReferenceSet excludes(EntityReference reference)
    {
        if (this.excludes == null) {
            this.excludes = new EntityReferenceEntry();
        }

        add(reference, this.excludes);

        return this;
    }

    private boolean matchesInclude(EntityReference reference)
    {
        if (this.includes == null) {
            return true;
        }

        EntityReferenceEntry currentEntry = this.includes;
        for (EntityReference element : reference.getReversedReferenceChain()) {
            // No children
            if (currentEntry.children == null) {
                return true;
            }

            EntityReferenceEntryChildren typedChildren = currentEntry.children.get(element.getType());

            if (typedChildren != null) {
                // Children have same type
                EntityReferenceEntry nameEntry = typedChildren.children.get(element.getName());

                if (nameEntry == null) {
                    currentEntry = typedChildren.children.get(null);

                    if (currentEntry == null) {
                        return false;
                    }
                } else {
                    currentEntry = nameEntry;
                }

                if (!currentEntry.matches(element)) {
                    return false;
                }
            } else {
                if (currentEntry.name != null || currentEntry.getClosestChildren(element.getType()) == null) {
                    return false;
                }
            }
        }

        return true;
    }

    private boolean matchesExclude(EntityReference reference)
    {
        if (this.excludes == null) {
            return true;
        }

        EntityReferenceEntry currentEntry = this.excludes;
        for (EntityReference element : reference.getReversedReferenceChain()) {
            // No children
            if (currentEntry.children == null) {
                return false;
            }

            EntityReferenceEntryChildren typedChildren = currentEntry.children.get(element.getType());

            if (typedChildren != null) {
                // Children have same type
                EntityReferenceEntry nameEntry = typedChildren.children.get(element.getName());

                if (nameEntry == null) {
                    currentEntry = typedChildren.children.get(null);

                    if (currentEntry == null) {
                        return true;
                    }
                } else {
                    currentEntry = nameEntry;
                }

                if (!currentEntry.matches(element)) {
                    return true;
                }
            }
        }

        // Check if the reference is shorter than the exclude(s)
        return currentEntry.children != null
        // Check if the excluded parameters are the same as the one the reference contains
            || (currentEntry.parameters != null && CollectionUtils.intersection(
                getParametersKeys(currentEntry.parameters), reference.getParameters().keySet()).isEmpty());
    }

    private Set<String> getParametersKeys(List<Map<String, Serializable>> parameters)
    {
        if (parameters.isEmpty()) {
            return Collections.emptySet();
        }

        Set<String> set = new HashSet<String>();

        for (Map<String, Serializable> map : parameters) {
            set.addAll(map.keySet());
        }

        return set;
    }

    /**
     * @param reference the reference
     * @return the entity reference set
     */
    public boolean matches(EntityReference reference)
    {
        return matchesInclude(reference) && matchesExclude(reference);
    }
}