Create a new GeometryExpression

@param value Geometry
@return new GeometryExpression
495396
public static <T extends Geometry> GeometryExpression<T> asGeometry(T value) {
        return asGeometry(Expressions.constant(value));
    }
987422
public Expression<Long> gte(long value) {
		String valueString = "'" + value + "'";
		return new Expression<Long>(this, Operation.gte, valueString);
	}
3151
public StringExpression geometryType() {
        if (geometryType == null) {
            geometryType = Expressions.stringOperation(SpatialOps.GEOMETRY_TYPE, mixin);
        }
        return geometryType;
    }
731463
public Geometry parse(byte[] value) {
        ByteGetter.BinaryByteGetter bytes = new ByteGetter.BinaryByteGetter(value);
        return this.parseGeometry(valueGetterForEndian(bytes));
    }
1249104
@XmlElementDecl(namespace = "", name = "msgLayer")
    public JAXBElement<String> createMsgLayer(String value) {
        return new JAXBElement<String>(_MsgLayer_QNAME, String.class, null, value);
    }
503147
public Geometry createGeometry(Geometry geometry) {
		if (geometry instanceof Point) {
			return createPoint(geometry.getCoordinate());
		} else if (geometry instanceof LinearRing) {
			return createLinearRing(geometry.getCoordinates());
		} else if (geometry instanceof LineString) {
			return createLineString(geometry.getCoordinates());
		} else if (geometry instanceof Polygon) {
			Polygon polygon = (Polygon) geometry;
			LinearRing exteriorRing = createLinearRing(polygon.getExteriorRing().getCoordinates());
			LinearRing[] interiorRings = new LinearRing[polygon.getNumInteriorRing()];
			for (int n = 0; n < polygon.getNumInteriorRing(); n++) {
				interiorRings[n] = createLinearRing(polygon.getInteriorRingN(n).getCoordinates());
			}
			return new Polygon(srid, precision, exteriorRing, interiorRings);
		} else if (geometry instanceof MultiPoint) {
			Point[] clones = new Point[geometry.getNumGeometries()];
			for (int n = 0; n < geometry.getNumGeometries(); n++) {
				clones[n] = createPoint(geometry.getGeometryN(n).getCoordinate());
			}
			return new MultiPoint(srid, precision, clones);
		} else if (geometry instanceof MultiLineString) {
			LineString[] clones = new LineString[geometry.getNumGeometries()];
			for (int n = 0; n < geometry.getNumGeometries(); n++) {
				clones[n] = createLineString(geometry.getGeometryN(n).getCoordinates());
			}
			return new MultiLineString(srid, precision, clones);
		} else if (geometry instanceof MultiPolygon) {
			Polygon[] clones = new Polygon[geometry.getNumGeometries()];
			for (int n = 0; n < geometry.getNumGeometries(); n++) {
				clones[n] = (Polygon) createGeometry(geometry.getGeometryN(n));
			}
			return new MultiPolygon(srid, precision, clones);
		}
		return null;
	}
1222024
@XmlElementDecl(namespace = "http://www.opengis.net/gml", name = "_ImplicitGeometry", substitutionHeadNamespace = "http://www.opengis.net/gml", substitutionHeadName = "_Geometry")
    public JAXBElement<AbstractGeometryType> create_ImplicitGeometry(AbstractGeometryType value) {
        return new JAXBElement<AbstractGeometryType>(__ImplicitGeometry_QNAME, AbstractGeometryType.class, null, value);
    }
1054758
@Override
    public ElementOperator<PlainTime> newValue(V value) {

        return new TimeOperator(this, ElementOperator.OP_NEW_VALUE, value);

    }
1327345
public static <T extends Geometry> GeometryExpression<T> asGeometry(Expression<T> expr) {
        Expression<T> underlyingMixin = ExpressionUtils.extract(expr);
        if (underlyingMixin instanceof PathImpl) {
            return new GeometryPath<T>((PathImpl<T>) underlyingMixin);
        } else if (underlyingMixin instanceof OperationImpl) {
            return new GeometryOperation<T>((OperationImpl<T>) underlyingMixin);
        } else {
            return new GeometryExpression<T>(underlyingMixin) {

                private static final long serialVersionUID = -6714044005570420009L;

                @Override
                public <R, C> R accept(Visitor<R, C> v, C context) {
                    return this.mixin.accept(v, context);
                }

            };
        }
    }
1142891
public Expression<String> gt(String value) {
		String valueString = "'" + value + "'";
		return new Expression<String>(this, Operation.gt, valueString);
	}
926282
public Expression<Double> gt(double value) {
		String valueString = "'" + value + "'";
		return new Expression<Double>(this, Operation.gt, valueString);
	}
785595
public static ConstantValueExpression makeExpression(VoltType dataType, String value) {
        ConstantValueExpression constantExpr = new ConstantValueExpression();
        constantExpr.setValueType(dataType);
        constantExpr.setValue(value);
        return constantExpr;
    }
422885
public FieldScopeLogicMap<V> with(FieldScopeLogic fieldScopeLogic, V value) {
    ImmutableList.Builder<Entry<V>> newEntries = ImmutableList.builder();
    // Earlier entries override later ones, so we insert the new one at the front of the list.
    newEntries.add(Entry.of(fieldScopeLogic, value));
    newEntries.addAll(entries);
    return new FieldScopeLogicMap<>(newEntries.build());
  }
795239
public static <T extends Geometry> JTSGeometryExpression<T> geometryOperation(Class<? extends T> type,
                                                                                  Operator op, Expression<?>... args) {
        return new JTSGeometryOperation<T>(type, op, args);
    }
367007
@ExportConstructor
	public static org.geomajas.geometry.Bbox constructor(double x, double y, double width, double height) {
		return new org.geomajas.geometry.Bbox(x, y, width, height);
	}
456274
int createGeometry(Geometry.Type geometry_type,
			VertexDescription description) {
		int newgeom = newGeometry_(geometry_type.value());
		if (m_vertices == null) {
			m_vertices_mp = new MultiPoint(description);
			m_vertices = (MultiPointImpl) m_vertices_mp._getImpl();
		} else
			m_vertices_mp.mergeVertexDescription(description);

		m_vertex_description = m_vertices_mp.getDescription();// this
																// description
																// will be a
																// merge of
																// existing
																// description
																// and the
																// description
																// of the
																// multi_path
		m_b_has_attributes = m_vertex_description.getAttributeCount() > 1;

		if (m_first_geometry == -1) {
			m_first_geometry = newgeom;
			m_last_geometry = newgeom;
		} else {
			setPrevGeometry_(newgeom, m_last_geometry);
			setNextGeometry_(m_last_geometry, newgeom);
			m_last_geometry = newgeom;
		}
		return newgeom;
	}
1072583
public Cell createCell(double value) {

        Cell cell = this.getNextCell(CellType.NUMERIC);
        cell.setCellValue(value);
        cell.setCellStyle(this.style.getNumberCs());
        return cell;
    }