import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Populate field map for the data source.
 */
private void populateFieldMap() {
    if(dataSourceInfo != null)
    {
        geometryFieldName = dataSourceInfo.getGeometryFieldName();

        fieldNameMap.clear();
        fieldTypeMap.clear();

        logger.debug("Datasource fields:");
        int index = 0;
        Collection<PropertyDescriptor> descriptorList = dataSourceInfo.getPropertyDescriptorList();
        if(descriptorList != null)
        {
            for(PropertyDescriptor property : descriptorList)
            {
                logger.debug(String.format("    %-20s %s", property.getName(), property.getType().getBinding().getName()));
                fieldNameMap.put(index, property.getName());
                fieldTypeMap.put(index, property.getType().getBinding());
                index ++;
            }
        }
    }
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the attributes.
 *
 * @param expectedDataType the expected data type
 * @return the attributes
 */
/* (non-Javadoc)
 * @see com.sldeditor.datasource.impl.DataSourceInterface#getAttributes(java.lang.Class)
 */
@Override
public List<String> getAttributes(Class<?> expectedDataType) {
    List<String> attributeNameList = new ArrayList<String>();

    Collection<PropertyDescriptor> descriptorList = getPropertyDescriptorList();

    if(descriptorList != null)
    {
        for(PropertyDescriptor property : descriptorList)
        {
            Class<?> bindingType = property.getType().getBinding();
            if(AllowedAttributeTypes.isAllowed(bindingType, expectedDataType))
            {
                attributeNameList.add(property.getName().toString());
            }
        }
    }
    return attributeNameList;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Populate field map for the data source.
 */
public void populateFieldMap() {
    fieldNameMap.clear();
    fieldTypeMap.clear();

    logger.debug("Datasource fields:");
    int index = 0;
    Collection<PropertyDescriptor> descriptorList = getPropertyDescriptorList();
    if (descriptorList != null) {
        for (PropertyDescriptor property : descriptorList) {
            if (property != null) {
                logger.debug(String.format("    %-20s %s", property.getName(),
                        property.getType().getBinding().getName()));
                fieldNameMap.put(index, property.getName());
                fieldTypeMap.put(index, property.getType().getBinding());
            }
            index++;
        }
    }
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the attributes.
 *
 * @param expectedDataType the expected data type
 * @return the attributes
 */
/*
 * (non-Javadoc)
 * 
 * @see com.sldeditor.datasource.impl.DataSourceInterface#getAttributes(java.lang.Class)
 */
@Override
public List<String> getAttributes(Class<?> expectedDataType) {
    List<String> attributeNameList = new ArrayList<String>();

    Collection<PropertyDescriptor> descriptorList = getPropertyDescriptorList();

    if (descriptorList != null) {
        for (PropertyDescriptor property : descriptorList) {
            Class<?> bindingType = property.getType().getBinding();
            if (AllowedAttributeTypes.isAllowed(bindingType, expectedDataType)) {
                attributeNameList.add(property.getName().toString());
            }
        }
    }
    return attributeNameList;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
@Override
public List<String> getAllAttributes(boolean includeGeometry) {
    List<String> attributeNameList = new ArrayList<String>();

    Collection<PropertyDescriptor> descriptorList = getPropertyDescriptorList();

    if (descriptorList != null) {
        for (PropertyDescriptor property : descriptorList) {
            boolean isGeometry = (property instanceof GeometryDescriptor);
            if ((isGeometry && includeGeometry) || !isGeometry) {
                attributeNameList.add(property.getName().toString());
            }
        }
    }
    return attributeNameList;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
public ComplexTypeImpl(
	Name name, Collection<PropertyDescriptor> properties, boolean identified, 
	boolean isAbstract, List<Filter> restrictions, AttributeType superType, 
	InternationalString description
) {
super(name, Collection.class, identified, isAbstract, restrictions, superType, description);
List<PropertyDescriptor> localProperties;
Map<Name, PropertyDescriptor> localPropertyMap;
if (properties == null) {
    localProperties = Collections.emptyList();
           localPropertyMap = Collections.emptyMap();
} else {
    localProperties = new ArrayList<PropertyDescriptor>(properties);
           localPropertyMap = new HashMap<Name, PropertyDescriptor>();
           for (PropertyDescriptor pd : properties) {
               if( pd == null ){
                   // descriptor entry may be null if a request was made for a property that does not exist
                   throw new NullPointerException("PropertyDescriptor is null - did you request a property that does not exist?");
               }
               localPropertyMap.put(pd.getName(), pd);
           }
           
       }
this.properties = Collections.unmodifiableList(localProperties);
       this.propertyMap = Collections.unmodifiableMap(localPropertyMap);
   }
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
public PropertyDescriptor getDescriptor(String name) {
    PropertyDescriptor result = getDescriptor(new NameImpl(name));
    if (result == null) {
        // look in the same namespace as the complex type
        result = getDescriptor(new NameImpl(getName().getNamespaceURI(), name));
        if (result == null) {
            // full scan
            for (PropertyDescriptor pd : properties) {
                if (pd.getName().getLocalPart().equals(name)) {
                    return pd;
                }
            }
        }
    }
    return result;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
private static String[] createSchema(Collection<PropertyDescriptor> attributeTypes) {
    String[] out = new String[attributeTypes.size()];
    int i = 0;
    for (PropertyDescriptor at : attributeTypes) {
        out[i++] = at.getName().toString();
    }
    return out;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
private static String[] createTypes(Collection<PropertyDescriptor> attributeTypes) {
    String[] out = new String[attributeTypes.size()];
    int i = 0;
    for (PropertyDescriptor at : attributeTypes) {
        out[i++] = at.getType().getName().toString();
    }
    return out;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 *
 * @param collectionsLayer
 * @param shpInput
 * @param transform
 * @param bbox
 * @return
 * @throws Exception
 */
public static GeometryImage mergeShapeFile2(SimpleFeatureCollection collectionsLayer, File shpInput,GeoTransform transform,Polygon bbox)throws Exception {
	Map<String, Serializable> params = new HashMap<String, Serializable>();
    params.put("url", shpInput.toURI().toURL());

    //create a DataStore object to connect to the physical source
    DataStore dataStore = DataStoreFinder.getDataStore(params);
    //retrieve a FeatureSource to work with the feature data
    SimpleFeatureSource shape2 = (SimpleFeatureSource) dataStore.getFeatureSource(dataStore.getTypeNames()[0]);

    ClipProcess clip=new ClipProcess();
    SimpleFeatureCollection collectionsShape2=shape2.getFeatures();
    SimpleFeatureCollection fc=clip.execute(collectionsShape2, bbox,true);
    SimpleFeatureSource source = new CollectionFeatureSource(fc);

    SimpleFeatureCollection result=joinFeaures(source, shape2);

    //create new datastore to save the new shapefile
    FileDataStoreFactorySpi factory = new ShapefileDataStoreFactory();
    File tmp=new File(SumoPlatform.getApplication().getCachePath()+"\\tmpshape_"+System.currentTimeMillis()+".shp");
    Map<String, Serializable> params2 = new HashMap<String, Serializable>();
    params2.put("url", tmp.toURI().toURL());
    ShapefileDataStore newds=(ShapefileDataStore)factory.createNewDataStore(params2);

    String geoName = collectionsLayer.getSchema().getGeometryDescriptor().getType().getName().toString();
    //String nameOutput="merge_"+shpInput.getName()+"_"+LayerManager.getIstanceManager().getCurrentImageLayer().getName();

  //from here create the new GeometricLayer
    Collection<PropertyDescriptor>descriptorsMerge=new ArrayList<>();
    descriptorsMerge.addAll(shape2.getSchema().getDescriptors());
    descriptorsMerge.addAll(collectionsLayer.getSchema().getDescriptors());

    String[] schema = createSchema(descriptorsMerge);
    String[] types = createTypes(descriptorsMerge);

    GeometryImage out=GeometryImage.createLayerFromFeatures(geoName, newds, result, schema, types,true,transform);

    return out;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
private static String[] createTypes(Collection<PropertyDescriptor> attributeTypes) {
    String[] out = new String[attributeTypes.size()];
    int i = 0;
    for (PropertyDescriptor at : attributeTypes) {
        out[i++] = at.getType().getBinding().getName();
    }
    return out;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the property descriptor list.
 *
 * @return the property descriptor list
 */
public Collection<PropertyDescriptor> getPropertyDescriptorList() {
    if(schema != null)
    {
        return schema.getDescriptors();
    }
    return null;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the property descriptor list.
 *
 * @return the property descriptor list
 */
@Override
public Collection<PropertyDescriptor> getPropertyDescriptorList() {
    if(dataSourceInfo != null)
    {
        return dataSourceInfo.getPropertyDescriptorList();
    }
    return null;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the property descriptor list.
 *
 * @return the property descriptor list
 */
public Collection<PropertyDescriptor> getPropertyDescriptorList() {
    if (schema != null) {
        return schema.getDescriptors();
    } else {
        if (geometryType == GeometryTypeEnum.RASTER) {
            if (rasterPropertyDescriptorList == null) {
                rasterPropertyDescriptorList = new ArrayList<PropertyDescriptor>();

                CoordinateReferenceSystem crs = null;
                boolean isIdentifiable = false;
                boolean isAbstract = false;
                List<Filter> restrictions = null;
                AttributeType superType = null;
                InternationalString description = null;
                GeometryType type = featureTypeFactory.createGeometryType(
                        new NameImpl(rasterGeometryField), GridCoverage2D.class, crs,
                        isIdentifiable, isAbstract, restrictions, superType, description);
                GeometryDescriptor descriptor = featureTypeFactory.createGeometryDescriptor(
                        type, new NameImpl(rasterGeometryField), 0, 1, false, null);

                rasterPropertyDescriptorList.add(descriptor);
            }

            return rasterPropertyDescriptorList;
        }
    }
    return null;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Gets the property descriptor list.
 *
 * @return the property descriptor list
 */
@Override
public Collection<PropertyDescriptor> getPropertyDescriptorList() {
    if (dataSourceInfo != null) {
        return dataSourceInfo.getPropertyDescriptorList();
    }
    return null;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Test method for {@link com.sldeditor.datasource.impl.DataSourceImpl#connect()}.
 */
@Test
public void testConnectToInlineDataSource() {
    DataSourceImpl ds = new DataSourceImpl();

    DummyInlineSLDFile editorFile = new DummyInlineSLDFile();
    DummyDataSourceUpdate dataSourceUpdateListener = new DummyDataSourceUpdate();
    ds.addListener(dataSourceUpdateListener);

    CreateDataSourceInterface internalDataSource = new DummyCreateDataSource();
    CreateDataSourceInterface externalDataSource = new DummyCreateDataSource();
    CreateDataSourceInterface inlineDataSource = new CreateInlineDataSource();

    ds.setDataSourceCreation(internalDataSource, externalDataSource, inlineDataSource);
    ds.connect("typeName", editorFile, null);
    assertTrue(dataSourceUpdateListener.hasBeenCalled());

    assertEquals(GeometryTypeEnum.UNKNOWN, dataSourceUpdateListener.geometryType);
    assertFalse(dataSourceUpdateListener.isConnectedToDataSourceFlag);

    Collection<PropertyDescriptor> fieldList = ds.getPropertyDescriptorList();
    assertNull(fieldList);

    FeatureSource<SimpleFeatureType, SimpleFeature> exampleLayer = ds.getExampleFeatureSource();
    assertNull(exampleLayer);

    Map<UserLayer, FeatureSource<SimpleFeatureType, SimpleFeature>> userLayerMap = ds
            .getUserLayerFeatureSource();
    assertEquals(1, userLayerMap.size());

    assertFalse(dataSourceUpdateListener.hasBeenCalled());

    ds.updateUserLayers();
    assertTrue(dataSourceUpdateListener.hasBeenCalled());

    DataSourcePropertiesInterface dsi = ds.getDataConnectorProperties();
    assertNotNull(dsi);
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Test method for
 * {@link com.sldeditor.datasource.impl.DataSourceInfo#getPropertyDescriptorList()}.
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testGetPropertyDescriptorList() {
    URL url = SLDEditorFile.class.getClassLoader()
            .getResource("point/sld/shp/sld_cookbook_point.shp");

    Map map = new HashMap();
    map.put("url", url);
    DataStore dataStore;
    try {
        dataStore = DataStoreFinder.getDataStore(map);

        DataSourceInfo dsInfo = new DataSourceInfo();

        String typeName = dataStore.getTypeNames()[0];
        dsInfo.setTypeName(typeName);
        SimpleFeatureSource source = dataStore.getFeatureSource(typeName);
        SimpleFeatureType schema = source.getSchema();

        assertNull(dsInfo.getPropertyDescriptorList());
        dsInfo.setSchema(schema);

        Collection<PropertyDescriptor> fieldList = dsInfo.getPropertyDescriptorList();

        assertTrue(fieldList.size() == 3);
    } catch (IOException e) {
        e.printStackTrace();
        fail(e.getMessage());
    }
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
@Override
public void saveAsCSV() {
	final List<String> attributes = new ArrayList<String>();
	for (final PropertyDescriptor v : layer.getFeatureSource().getSchema().getDescriptors()) {
		attributes.add(v.getName().toString());
	}
	saveAsCSV(attributes, null, null);
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
/**
 * Check if the given map layer contains a grid coverage or a grid coverage reader.
 * <p>
 * Implementation note: we avoid referencing org.geotools.coverage.grid classes directly here so that applications
 * dealing only with other data types are not forced to have JAI in the classpath.
 *
 * @param layer
 *            the map layer
 *
 * @return true if this is a grid layer; false otherwise
 */
public static boolean isGridLayer(final Layer layer) {

	final Collection<PropertyDescriptor> descriptors = layer.getFeatureSource().getSchema().getDescriptors();
	for (final PropertyDescriptor desc : descriptors) {
		final Class<?> binding = desc.getType().getBinding();

		if (BASE_GRID_CLASS.isAssignableFrom(binding)
				|| BASE_READER_CLASS.isAssignableFrom(binding)) { return true; }
	}

	return false;
}
 

import org.opengis.feature.type.PropertyDescriptor; //导入依赖的package包/类
public static String getGridAttributeName(final Layer layer) {
	String attrName = null;

	final Collection<PropertyDescriptor> descriptors = layer.getFeatureSource().getSchema().getDescriptors();
	for (final PropertyDescriptor desc : descriptors) {
		final Class<?> binding = desc.getType().getBinding();

		if (BASE_GRID_CLASS.isAssignableFrom(binding) || BASE_READER_CLASS.isAssignableFrom(binding)) {
			attrName = desc.getName().getLocalPart();
			break;
		}
	}

	return attrName;
}