/*
* This is part of Geomajas, a GIS framework, http://www.geomajas.org/.
*
* Copyright 2008-2015 Geosparc nv, http://www.geosparc.com/, Belgium.
*
* The program is available in open source according to the GNU Affero
* General Public License. All contributions in this program are covered
* by the Geomajas Contributors License Agreement. For full licensing
* details, see LICENSE.txt in the project root.
*/
package org.geomajas.plugin.editing.jsapi.client.service;
import org.geomajas.annotation.Api;
import org.geomajas.geometry.Coordinate;
import org.geomajas.geometry.Geometry;
import org.geomajas.plugin.editing.client.service.GeometryIndex;
import org.geomajas.plugin.editing.client.service.GeometryIndexNotFoundException;
import org.geomajas.plugin.editing.client.service.GeometryIndexService;
import org.geomajas.plugin.editing.client.service.GeometryIndexType;
import org.timepedia.exporter.client.Export;
import org.timepedia.exporter.client.ExportInstanceMethod;
import org.timepedia.exporter.client.ExportOverlay;
import org.timepedia.exporter.client.ExportPackage;
/**
* Service for managing sub-parts of geometries through special geometry indices.
* <p>
* TODO All methods that return an array or a list have been excluded. We still need to get these to work...
* </p>
*
* @author Pieter De Graef
* @since 1.0.0
*/
@Export("GeometryIndexService")
@ExportPackage("org.geomajas.plugin.editing.service")
@Api(allMethods = true)
public class JsGeometryIndexService implements ExportOverlay<GeometryIndexService> {
/**
* Create a new geometry index instance.
*
* @param instance
* The index service instance to help you create the index.
* @param type
* The type for the deepest index value.
* @param values
* A list of values for the children to create.
* @return The new index.
*/
@ExportInstanceMethod
public static GeometryIndex create(GeometryIndexService instance, String type, int[] values) {
if ("geometry".equalsIgnoreCase(type)) {
return instance.create(GeometryIndexType.TYPE_GEOMETRY, values);
} else if ("vertex".equalsIgnoreCase(type)) {
return instance.create(GeometryIndexType.TYPE_VERTEX, values);
} else if ("edge".equalsIgnoreCase(type)) {
return instance.create(GeometryIndexType.TYPE_EDGE, values);
}
return null;
}
/**
* Create a new geometry index instance, by adding more depth to a given parent index.
*
* @param instance
* The index service instance to help you create the index.
* @param index
* The parent index to start from.
* @param type
* The type for the deepest index value.
* @param values
* A list of values for the children to attach to the parent index.
* @return The next index.
*/
@ExportInstanceMethod
public static GeometryIndex addChildren(GeometryIndexService instance, GeometryIndex index, String type,
int[] values) {
if ("geometry".equalsIgnoreCase(type)) {
return instance.addChildren(index, GeometryIndexType.TYPE_GEOMETRY, values);
} else if ("vertex".equalsIgnoreCase(type)) {
return instance.addChildren(index, GeometryIndexType.TYPE_VERTEX, values);
} else if ("edge".equalsIgnoreCase(type)) {
return instance.addChildren(index, GeometryIndexType.TYPE_EDGE, values);
}
return null;
}
// ------------------------------------------------------------------------
// Methods concerning index parsing/formatting:
// ------------------------------------------------------------------------
/**
* Format a given geometry index, creating something like "geometry2.vertex1".
*
* @param index
* The geometry index to format.
* @return Returns the string value resulting from the index.
*/
public String format(GeometryIndex index) {
return null;
}
/**
* Given a certain string identifier, parse it as a geometry index.
*
* @param identifier
* The identifier to try and parse.
* @return Returns the associating geometry index (if no exception was thrown).
* @throws GeometryIndexNotFoundException
* In case the identifier could not be parsed.
*/
public GeometryIndex parse(String identifier) throws GeometryIndexNotFoundException {
return null;
}
// ------------------------------------------------------------------------
// Methods for geometry retrieval:
// ------------------------------------------------------------------------
/**
* Given a certain geometry, get the sub-geometry the index points to. This only works if the index actually points
* to a sub-geometry.
*
* @param geometry
* The geometry to search in.
* @param index
* The index that points to a sub-geometry within the given geometry.
* @return Returns the sub-geometry if it exists.
* @throws GeometryIndexNotFoundException
* Thrown in case the index is of the wrong type, or if the sub-geometry could not be found within the
* given geometry.
*/
public Geometry getGeometry(Geometry geometry, GeometryIndex index) throws GeometryIndexNotFoundException {
return null;
}
/**
* Given a certain geometry, get the vertex the index points to. This only works if the index actually points to a
* vertex.
*
* @param geometry
* The geometry to search in.
* @param index
* The index that points to a vertex within the given geometry.
* @return Returns the vertex if it exists.
* @throws GeometryIndexNotFoundException
* Thrown in case the index is of the wrong type, or if the vertex could not be found within the given
* geometry.
*/
public Coordinate getVertex(Geometry geometry, GeometryIndex index) throws GeometryIndexNotFoundException {
return null;
}
/**
* Given a certain geometry, get the edge the index points to. This only works if the index actually points to an
* edge.
*
* @param geometry The geometry to search in.
* @param index The index that points to an edge within the given geometry.
* @return Returns the edge if it exists.
* @throws GeometryIndexNotFoundException Thrown in case the index is of the wrong type, or if the edge could not be
* found within the given geometry.
*/
public Coordinate[] getEdge(Geometry geometry, GeometryIndex index) throws GeometryIndexNotFoundException {
return null;
}
// ------------------------------------------------------------------------
// Helper methods:
// ------------------------------------------------------------------------
/**
* Does the given index point to a vertex or not? We look at the deepest level to check this.
*
* @param index
* The index to check.
* @return true or false.
*/
public boolean isVertex(GeometryIndex index) {
return false;
}
/**
* Does the given index point to an edge or not? We look at the deepest level to check this.
*
* @param index
* The index to check.
* @return true or false.
*/
public boolean isEdge(GeometryIndex index) {
return false;
}
/**
* Does the given index point to a sub-geometry or not? We look at the deepest level to check this.
*
* @param index
* The index to check.
* @return true or false.
*/
public boolean isGeometry(GeometryIndex index) {
return false;
}
/**
* Get the type of sub-part the given index points to. We look at the deepest level to check this.
*
* @param index
* The index to check.
* @return true or false.
*/
@ExportInstanceMethod
public static String getType(GeometryIndexService instance, GeometryIndex index) {
switch (instance.getType(index)) {
case TYPE_GEOMETRY:
return "geometry";
case TYPE_VERTEX:
return "vertex";
case TYPE_EDGE:
return "edge";
default:
return "unknown";
}
}
/**
* What is the geometry type of the sub-geometry pointed to by the given index? If the index points to a vertex or
* edge, the geometry type at the parent level is returned.
*
* @param geometry
* The geometry wherein to search.
* @param index
* The index pointing to a vertex/edge/sub-geometry. In the case of a vertex/edge, the parent geometry
* type is returned. If index is null, the type of the given geometry is returned.
* @return The geometry type as defined in the {@link Geometry} class.
* @throws GeometryIndexNotFoundException
* Thrown in case the index points to a non-existing sub-geometry.
*/
public String getGeometryType(Geometry geometry, GeometryIndex index) throws GeometryIndexNotFoundException {
return null;
}
/**
* Checks to see if a given index is the child of another index.
*
* @param parentIndex
* The so-called parent index.
* @param childIndex
* The so-called child index.
* @return Is the second index really a child of the first index?
*/
public boolean isChildOf(GeometryIndex parentIndex, GeometryIndex childIndex) {
return false;
}
/**
* Returns the value of the innermost child index.
*
* @param index
* The index to recursively search.
* @return The value of the deepest child.
*/
public int getValue(GeometryIndex index) {
return 0;
}
// ------------------------------------------------------------------------
// Methods concerning adjacency (finding ones neighbors):
// ------------------------------------------------------------------------
//
// public List<GeometryIndex> getAdjacentVertices(Geometry geometry, GeometryIndex index)
// throws GeometryIndexNotFoundException {
// return null;
// }
//
// public List<GeometryIndex> getAdjacentEdges(Geometry geometry, GeometryIndex index)
// throws GeometryIndexNotFoundException {
// return null;
// }
/**
* Given a certain geometry and index (one), check if the the other index (two) is a neighbor.
*
* @param geometry
* The geometry wherein to search if indices one and two are neighbors.
* @param one
* One of the indices. Must point to either a vertex or and edge.
* @param two
* Another one of the indices. Must point to either a vertex or and edge.
* @return true or false.
*/
public boolean isAdjacent(Geometry geometry, GeometryIndex one, GeometryIndex two) {
return false;
}
/**
* Given a certain index, find the next vertex in line.
*
* @param index
* The index to start out from. Must point to either a vertex or and edge.
* @return Returns the next vertex index. Note that no geometry is given, and so no actual checking is done. It just
* returns the theoretical answer.
*/
public GeometryIndex getNextVertex(GeometryIndex index) {
return null;
}
/**
* Given a certain index, find the previous vertex in line.
*
* @param index
* The index to start out from. Must point to either a vertex or and edge.
* @return Returns the previous vertex index. Note that no geometry is given, and so no actual checking is done. It
* just returns the theoretical answer.
*/
public GeometryIndex getPreviousVertex(GeometryIndex index) {
return null;
}
/**
* Given a certain index, how many indices of the same type can be found within the given geometry. This count
* includes the given index.<br>
* For example, if the index points to a vertex on a LinearRing within a polygon, then this will return the amount
* of vertices on that LinearRing.
*
* @param geometry
* The geometry to look into.
* @param index
* The index to take as example (can be of any type).
* @return Returns the total amount of siblings.
*/
public int getSiblingCount(Geometry geometry, GeometryIndex index) {
return 0;
}
//
// public Coordinate[] getSiblingVertices(Geometry geometry, GeometryIndex index)
// throws GeometryIndexNotFoundException {
// return null;
// }
}