modules/core/src/main/java/org/apache/ignite/internal/processors/igfs/IgfsPathIds.java - ignite - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements.  See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to You 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.apache.ignite.internal.processors.igfs;

 import org.apache.ignite.igfs.IgfsPath;
 import org.apache.ignite.lang.IgniteUuid;
 import org.jetbrains.annotations.Nullable;

 import java.util.Collection;
 import java.util.Map;

 /**
  * Path IDs abstraction. Contains path and corresponding IDs.
  */
 public class IgfsPathIds {
     /** Original path. */
     private final IgfsPath path;

     /** Path parts. */
     private final String[] parts;

     /** IDs. */
     private final IgniteUuid[] ids;

     /** Surrogate IDs for paths which doesn't exist yet. Initialized on demand. */
     private IgniteUuid[] surrogateIds;

     /** Index of last existing ID. */
     private final int lastExistingIdx;

     /**
      * Constructor.
      *
      * @param path Path.
      * @param parts Path parts.
      * @param ids IDs.
      */
     public IgfsPathIds(IgfsPath path, String[] parts, IgniteUuid[] ids) {
         assert path != null;
         assert parts.length == ids.length;

         this.path = path;
         this.parts = parts;
         this.ids = ids;

         int lastExistingIdx0 = -1;

         for (int i = parts.length - 1; i >= 0; i--) {
             if (ids[i] != null) {
                 lastExistingIdx0 = i;

                 break;
             }
         }

         assert lastExistingIdx0 >= 0;

         lastExistingIdx = lastExistingIdx0;
     }

     /**
      * Get parent entity.
      *
      * @return Parent entity.
      */
     public IgfsPathIds parent() {
         assert ids.length > 1;

         String[] parentParts = new String[parts.length - 1];
         IgniteUuid[] parentIds = new IgniteUuid[ids.length - 1];

         System.arraycopy(parts, 0, parentParts, 0, parentParts.length);
         System.arraycopy(ids, 0, parentIds, 0, parentIds.length);

         return new IgfsPathIds(path.parent(), parentParts, parentIds);
     }

     /**
      * Get number of elements.
      *
      * @return ID count.
      */
     public int count() {
         return ids.length;
     }

     /**
      * Get original path.
      *
      * @return Path.
      */
     public IgfsPath path() {
         return path;
     }

     /**
      * Get path part at the given index.
      *
      * @param idx Index.
      * @return Path part.
      */
     public String part(int idx) {
         assert idx < parts.length;

         return parts[idx];
     }

     /**
      * Get last part of original path.
      *
      * @return Last part.
      */
     public String lastPart() {
         return parts[parts.length - 1];
     }

     /**
      * Get last ID.
      *
      * @return Last ID.
      */
     public IgniteUuid lastId() {
         return ids[ids.length - 1];
     }

     /**
      * Get last parent ID.
      *
      * @return Last parent ID.
      */
     @Nullable public IgniteUuid lastParentId() {
         return ids[ids.length - 2];
     }

     /**
      * Whether provided index denotes last entry in the path.
      *
      * @param idx Index.
      * @return {@code True} if last.
      */
     public boolean isLastIndex(int idx) {
         return idx == parts.length - 1;
     }

     /**
      * Get path of the last existing element.
      *
      * @return Path of the last existing element.
      */
     public IgfsPath lastExistingPath() {
         IgfsPath path = IgfsPath.ROOT;

         for (int i = 1; i <= lastExistingIdx; i++)
             path = new IgfsPath(path, parts[i]);

         return path;
     }

     /**
      * Whether all parts exists.
      *
      * @return {@code True} if all parts were found.
      */
     public boolean allExists() {
         return parts.length == lastExistingIdx + 1;
     }

     /**
      * Whether last entry exists.
      *
      * @return {@code True} if exists.
      */
     public boolean lastExists() {
         return lastExistingIdx == ids.length - 1;
     }


     /**
      * Whether parent of the last entry exists.
      *
      * @return {@code True} if exists.
      */
     public boolean lastParentExists() {
         return ids.length > 1 && lastExistingIdx == ids.length - 2;
     }

     /**
      * Get ID of the last existing entry.
      *
      * @return ID of the last existing entry.
      */
     public IgniteUuid lastExistingId() {
         return ids[lastExistingIdx];
     }

     /**
      * Get index of the last existing entry.
      *
      * @return Index of the last existing entry.
      */
     public int lastExistingIndex() {
         return lastExistingIdx;
     }

     /**
      * Add existing IDs to provided collection.
      *
      * @param col Collection.
      * @param relaxed Relaxed mode flag.
      */
     @SuppressWarnings("ManualArrayToCollectionCopy")
     public void addExistingIds(Collection<IgniteUuid> col, boolean relaxed) {
         if (relaxed) {
             col.add(ids[lastExistingIdx]);

             if (lastExistingIdx == ids.length - 1 && lastExistingIdx > 0)
                 col.add(ids[lastExistingIdx - 1]);
         }
         else {
             for (int i = 0; i <= lastExistingIdx; i++)
                 col.add(ids[i]);
         }
     }

     /**
      * Add surrogate IDs to provided collection potentially creating them on demand.
      *
      * @param col Collection.
      */
     @SuppressWarnings("ManualArrayToCollectionCopy")
     public void addSurrogateIds(Collection<IgniteUuid> col) {
         if (surrogateIds == null) {
             surrogateIds = new IgniteUuid[ids.length];

             for (int i = lastExistingIdx + 1; i < surrogateIds.length; i++)
                 surrogateIds[i] = IgniteUuid.randomUuid();
         }

         for (int i = lastExistingIdx + 1; i < surrogateIds.length; i++)
             col.add(surrogateIds[i]);
     }

     /**
      * Get ID at the give index.
      *
      * @param idx Index.
      * @return ID.
      */
     public IgniteUuid id(int idx) {
         return idx <= lastExistingIdx ? ids[idx] : surrogateId(idx);
     }

     /**
      * Get surrogate ID at the given index.
      *
      * @param idx Index.
      * @return Surrogate ID.
      */
     public IgniteUuid surrogateId(int idx) {
         assert surrogateIds != null;

         assert idx > lastExistingIdx;
         assert idx < surrogateIds.length;

         return surrogateIds[idx];
     }

     /**
      * Verify that observed paths are found in provided infos in the right order.
      *
      * @param infos Info.
      * @param relaxed Whether to perform check in relaxed mode.
      * @return {@code True} if full integrity is preserved.
      */
     public boolean verifyIntegrity(Map<IgniteUuid, IgfsEntryInfo> infos, boolean relaxed) {
         if (relaxed) {
             // Relaxed mode ensures that the last element is there. If this element is the last in the path, then
             // existence of it's parent and link between them are checked as well.
             IgfsEntryInfo info = infos.get(ids[lastExistingIdx]);

             if (info == null)
                 return false;

             if (lastExistingIdx == ids.length - 1 && lastExistingIdx > 0) {
                 IgfsEntryInfo parentInfo = infos.get(ids[lastExistingIdx - 1]);

                 if (parentInfo == null || !parentInfo.hasChild(parts[lastExistingIdx], ids[lastExistingIdx]))
                     return false;
             }
         }
         else {
             // Strict mode ensures that all participants are in place and are still linked.
             for (int i = 0; i <= lastExistingIdx; i++) {
                 IgfsEntryInfo info = infos.get(ids[i]);

                 // Check if required ID is there.
                 if (info == null)
                     return false;

                 // For non-leaf entry we check if child exists.
                 if (i < lastExistingIdx) {
                     if (!info.hasChild(parts[i + 1], ids[i + 1]))
                         return false;
                 }
             }
         }

         return true;
     }
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to You 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.apache.ignite.internal.processors.igfs;

	import org.apache.ignite.igfs.IgfsPath;
	import org.apache.ignite.lang.IgniteUuid;
	import org.jetbrains.annotations.Nullable;

	import java.util.Collection;
	import java.util.Map;

	/**
	* Path IDs abstraction. Contains path and corresponding IDs.
	*/
	public class IgfsPathIds {
	/** Original path. */
	private final IgfsPath path;

	/** Path parts. */
	private final String[] parts;

	/** IDs. */
	private final IgniteUuid[] ids;

	/** Surrogate IDs for paths which doesn't exist yet. Initialized on demand. */
	private IgniteUuid[] surrogateIds;

	/** Index of last existing ID. */
	private final int lastExistingIdx;

	/**
	* Constructor.
	*
	* @param path Path.
	* @param parts Path parts.
	* @param ids IDs.
	*/
	public IgfsPathIds(IgfsPath path, String[] parts, IgniteUuid[] ids) {
	assert path != null;
	assert parts.length == ids.length;

	this.path = path;
	this.parts = parts;
	this.ids = ids;

	int lastExistingIdx0 = -1;

	for (int i = parts.length - 1; i >= 0; i--) {
	if (ids[i] != null) {
	lastExistingIdx0 = i;

	break;
	}
	}

	assert lastExistingIdx0 >= 0;

	lastExistingIdx = lastExistingIdx0;
	}

	/**
	* Get parent entity.
	*
	* @return Parent entity.
	*/
	public IgfsPathIds parent() {
	assert ids.length > 1;

	String[] parentParts = new String[parts.length - 1];
	IgniteUuid[] parentIds = new IgniteUuid[ids.length - 1];

	System.arraycopy(parts, 0, parentParts, 0, parentParts.length);
	System.arraycopy(ids, 0, parentIds, 0, parentIds.length);

	return new IgfsPathIds(path.parent(), parentParts, parentIds);
	}

	/**
	* Get number of elements.
	*
	* @return ID count.
	*/
	public int count() {
	return ids.length;
	}

	/**
	* Get original path.
	*
	* @return Path.
	*/
	public IgfsPath path() {
	return path;
	}

	/**
	* Get path part at the given index.
	*
	* @param idx Index.
	* @return Path part.
	*/
	public String part(int idx) {
	assert idx < parts.length;

	return parts[idx];
	}

	/**
	* Get last part of original path.
	*
	* @return Last part.
	*/
	public String lastPart() {
	return parts[parts.length - 1];
	}

	/**
	* Get last ID.
	*
	* @return Last ID.
	*/
	public IgniteUuid lastId() {
	return ids[ids.length - 1];
	}

	/**
	* Get last parent ID.
	*
	* @return Last parent ID.
	*/
	@Nullable public IgniteUuid lastParentId() {
	return ids[ids.length - 2];
	}

	/**
	* Whether provided index denotes last entry in the path.
	*
	* @param idx Index.
	* @return {@code True} if last.
	*/
	public boolean isLastIndex(int idx) {
	return idx == parts.length - 1;
	}

	/**
	* Get path of the last existing element.
	*
	* @return Path of the last existing element.
	*/
	public IgfsPath lastExistingPath() {
	IgfsPath path = IgfsPath.ROOT;

	for (int i = 1; i <= lastExistingIdx; i++)
	path = new IgfsPath(path, parts[i]);

	return path;
	}

	/**
	* Whether all parts exists.
	*
	* @return {@code True} if all parts were found.
	*/
	public boolean allExists() {
	return parts.length == lastExistingIdx + 1;
	}

	/**
	* Whether last entry exists.
	*
	* @return {@code True} if exists.
	*/
	public boolean lastExists() {
	return lastExistingIdx == ids.length - 1;
	}


	/**
	* Whether parent of the last entry exists.
	*
	* @return {@code True} if exists.
	*/
	public boolean lastParentExists() {
	return ids.length > 1 && lastExistingIdx == ids.length - 2;
	}

	/**
	* Get ID of the last existing entry.
	*
	* @return ID of the last existing entry.
	*/
	public IgniteUuid lastExistingId() {
	return ids[lastExistingIdx];
	}

	/**
	* Get index of the last existing entry.
	*
	* @return Index of the last existing entry.
	*/
	public int lastExistingIndex() {
	return lastExistingIdx;
	}

	/**
	* Add existing IDs to provided collection.
	*
	* @param col Collection.
	* @param relaxed Relaxed mode flag.
	*/
	@SuppressWarnings("ManualArrayToCollectionCopy")
	public void addExistingIds(Collection<IgniteUuid> col, boolean relaxed) {
	if (relaxed) {
	col.add(ids[lastExistingIdx]);

	if (lastExistingIdx == ids.length - 1 && lastExistingIdx > 0)
	col.add(ids[lastExistingIdx - 1]);
	}
	else {
	for (int i = 0; i <= lastExistingIdx; i++)
	col.add(ids[i]);
	}
	}

	/**
	* Add surrogate IDs to provided collection potentially creating them on demand.
	*
	* @param col Collection.
	*/
	@SuppressWarnings("ManualArrayToCollectionCopy")
	public void addSurrogateIds(Collection<IgniteUuid> col) {
	if (surrogateIds == null) {
	surrogateIds = new IgniteUuid[ids.length];

	for (int i = lastExistingIdx + 1; i < surrogateIds.length; i++)
	surrogateIds[i] = IgniteUuid.randomUuid();
	}

	for (int i = lastExistingIdx + 1; i < surrogateIds.length; i++)
	col.add(surrogateIds[i]);
	}

	/**
	* Get ID at the give index.
	*
	* @param idx Index.
	* @return ID.
	*/
	public IgniteUuid id(int idx) {
	return idx <= lastExistingIdx ? ids[idx] : surrogateId(idx);
	}

	/**
	* Get surrogate ID at the given index.
	*
	* @param idx Index.
	* @return Surrogate ID.
	*/
	public IgniteUuid surrogateId(int idx) {
	assert surrogateIds != null;

	assert idx > lastExistingIdx;
	assert idx < surrogateIds.length;

	return surrogateIds[idx];
	}

	/**
	* Verify that observed paths are found in provided infos in the right order.
	*
	* @param infos Info.
	* @param relaxed Whether to perform check in relaxed mode.
	* @return {@code True} if full integrity is preserved.
	*/
	public boolean verifyIntegrity(Map<IgniteUuid, IgfsEntryInfo> infos, boolean relaxed) {
	if (relaxed) {
	// Relaxed mode ensures that the last element is there. If this element is the last in the path, then
	// existence of it's parent and link between them are checked as well.
	IgfsEntryInfo info = infos.get(ids[lastExistingIdx]);

	if (info == null)
	return false;

	if (lastExistingIdx == ids.length - 1 && lastExistingIdx > 0) {
	IgfsEntryInfo parentInfo = infos.get(ids[lastExistingIdx - 1]);

	if (parentInfo == null \|\| !parentInfo.hasChild(parts[lastExistingIdx], ids[lastExistingIdx]))
	return false;
	}
	}
	else {
	// Strict mode ensures that all participants are in place and are still linked.
	for (int i = 0; i <= lastExistingIdx; i++) {
	IgfsEntryInfo info = infos.get(ids[i]);

	// Check if required ID is there.
	if (info == null)
	return false;

	// For non-leaf entry we check if child exists.
	if (i < lastExistingIdx) {
	if (!info.hasChild(parts[i + 1], ids[i + 1]))
	return false;
	}
	}
	}

	return true;
	}
	}