Please wait. This can take some minutes ...
Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
org.geotools.geojson.feature.FeatureJSON Maven / Gradle / Ivy
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//
package org.geotools.geojson.feature;
import org.geotools.data.crs.ForceCoordinateSystemFeatureResults;
import org.geotools.feature.DefaultFeatureCollection;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.FeatureIterator;
import org.geotools.feature.SchemaException;
import org.geotools.feature.simple.SimpleFeatureBuilder;
import org.geotools.geojson.GeoJSONUtil;
import org.geotools.geojson.geom.GeometryJSON;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.referencing.CRS;
import org.json.simple.JSONArray;
import org.json.simple.JSONAware;
import org.json.simple.JSONStreamAware;
import org.json.simple.parser.JSONParser;
import org.locationtech.jts.geom.Envelope;
import org.locationtech.jts.geom.Geometry;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.feature.type.AttributeDescriptor;
import org.opengis.geometry.BoundingBox;
import org.opengis.referencing.FactoryException;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import java.io.*;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
public class FeatureJSON {
GeometryJSON gjson;
SimpleFeatureType featureType;
AttributeIO attio;
boolean encodeFeatureBounds;
boolean encodeFeatureCollectionBounds;
boolean encodeFeatureCRS;
boolean encodeFeatureCollectionCRS;
boolean encodeNullValues;
public FeatureJSON() {
this(new GeometryJSON());
}
public FeatureJSON(GeometryJSON gjson) {
this.encodeFeatureBounds = false;
this.encodeFeatureCollectionBounds = false;
this.encodeFeatureCRS = false;
this.encodeFeatureCollectionCRS = false;
this.encodeNullValues = false;
this.gjson = gjson;
this.attio = new DefaultAttributeIO();
}
public void setFeatureType(SimpleFeatureType featureType) {
this.featureType = featureType;
this.attio = new FeatureTypeAttributeIO(featureType);
}
public void setEncodeFeatureBounds(boolean encodeFeatureBounds) {
this.encodeFeatureBounds = encodeFeatureBounds;
}
public boolean isEncodeFeatureBounds() {
return this.encodeFeatureBounds;
}
public void setEncodeFeatureCollectionBounds(boolean encodeFeatureCollectionBounds) {
this.encodeFeatureCollectionBounds = encodeFeatureCollectionBounds;
}
public boolean isEncodeFeatureCollectionBounds() {
return this.encodeFeatureCollectionBounds;
}
public void setEncodeFeatureCRS(boolean encodeFeatureCRS) {
this.encodeFeatureCRS = encodeFeatureCRS;
}
public boolean isEncodeFeatureCRS() {
return this.encodeFeatureCRS;
}
public void setEncodeFeatureCollectionCRS(boolean encodeFeatureCollectionCRS) {
this.encodeFeatureCollectionCRS = encodeFeatureCollectionCRS;
}
public boolean isEncodeFeatureCollectionCRS() {
return this.encodeFeatureCollectionCRS;
}
public void setEncodeNullValues(boolean encodeNullValues) {
this.encodeNullValues = encodeNullValues;
}
public boolean isEncodeNullValues() {
return this.encodeNullValues;
}
public void writeFeature(SimpleFeature feature, Object output) throws IOException {
GeoJSONUtil.encode((new FeatureJSON.FeatureEncoder(feature)).toJSONString(), output);
}
public void writeFeature(SimpleFeature feature, OutputStream output) throws IOException {
this.writeFeature(feature, (Object)output);
}
public String toString(SimpleFeature feature) throws IOException {
StringWriter w = new StringWriter();
this.writeFeature(feature, (Object)w);
return w.toString();
}
public SimpleFeature readFeature(Object input) throws IOException {
return (SimpleFeature)GeoJSONUtil.parse(new FeatureHandler(this.featureType != null ? new SimpleFeatureBuilder(this.featureType) : null, this.attio), input, false);
}
public SimpleFeature readFeature(InputStream input) throws IOException {
return this.readFeature((Object)input);
}
public void writeFeatureCollection(FeatureCollection features, Object output) throws IOException {
LinkedHashMap obj = new LinkedHashMap();
obj.put("type", "FeatureCollection");
if (features.getSchema().getGeometryDescriptor() != null) {
ReferencedEnvelope bounds = features.getBounds();
CoordinateReferenceSystem crs = bounds != null ? bounds.getCoordinateReferenceSystem() : null;
if (bounds != null && this.encodeFeatureCollectionBounds) {
JSONStreamAware writer = (out) -> {
JSONArray.writeJSONString(Arrays.asList(bounds.getMinX(), bounds.getMinY(), bounds.getMaxX(), bounds.getMaxY()), out);
};
obj.put("bbox", writer);
}
if (crs != null && (this.encodeFeatureCollectionCRS || !this.isStandardCRS(crs))) {
obj.put("crs", this.createCRS(crs));
}
}
obj.put("features", new FeatureJSON.FeatureCollectionEncoder(features, this.gjson));
GeoJSONUtil.encode(obj, output);
}
private boolean isStandardCRS(CoordinateReferenceSystem crs) {
if (crs == null) {
return true;
} else {
try {
CoordinateReferenceSystem standardCRS = CRS.decode("EPSG:4326");
return CRS.equalsIgnoreMetadata(crs, standardCRS);
} catch (Exception var3) {
return false;
}
}
}
public void writeFeatureCollection(FeatureCollection features, OutputStream output) throws IOException {
this.writeFeatureCollection(features, (Object)output);
}
public FeatureCollection readFeatureCollection(Object input) throws IOException {
DefaultFeatureCollection features = new DefaultFeatureCollection((String)null, (SimpleFeatureType)null);
FeatureJSON.FeatureCollectionIterator it = (FeatureJSON.FeatureCollectionIterator)this.streamFeatureCollection(input);
Throwable var4 = null;
DefaultFeatureCollection var5;
try {
while(it.hasNext()) {
features.add(it.next());
}
if (features.getSchema() != null && features.getSchema().getCoordinateReferenceSystem() == null && it.getHandler().getCRS() != null) {
try {
ForceCoordinateSystemFeatureResults var19 = new ForceCoordinateSystemFeatureResults(features, it.getHandler().getCRS());
return var19;
} catch (SchemaException var16) {
throw (IOException)(new IOException()).initCause(var16);
}
}
var5 = features;
} catch (Throwable var17) {
var4 = var17;
throw var17;
} finally {
if (it != null) {
if (var4 != null) {
try {
it.close();
} catch (Throwable var15) {
var4.addSuppressed(var15);
}
} else {
it.close();
}
}
}
return var5;
}
public FeatureCollection readFeatureCollection(InputStream input) throws IOException {
return this.readFeatureCollection((Object)input);
}
public FeatureIterator streamFeatureCollection(Object input) throws IOException {
return new FeatureJSON.FeatureCollectionIterator(input);
}
public String toString(FeatureCollection features) throws IOException {
StringWriter w = new StringWriter();
this.writeFeatureCollection(features, (Object)w);
return w.toString();
}
public void writeCRS(CoordinateReferenceSystem crs, Object output) throws IOException {
GeoJSONUtil.encode(this.createCRS(crs), output);
}
public void writeCRS(CoordinateReferenceSystem crs, OutputStream output) throws IOException {
this.writeCRS(crs, (Object)output);
}
Map createCRS(CoordinateReferenceSystem crs) throws IOException {
Map obj = new LinkedHashMap();
obj.put("type", "name");
Map props = new LinkedHashMap();
if (crs == null) {
props.put("name", "EPSG:4326");
} else {
try {
String identifier = CRS.lookupIdentifier(crs, true);
props.put("name", identifier);
} catch (FactoryException var5) {
throw (IOException)(new IOException("Error looking up crs identifier")).initCause(var5);
}
}
obj.put("properties", props);
return obj;
}
public CoordinateReferenceSystem readCRS(Object input) throws IOException {
return (CoordinateReferenceSystem)GeoJSONUtil.parse(new CRSHandler(), input, false);
}
public CoordinateReferenceSystem readCRS(InputStream input) throws IOException {
return this.readCRS((Object)input);
}
public SimpleFeatureType readFeatureCollectionSchema(Object input, boolean nullValuesEncoded) throws IOException {
return (SimpleFeatureType)GeoJSONUtil.parse(new FeatureTypeHandler(nullValuesEncoded), input, false);
}
public SimpleFeatureType readFeatureCollectionSchema(InputStream input, boolean nullValuesEncoded) throws IOException {
return this.readFeatureCollectionSchema((Object)input, false);
}
public String toString(CoordinateReferenceSystem crs) throws IOException {
StringWriter writer = new StringWriter();
this.writeCRS(crs, (Object)writer);
return writer.toString();
}
class FeatureCollectionIterator implements FeatureIterator {
Reader reader;
FeatureCollectionHandler handler;
JSONParser parser;
SimpleFeature next;
FeatureCollectionIterator(Object input) {
try {
this.reader = GeoJSONUtil.toReader(input);
} catch (IOException var4) {
throw new RuntimeException(var4);
}
this.parser = new JSONParser();
}
FeatureCollectionHandler getHandler() {
return this.handler;
}
public boolean hasNext() {
if (this.next != null) {
return true;
} else {
if (this.handler == null) {
this.handler = new FeatureCollectionHandler(FeatureJSON.this.featureType, FeatureJSON.this.attio);
}
this.next = this.readNext();
return this.next != null;
}
}
public SimpleFeature next() {
SimpleFeature feature = this.next;
this.next = null;
return feature;
}
SimpleFeature readNext() {
try {
this.parser.parse(this.reader, this.handler, true);
return this.handler.getValue();
} catch (Exception var2) {
throw new RuntimeException(var2);
}
}
public void remove() {
throw new UnsupportedOperationException();
}
public void close() {
if (this.reader != null) {
try {
this.reader.close();
} catch (IOException var2) {
}
this.reader = null;
}
this.parser = null;
this.handler = null;
}
}
class FeatureCollectionEncoder implements JSONStreamAware {
FeatureCollection features;
GeometryJSON gjson;
public FeatureCollectionEncoder(FeatureCollection features, GeometryJSON gjson) {
this.features = features;
this.gjson = gjson;
}
public void writeJSONString(Writer out) throws IOException {
FeatureJSON.FeatureEncoder featureEncoder = FeatureJSON.this.new FeatureEncoder((SimpleFeatureType)this.features.getSchema());
out.write("[");
FeatureIterator i = this.features.features();
Throwable var4 = null;
try {
if (i.hasNext()) {
SimpleFeature f = (SimpleFeature)i.next();
out.write(featureEncoder.toJSONString(f));
while(i.hasNext()) {
out.write(",");
f = (SimpleFeature)i.next();
out.write(featureEncoder.toJSONString(f));
}
}
} catch (Throwable var13) {
var4 = var13;
throw var13;
} finally {
if (i != null) {
if (var4 != null) {
try {
i.close();
} catch (Throwable var12) {
var4.addSuppressed(var12);
}
} else {
i.close();
}
}
}
out.write("]");
out.flush();
}
}
class FeatureEncoder implements JSONAware {
SimpleFeatureType featureType;
SimpleFeature feature;
public FeatureEncoder(SimpleFeature feature) {
this((SimpleFeatureType)feature.getType());
this.feature = feature;
}
public FeatureEncoder(SimpleFeatureType featureType) {
this.featureType = featureType;
}
public String toJSONString(SimpleFeature feature) {
StringBuilder sb = new StringBuilder();
sb.append("{");
GeoJSONUtil.entry("type", "Feature", sb);
sb.append(",");
if (FeatureJSON.this.encodeFeatureCRS) {
CoordinateReferenceSystem crs = feature.getFeatureType().getCoordinateReferenceSystem();
if (crs != null) {
try {
GeoJSONUtil.string("crs", sb).append(":");
sb.append(FeatureJSON.this.toString(crs)).append(",");
} catch (IOException var8) {
throw new RuntimeException(var8);
}
}
}
if (FeatureJSON.this.encodeFeatureBounds) {
BoundingBox bbox = feature.getBounds();
GeoJSONUtil.string("bbox", sb).append(":");
sb.append(FeatureJSON.this.gjson.toString(bbox)).append(",");
}
if (feature.getDefaultGeometry() != null) {
GeoJSONUtil.string("geometry", sb).append(":").append(FeatureJSON.this.gjson.toString((Geometry)feature.getDefaultGeometry()));
sb.append(",");
}
int gindex = this.featureType.getGeometryDescriptor() != null ? this.featureType.indexOf(this.featureType.getGeometryDescriptor().getLocalName()) : -1;
GeoJSONUtil.string("properties", sb).append(":").append("{");
boolean attributesWritten = false;
for(int i = 0; i < this.featureType.getAttributeCount(); ++i) {
AttributeDescriptor ad = this.featureType.getDescriptor(i);
if (i != gindex) {
Object value = feature.getAttribute(i);
if (FeatureJSON.this.encodeNullValues || value != null) {
attributesWritten = true;
if (value instanceof Envelope) {
GeoJSONUtil.array(ad.getLocalName(), FeatureJSON.this.gjson.toString((Envelope)value), sb);
} else if (value instanceof BoundingBox) {
GeoJSONUtil.array(ad.getLocalName(), FeatureJSON.this.gjson.toString((BoundingBox)value), sb);
} else if (value instanceof Geometry) {
GeoJSONUtil.string(ad.getLocalName(), sb).append(":").append(FeatureJSON.this.gjson.toString((Geometry)value));
} else {
GeoJSONUtil.entry(ad.getLocalName(), value, sb);
}
sb.append(",");
}
}
}
if (attributesWritten) {
sb.setLength(sb.length() - 1);
}
sb.append("},");
GeoJSONUtil.entry("id", feature.getID(), sb);
sb.append("}");
return sb.toString();
}
public String toJSONString() {
return this.toJSONString(this.feature);
}
}
}