sdks/java/basys.sdk/src/main/java/org/eclipse/basyx/vab/modelprovider/VABPathTools.java - basyx/basyx - Git at Google

 /*******************************************************************************
  * Copyright (C) 2021 the Eclipse BaSyx Authors
  *
  * This program and the accompanying materials are made
  * available under the terms of the Eclipse Public License 2.0
  * which is available at https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  ******************************************************************************/
 package org.eclipse.basyx.vab.modelprovider;

 import java.io.UnsupportedEncodingException;
 import java.net.URLDecoder;
 import java.net.URLEncoder;
 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.basyx.submodel.metamodel.map.submodelelement.operation.Operation;
 import org.eclipse.basyx.vab.exception.provider.MalformedRequestException;

 /**
  * Utility functions to handle a VAB path
  *
  * @author kuhn, espen
  *
  */
 public class VABPathTools {
 	public static final String SEPERATOR = "/";

 	/**
 	 * Removes leading and trailing slashes
 	 *
 	 * @param path
 	 * @return
 	 */
 	public static String stripSlashes(String path) {
 		while (path.startsWith("/")) {
 			path = path.substring(1);
 		}

 		while (path.endsWith("/")) {
 			path = path.substring(0, path.length() - 1);
 		}
 		return path;
 	}

 	/**
 	 * Encodes sensitive characters, e.g. "/" and "#"
 	 *
 	 * @param elem
 	 * @return
 	 */
 	public static String encodePathElement(String elem) {
 		try {
 			return URLEncoder.encode(elem, "UTF-8");
 		} catch (UnsupportedEncodingException e) {
 			throw new RuntimeException(e);
 		}
 	}

 	/**
 	 * Decodes sensitive characters, e.g. "/" and "#"
 	 *
 	 * @param elem
 	 * @return
 	 */
 	public static String decodePathElement(String encodedElem) {
 		try {
 			return URLDecoder.decode(encodedElem, "UTF-8");
 		} catch (UnsupportedEncodingException e) {
 			throw new RuntimeException(e);
 		}
 	}

 	/**
 	 * Skips the first N entries of a path. E.g. for <i>a/b/c</i> skipping 2 means
 	 * returning <i>c</i>
 	 *
 	 * @param path
 	 * @param toSkip
 	 * @return
 	 */
 	public static String skipEntries(String path, int toSkip) {
 		StringBuilder builder = new StringBuilder();
 		String[] splitted = VABPathTools.splitPath(path);

 		for (int i = toSkip; i < splitted.length; i++) {
 			builder.append(splitted[i]);

 			// Don't add slash at last step
 			if (i < splitted.length - 1) {
 				builder.append("/");
 			}

 		}

 		return builder.toString();
 	}

 	/**
 	 * Returns the Nth entry of a path, e.g. the second entry of <i>a/b/c</i> is
 	 * <i>c</i>
 	 *
 	 * @param path
 	 * @param entry
 	 * @return
 	 */
 	public static String getEntry(String path, int entry) {
 		return VABPathTools.splitPath(path)[entry];
 	}

 	/**
 	 * Split a path into path elements, e.g. /a/b/c -> [ a, b, c ]
 	 */
 	public static String[] splitPath(String path) {
 		// Return null result for null argument
 		if (path == null) {
 			return null;
 		}

 		// includes null-values, "" and "/";
 		if (VABPathTools.isEmptyPath(path)) {
 			return new String[] {};
 		}

 		// Remove leading separator, otherwise /a leads to {"", "a"}
 		String fixedPath = removePrefix(path, SEPERATOR);

 		String[] splitted = fixedPath.split(SEPERATOR);
 		List<String> nonEmptySplitted = new ArrayList<>();

 		// Remove empty entries
 		for (String s : splitted) {
 			if (!s.isEmpty()) {
 				nonEmptySplitted.add(s);
 			}
 		}
 		return nonEmptySplitted.toArray(new String[nonEmptySplitted.size()]);
 	}

 	/**
 	 * Remove the last element from the path
 	 */
 	public static String getParentPath(String path) {
 		// Return null result for null argument
 		if (path == null) {
 			return null;
 		}

 		if (isEmptyPath(path)) {
 			return "";
 		}
 		int lastIndex = path.lastIndexOf(SEPERATOR);
 		if (lastIndex == path.length() - 1) {
 			lastIndex = path.lastIndexOf(SEPERATOR, path.length() - 2);
 		}
 		if (lastIndex >= 0) {
 			return removePrefix(path.substring(0, lastIndex), SEPERATOR);
 		} else {
 			return "";
 		}
 	}

 	/**
 	 * Get the last element of a path. Return "" if there is no element in the path
 	 */
 	public static String getLastElement(String path) {
 		// Return null result for null argument
 		if (path == null) {
 			return null;
 		}

 		String[] elements = splitPath(path);
 		if (elements.length > 0) {
 			return elements[elements.length - 1];
 		} else {
 			return "";
 		}
 	}

 	/**
 	 * Remove prefix from beginning of path
 	 */
 	public static String removePrefix(String path, String prefix) {
 		// Return null result for null argument
 		if (path == null) {
 			return null;
 		}

 		if (VABPathTools.isEmptyPath(path)) {
 			// same result as for any other "empty" path, like "" and "/"
 			return "";
 		}
 		if (path.startsWith(prefix)) {
 			return path.substring(prefix.length());
 		} else {
 			return path;
 		}
 	}

 	public static String append(String path, String element) {
 		// Return null result for null argument
 		if (path == null || element == null) {
 			return null;
 		}

 		if (path.lastIndexOf(SEPERATOR) == path.length() - 1) {
 			return path + element;
 		} else {
 			return path + SEPERATOR + element;
 		}
 	}

 	/**
 	 * Build and return a path with pathElements[startIndex] as the root element
 	 */
 	public static String buildPath(String[] pathElements, int startIndex) {
 		// Return null result for null argument
 		if (pathElements == null) {
 			return null;
 		}

 		if (startIndex >= pathElements.length) {
 			return "";
 		}

 		// This will store the resulting path
 		StringBuilder result = new StringBuilder();

 		// Build path
 		for (int i = startIndex; i < pathElements.length; i++)
 			result.append(pathElements[i] + SEPERATOR);

 		// Remove last '/'
 		result.deleteCharAt(result.length() - 1);

 		// Return created path
 		return result.toString();
 	}

 	/**
 	 * Check if the path to an VAB elements leads to the invocation of an operation. In this case, the
 	 * element path conforms to /aas/submodels/{subModelId}/submodelElements/{operationId}/invoke
 	 */
 	public static boolean isOperationInvokationPath(String path) {
 		// null-Paths are no operation paths
 		if (path == null) {
 			return false;
 		}

 		// Split path
 		String[] pathElements = splitPath(path);

 		if(pathElements.length == 0) {
 			return false;
 		}

 		// Check if last path element is "invoke" or "operations" is contained anywhere
 		return pathElements[pathElements.length - 1].startsWith(Operation.INVOKE) || isOperationPath(path);
 	}

 	private static boolean isOperationPath(String path) {
 		String lowerCasePath = path.toLowerCase();
 		return lowerCasePath.startsWith("operations/") || path.toLowerCase().contains("/operations/");
 	}

 	/**
 	 * Check, if the path does not contain any elements.
 	 */
 	public static boolean isEmptyPath(String path) {
 		return path.equals("") || path.equals("/");
 	}

 	/**
 	 * Gets the first endpoint of a path.
 	 * @path
 	 * 		A path that can contain 0..* endpoints.
 	 * @return
 	 * 		The first address entry of a path. The address entry is the first endpoint combined with a protocol.
 	 * 		If there is no protocol defined, the address entry is empty ("").
 	 * 		E.g. basyx://127.0.0.1:6998//https://localhost/test/ will return basyx://127.0.0.1:6998,
 	 * 		https://localhost/test//basyx://127.0.0.1:6998/ will return https://localhost/test
 	 * 		and http://localhost/test/ will return "".
 	 */
 	public static String getFirstEndpoint(String fullPath) {
 		// Return null result for null argument
 		if (fullPath == null) {
 			return null;
 		}

 		if (isEmptyPath(fullPath) || !fullPath.contains("//")) {
 			return "";
 		} else {
 			String[] splitted = fullPath.split("//");
 			return splitted[0] + "//" + splitted[1];
 		}
 	}

 	/**
 	 * Removes the first endpoint from a path. See {@link #getAddressEntry}<br/>
 	 * @path
 	 * @return
 	 * 		The first endpoint. E.g. basyx://127.0.0.1:6998//https://localhost/test/ will return
 	 * 		https://localhost/test/.
 	 *
 	 */
 	public static String removeFirstEndpoint(String fullPath) {
 		// Return null result for null argument
 		if (fullPath == null) {
 			return null;
 		}

 		if (isEmptyPath(fullPath)) {
 			return "";
 		} else if (!fullPath.contains("//")) {
 			return fullPath;
 		} else {
 			String firstEndpoint = fullPath.replaceFirst(getFirstEndpoint(fullPath), "");
 			if (firstEndpoint.startsWith("//")) {
 				firstEndpoint = firstEndpoint.replaceFirst("//", "");
 			}
 			return firstEndpoint;
 		}
 	}

 	/**
 	 * Concatenate two paths
 	 */
 	public static String concatenatePaths(String... paths) {
 		// Return null result for null argument
 		if (paths == null || paths.length == 0) {
 			return null;
 		}

 		// Store result
 		StringBuffer result = new StringBuffer();

 		// Flag that indicates whether processed path segment is first segment
 		boolean isFirst = true;

 		// Process all path segments
 		for (String pathSegment : paths) {
 			// Return empty result, if any element is null
 			if (pathSegment == null) {
 				return null;
 			}

 			// Remove leading and trailing "/" from pathsegment
 			while (pathSegment.endsWith("/"))
 				pathSegment = pathSegment.substring(0, pathSegment.length() - 1);
 			while (pathSegment.startsWith("/"))
 				pathSegment = pathSegment.substring(1);

 			// Add path to result; if its first segment, do not split with "'"
 			if (!isFirst)
 				result.append("/");
 			else
 				isFirst = false;
 			result.append(pathSegment);
 		}

 		// Return combined path
 		return result.toString();
 	}

 	/**
 	 * Checks if path is null, if yes throw exception
 	 *
 	 * @param path
 	 */
 	public static void checkPathForNull(String path) throws MalformedRequestException {
 		if (path == null) {
 			throw new MalformedRequestException("Path is not allowed to be null");
 		}
 	}

 	/**
 	 * Strips the last path element if it is "invoke"
 	 *
 	 * @param path
 	 * @return path without last element "invoke" or unchanged path
 	 */
 	public static String stripInvokeFromPath(String path) {

 		if(path == null)
 			return null;

 		if(getLastElement(path).startsWith(Operation.INVOKE)) {
 			return getParentPath(path);
 		}

 		return path;
 	}

 	/**
 	 * Gets the path from a URL
 	 * e.g "http://localhost:8080/path/to/test.file" results in "/path/to/test.file"
 	 *
 	 * @param url
 	 * @return the path from the URL
 	 */
 	public static String getPathFromURL(String url) {
 		if(url == null) {
 			return null;
 		}

 		if(url.contains("://")) {

 			// Find the ":" and and remove the "http://" from the url
 			int index = url.indexOf(":") + 3;
 			url = url.substring(index);

 			// Find the first "/" from the URL (now without the "http://") and remove everything before that
 			index = url.indexOf("/");
 			url = url.substring(index);

 			// Recursive call to deal with more than one server parts
 			// (e.g. basyx://127.0.0.1:6998//https://localhost/test/)
 			return getPathFromURL(url);
 		} else {
 			// Make sure the path has a / at the start
 			if(!url.startsWith("/")) {
 				url = "/" + url;
 			}
 			return url;
 		}
 	}

 	/**
 	 * Harmonizes a path so that it will always and with the suffix and no ending
 	 * slash (even if the suffix contains one).
 	 *
 	 * @param path
 	 *            to harmonize
 	 * @param suffix
 	 *            to check for existance and append if necessary
 	 * @return harmonized path
 	 */
 	public static String harmonizePathWithSuffix(String path, String suffix) {
 		String strippedPath = stripSlashes(path);
 		String strippedSuffix = stripSlashes(suffix);

 		if (strippedPath.endsWith("/" + strippedSuffix)) {
 			return strippedPath;
 		} else {
 			return VABPathTools.concatenatePaths(strippedPath, strippedSuffix);
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (C) 2021 the Eclipse BaSyx Authors
	*
	* This program and the accompanying materials are made
	* available under the terms of the Eclipse Public License 2.0
	* which is available at https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	******************************************************************************/
	package org.eclipse.basyx.vab.modelprovider;

	import java.io.UnsupportedEncodingException;
	import java.net.URLDecoder;
	import java.net.URLEncoder;
	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.basyx.submodel.metamodel.map.submodelelement.operation.Operation;
	import org.eclipse.basyx.vab.exception.provider.MalformedRequestException;

	/**
	* Utility functions to handle a VAB path
	*
	* @author kuhn, espen
	*
	*/
	public class VABPathTools {
	public static final String SEPERATOR = "/";

	/**
	* Removes leading and trailing slashes
	*
	* @param path
	* @return
	*/
	public static String stripSlashes(String path) {
	while (path.startsWith("/")) {
	path = path.substring(1);
	}

	while (path.endsWith("/")) {
	path = path.substring(0, path.length() - 1);
	}
	return path;
	}

	/**
	* Encodes sensitive characters, e.g. "/" and "#"
	*
	* @param elem
	* @return
	*/
	public static String encodePathElement(String elem) {
	try {
	return URLEncoder.encode(elem, "UTF-8");
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
	}
	}

	/**
	* Decodes sensitive characters, e.g. "/" and "#"
	*
	* @param elem
	* @return
	*/
	public static String decodePathElement(String encodedElem) {
	try {
	return URLDecoder.decode(encodedElem, "UTF-8");
	} catch (UnsupportedEncodingException e) {
	throw new RuntimeException(e);
	}
	}

	/**
	* Skips the first N entries of a path. E.g. for <i>a/b/c</i> skipping 2 means
	* returning <i>c</i>
	*
	* @param path
	* @param toSkip
	* @return
	*/
	public static String skipEntries(String path, int toSkip) {
	StringBuilder builder = new StringBuilder();
	String[] splitted = VABPathTools.splitPath(path);

	for (int i = toSkip; i < splitted.length; i++) {
	builder.append(splitted[i]);

	// Don't add slash at last step
	if (i < splitted.length - 1) {
	builder.append("/");
	}

	}

	return builder.toString();
	}

	/**
	* Returns the Nth entry of a path, e.g. the second entry of <i>a/b/c</i> is
	* <i>c</i>
	*
	* @param path
	* @param entry
	* @return
	*/
	public static String getEntry(String path, int entry) {
	return VABPathTools.splitPath(path)[entry];
	}

	/**
	* Split a path into path elements, e.g. /a/b/c -> [ a, b, c ]
	*/
	public static String[] splitPath(String path) {
	// Return null result for null argument
	if (path == null) {
	return null;
	}

	// includes null-values, "" and "/";
	if (VABPathTools.isEmptyPath(path)) {
	return new String[] {};
	}

	// Remove leading separator, otherwise /a leads to {"", "a"}
	String fixedPath = removePrefix(path, SEPERATOR);

	String[] splitted = fixedPath.split(SEPERATOR);
	List<String> nonEmptySplitted = new ArrayList<>();

	// Remove empty entries
	for (String s : splitted) {
	if (!s.isEmpty()) {
	nonEmptySplitted.add(s);
	}
	}
	return nonEmptySplitted.toArray(new String[nonEmptySplitted.size()]);
	}

	/**
	* Remove the last element from the path
	*/
	public static String getParentPath(String path) {
	// Return null result for null argument
	if (path == null) {
	return null;
	}

	if (isEmptyPath(path)) {
	return "";
	}
	int lastIndex = path.lastIndexOf(SEPERATOR);
	if (lastIndex == path.length() - 1) {
	lastIndex = path.lastIndexOf(SEPERATOR, path.length() - 2);
	}
	if (lastIndex >= 0) {
	return removePrefix(path.substring(0, lastIndex), SEPERATOR);
	} else {
	return "";
	}
	}

	/**
	* Get the last element of a path. Return "" if there is no element in the path
	*/
	public static String getLastElement(String path) {
	// Return null result for null argument
	if (path == null) {
	return null;
	}

	String[] elements = splitPath(path);
	if (elements.length > 0) {
	return elements[elements.length - 1];
	} else {
	return "";
	}
	}

	/**
	* Remove prefix from beginning of path
	*/
	public static String removePrefix(String path, String prefix) {
	// Return null result for null argument
	if (path == null) {
	return null;
	}

	if (VABPathTools.isEmptyPath(path)) {
	// same result as for any other "empty" path, like "" and "/"
	return "";
	}
	if (path.startsWith(prefix)) {
	return path.substring(prefix.length());
	} else {
	return path;
	}
	}

	public static String append(String path, String element) {
	// Return null result for null argument
	if (path == null \|\| element == null) {
	return null;
	}

	if (path.lastIndexOf(SEPERATOR) == path.length() - 1) {
	return path + element;
	} else {
	return path + SEPERATOR + element;
	}
	}

	/**
	* Build and return a path with pathElements[startIndex] as the root element
	*/
	public static String buildPath(String[] pathElements, int startIndex) {
	// Return null result for null argument
	if (pathElements == null) {
	return null;
	}

	if (startIndex >= pathElements.length) {
	return "";
	}

	// This will store the resulting path
	StringBuilder result = new StringBuilder();

	// Build path
	for (int i = startIndex; i < pathElements.length; i++)
	result.append(pathElements[i] + SEPERATOR);

	// Remove last '/'
	result.deleteCharAt(result.length() - 1);

	// Return created path
	return result.toString();
	}

	/**
	* Check if the path to an VAB elements leads to the invocation of an operation. In this case, the
	* element path conforms to /aas/submodels/{subModelId}/submodelElements/{operationId}/invoke
	*/
	public static boolean isOperationInvokationPath(String path) {
	// null-Paths are no operation paths
	if (path == null) {
	return false;
	}

	// Split path
	String[] pathElements = splitPath(path);

	if(pathElements.length == 0) {
	return false;
	}

	// Check if last path element is "invoke" or "operations" is contained anywhere
	return pathElements[pathElements.length - 1].startsWith(Operation.INVOKE) \|\| isOperationPath(path);
	}

	private static boolean isOperationPath(String path) {
	String lowerCasePath = path.toLowerCase();
	return lowerCasePath.startsWith("operations/") \|\| path.toLowerCase().contains("/operations/");
	}

	/**
	* Check, if the path does not contain any elements.
	*/
	public static boolean isEmptyPath(String path) {
	return path.equals("") \|\| path.equals("/");
	}

	/**
	* Gets the first endpoint of a path.
	* @path
	* A path that can contain 0..* endpoints.
	* @return
	* The first address entry of a path. The address entry is the first endpoint combined with a protocol.
	* If there is no protocol defined, the address entry is empty ("").
	* E.g. basyx://127.0.0.1:6998//https://localhost/test/ will return basyx://127.0.0.1:6998,
	* https://localhost/test//basyx://127.0.0.1:6998/ will return https://localhost/test
	* and http://localhost/test/ will return "".
	*/
	public static String getFirstEndpoint(String fullPath) {
	// Return null result for null argument
	if (fullPath == null) {
	return null;
	}

	if (isEmptyPath(fullPath) \|\| !fullPath.contains("//")) {
	return "";
	} else {
	String[] splitted = fullPath.split("//");
	return splitted[0] + "//" + splitted[1];
	}
	}

	/**
	* Removes the first endpoint from a path. See {@link #getAddressEntry}<br/>
	* @path
	* @return
	* The first endpoint. E.g. basyx://127.0.0.1:6998//https://localhost/test/ will return
	* https://localhost/test/.
	*
	*/
	public static String removeFirstEndpoint(String fullPath) {
	// Return null result for null argument
	if (fullPath == null) {
	return null;
	}

	if (isEmptyPath(fullPath)) {
	return "";
	} else if (!fullPath.contains("//")) {
	return fullPath;
	} else {
	String firstEndpoint = fullPath.replaceFirst(getFirstEndpoint(fullPath), "");
	if (firstEndpoint.startsWith("//")) {
	firstEndpoint = firstEndpoint.replaceFirst("//", "");
	}
	return firstEndpoint;
	}
	}

	/**
	* Concatenate two paths
	*/
	public static String concatenatePaths(String... paths) {
	// Return null result for null argument
	if (paths == null \|\| paths.length == 0) {
	return null;
	}

	// Store result
	StringBuffer result = new StringBuffer();

	// Flag that indicates whether processed path segment is first segment
	boolean isFirst = true;

	// Process all path segments
	for (String pathSegment : paths) {
	// Return empty result, if any element is null
	if (pathSegment == null) {
	return null;
	}

	// Remove leading and trailing "/" from pathsegment
	while (pathSegment.endsWith("/"))
	pathSegment = pathSegment.substring(0, pathSegment.length() - 1);
	while (pathSegment.startsWith("/"))
	pathSegment = pathSegment.substring(1);

	// Add path to result; if its first segment, do not split with "'"
	if (!isFirst)
	result.append("/");
	else
	isFirst = false;
	result.append(pathSegment);
	}

	// Return combined path
	return result.toString();
	}

	/**
	* Checks if path is null, if yes throw exception
	*
	* @param path
	*/
	public static void checkPathForNull(String path) throws MalformedRequestException {
	if (path == null) {
	throw new MalformedRequestException("Path is not allowed to be null");
	}
	}

	/**
	* Strips the last path element if it is "invoke"
	*
	* @param path
	* @return path without last element "invoke" or unchanged path
	*/
	public static String stripInvokeFromPath(String path) {

	if(path == null)
	return null;

	if(getLastElement(path).startsWith(Operation.INVOKE)) {
	return getParentPath(path);
	}

	return path;
	}

	/**
	* Gets the path from a URL
	* e.g "http://localhost:8080/path/to/test.file" results in "/path/to/test.file"
	*
	* @param url
	* @return the path from the URL
	*/
	public static String getPathFromURL(String url) {
	if(url == null) {
	return null;
	}

	if(url.contains("://")) {

	// Find the ":" and and remove the "http://" from the url
	int index = url.indexOf(":") + 3;
	url = url.substring(index);

	// Find the first "/" from the URL (now without the "http://") and remove everything before that
	index = url.indexOf("/");
	url = url.substring(index);

	// Recursive call to deal with more than one server parts
	// (e.g. basyx://127.0.0.1:6998//https://localhost/test/)
	return getPathFromURL(url);
	} else {
	// Make sure the path has a / at the start
	if(!url.startsWith("/")) {
	url = "/" + url;
	}
	return url;
	}
	}

	/**
	* Harmonizes a path so that it will always and with the suffix and no ending
	* slash (even if the suffix contains one).
	*
	* @param path
	* to harmonize
	* @param suffix
	* to check for existance and append if necessary
	* @return harmonized path
	*/
	public static String harmonizePathWithSuffix(String path, String suffix) {
	String strippedPath = stripSlashes(path);
	String strippedSuffix = stripSlashes(suffix);

	if (strippedPath.endsWith("/" + strippedSuffix)) {
	return strippedPath;
	} else {
	return VABPathTools.concatenatePaths(strippedPath, strippedSuffix);
	}
	}
	}