Returns the value geometry type parameter.

@return the geometry type or <code>null</code> if not present.
342439
public String getGeometryType() {
      String geometryType = null;
      if (getParameters().length > 0 && getParameters()[0] != null) {
         geometryType = getParameters()[0].toString();
      }
      return geometryType;
   }
917547
public String getOid()
    {
        String ret = null;
        if (isValid()) {
            ret = getType().getId() + "." + getId();
        }
        return ret;
    }
504213
public Type[] getParameterTypes() {
        Type[] types = new Type[parameterNames.size()];
        for (int i = 0; i < types.length; i++) {
            types[i] = String.class;
        }

        return types;
    }
1027759
public OGCPoint getPoint(DeferredObject[] args) {
		OGCGeometry geometry = getGeometry(args);
		
		if (geometry instanceof OGCPoint) {
			return (OGCPoint)geometry;
		} else {
			return null;
		}
	}
3151
public StringExpression geometryType() {
        if (geometryType == null) {
            geometryType = Expressions.stringOperation(SpatialOps.GEOMETRY_TYPE, mixin);
        }
        return geometryType;
    }
1026257
public static Geometry getGeometryN(Geometry geometry, Integer n) throws SQLException {
        if (geometry == null) {
            return null;
        }
        if (n >= 1 && n <= geometry.getNumGeometries()) {
            return geometry.getGeometryN(n - 1);
        } else {
            throw new SQLException(OUT_OF_BOUNDS_ERR_MESSAGE);
        }
    }
1313646
public Bbox getBounds(Geometry geometry) {
		org.geomajas.gwt.client.spatial.geometry.Geometry geom = GeometryConverter.toGwt(geometry);
		return GeometryConverter.toDto(geom.getBounds());
	}
835653
@Nonnull
    public final Style getDefaultStyle(@Nonnull final String geometryType) {
        String normalizedGeomName = GEOMETRY_NAME_ALIASES.get(geometryType.toLowerCase());
        if (normalizedGeomName == null) {
            normalizedGeomName = geometryType.toLowerCase();
        }
        Style style = this.defaultStyle.get(normalizedGeomName.toLowerCase());
        if (style == null) {
            style = this.namedStyles.get(normalizedGeomName.toLowerCase());
        }

        if (style == null) {
            StyleBuilder builder = new StyleBuilder();
            final Symbolizer symbolizer;
            if (isPointType(normalizedGeomName)) {
                symbolizer = builder.createPointSymbolizer();
            } else if (isLineType(normalizedGeomName)) {
                symbolizer = builder.createLineSymbolizer(Color.black, 2);
            } else if (isPolygonType(normalizedGeomName)) {
                symbolizer = builder.createPolygonSymbolizer(Color.lightGray, Color.black, 2);
            } else if (normalizedGeomName.equalsIgnoreCase(Constants.Style.Raster.NAME)) {
                symbolizer = builder.createRasterSymbolizer();
            } else if (normalizedGeomName.startsWith(Constants.Style.OverviewMap.NAME)) {
                symbolizer = createMapOverviewStyle(normalizedGeomName, builder);
            } else {
                final Style geomStyle = this.defaultStyle.get(Geometry.class.getSimpleName().toLowerCase());
                if (geomStyle != null) {
                    return geomStyle;
                } else {
                    symbolizer = builder.createPointSymbolizer();
                }
            }
            style = builder.createStyle(symbolizer);
        }
        return style;
    }
208468
public LineString getLineString(Geometry geometry) {
		if (geometry instanceof MultiLineString) {
			if (geometryIndex >= 0 && geometryIndex < geometry.getNumGeometries()) {
				return getLinearRing(geometry.getGeometryN(geometryIndex));
			}
		} else if (geometry instanceof LineString) {
			return (LineString) geometry;
		}
		return getLinearRing(geometry);
	}
1351139
public Geometry execute(Geometry geometry) {
		if (geometry == null) {
			return null;
		}
		if (geometry instanceof LinearRing) {
			if (coordIndex <= 0) {
				coordIndex = 0;
			} else if (coordIndex > geometry.getNumPoints() - 1) {
				coordIndex = geometry.getNumPoints() - 1;
			}
			Coordinate[] coordinates = new Coordinate[geometry.getNumPoints() + 1];
			int count = 0;
			for (int i = 0; i < coordinates.length; i++) {
				if (i == coordIndex) {
					coordinates[i] = coordinate;
				} else if (i == coordinates.length - 1) {
					coordinates[i] = coordinates[0];
				} else {
					coordinates[i] = geometry.getCoordinates()[count++];
				}
			}
			return geometry.getGeometryFactory().createLinearRing(coordinates);
		} else if (geometry instanceof LineString) {
			if (coordIndex <= 0) {
				coordIndex = 0;
			} else if (coordIndex > geometry.getNumPoints()) {
				coordIndex = geometry.getNumPoints();
			}
			Coordinate[] coordinates = new Coordinate[geometry.getNumPoints() + 1];
			int count = 0;
			for (int i = 0; i < coordinates.length; i++) {
				if (i == coordIndex) {
					coordinates[i] = coordinate;
				} else {
					coordinates[i] = geometry.getCoordinates()[count++];
				}
			}
			return geometry.getGeometryFactory().createLineString(coordinates);
		}
		return null;
	}
940352
public GeometryFactory getGeometryFactory() {
		if (null == geometryFactory) {
			if (0 == srid) {
				throw new IllegalArgumentException("srid needs to be set on MapModel to obtain GeometryFactory");
			}
			geometryFactory = new GeometryFactory(srid, -1); // @todo precision is not yet implemented
		}
		return geometryFactory;
	}
77928
public Class<?> getNestedParameterType() {
        if (this.nestingLevel > 1) {
            Type type = getGenericParameterType();
            for (int i = 2; i <= this.nestingLevel; i++) {
                if (type instanceof ParameterizedType) {
                    Type[] args = ((ParameterizedType) type).getActualTypeArguments();
                    Integer index = getTypeIndexForLevel(i);
                    type = args[index != null ? index : args.length - 1];
                }
            }
            if (type instanceof Class) {
                return (Class<?>) type;
            } else if (type instanceof ParameterizedType) {
                Type arg = ((ParameterizedType) type).getRawType();
                if (arg instanceof Class) {
                    return (Class<?>) arg;
                }
            }
            return Object.class;
        } else {
            return getParameterType();
        }
    }
138950
public T getAsObject() {
        try {
            T modelClassObj = modelClazz.newInstance();

            Set<String> columnNameSet = mFieldMap.keySet();

            for (String columnName : columnNameSet) {

                D6ModelClassFieldInfo fieldInfo = mFieldMap.get(columnName);

                final Field field = fieldInfo.field;

                final Object value = fieldInfo.value;

                if (value != null) {

                    // try to set 'null' if available
                    try {
                        field.set(modelClassObj, null);
                    } catch (Exception e) {
                    }

                    try {

                        field.set(modelClassObj, value);
                    } catch (IllegalAccessException e) {
                        // handling this exception for field.set(o, value);
                        loge("#getAsObject", e);
                    } catch (IllegalArgumentException e) {

                        // e.printStackTrace();
                        final String name = field.getName();
                        final Class<?> type = field.getType();

                        String msg = "The value of '" + columnName + "'=" + value + "(" + value.getClass() + ") couldn't set to variable '" + name + "'(" + type + ")";

                        loge("#getAsObject " + msg);

                    }
                } else {
                    // value is null

                    // check is this column CompositType like MySQL's Geometry
                    final List<Object> compositObjValues = fieldInfo.valuesForSpecialType;

                    if (field.getType() == org.riversun.d6.model.Geometry.class) {

                        if (compositObjValues != null && compositObjValues.size() > 1) {
                            final org.riversun.d6.model.Geometry newGeometryObj = new org.riversun.d6.model.Geometry();
                            newGeometryObj.x = (Double) compositObjValues.get(0);
                            newGeometryObj.y = (Double) compositObjValues.get(1);
                            field.set(modelClassObj, newGeometryObj);
                        }

                    }

                }

            }
            return modelClassObj;

        } catch (IllegalAccessException e) {
            throw new D6RuntimeException(e);
        } catch (InstantiationException e) {
            throw new D6RuntimeException("Cannot instanciate model object from '" + modelClazz.getName() + "' If you declare '" + modelClazz.getName() + "' as inner class, please make it static.");
        }

    }
314200
public static Integer getCoordinateDimension(byte[] geom) throws IOException {
        if (geom == null) {
            return null;
        }
        return GeometryMetaData.getMetaDataFromWKB(geom).dimension;
    }
1332310
public Geometry getGeometryN(int n) {
		if (isEmpty()) {
			return null;
		}
		if (n >= 0 && n < points.length) {
			return points[n];
		}
		throw new ArrayIndexOutOfBoundsException(n);
		// return this;
	}
34995
function(geometry) {
            if (geometry == null) {
                return null;
            }
            if (this.internalProjection && this.externalProjection) {
                geometry = geometry.clone();
                geometry.transform(this.internalProjection, 
                                   this.externalProjection);
            }                       
            var geometryType = geometry.CLASS_NAME.split('.')[2];
            var data = this.extract[geometryType.toLowerCase()].apply(this, [geometry]);
            var json;
            if(geometryType == "Collection") {
                json = {
                    "type": "GeometryCollection",
                    "geometries": data
                };
            } else {
                json = {
                    "type": geometryType,
                    "coordinates": data
                };
            }
            
            return json;
        }
1325666
public OGCGeometry getGeometry(DeferredObject[] args) {
		if (isConstant) {
			if (constantGeometry == null) {
				constantGeometry = getGeometry(args[argIndex]);
			} 
			
			return constantGeometry;
		} else {
			// not constant, so we have to rebuild the geometry
			// on every call
			return getGeometry(args[argIndex]);
		}
	}