import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
@Override
public Worker<CityGML> createWorker() {
	DBImportWorker dbWorker = null;

	try {
		dbWorker = new DBImportWorker(dbConnectionPool,
				jaxbBuilder,
				xlinkWorkerPool, 
				lookupServerManager,
				importFilter,
				config, 
				eventDispatcher);
	} catch (SQLException sqlEx) {
		// could not instantiate DBWorker
	}

	return dbWorker;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
@Override
public CityGMLClass getCityGMLClass() {
	if (citygmlResolved.get())
		return citygml.getCityGMLClass();

	if (typeResolved.compareAndSet(false, true)) {
		try {
			ElementInfo info = jaxbReader.elementChecker.getElementInfo(firstElement);
			if (info != null) {
				if (info.getFeatureClass() != null
						&& jaxbReader.elementChecker.isCityGMLElement(firstElement)
						&& CityGML.class.isAssignableFrom(info.getFeatureClass()))
					type = CityGMLClass.fromModelClass(info.getFeatureClass().asSubclass(CityGML.class));
				else
					type = CityGMLClass.ADE_COMPONENT;
			}
		} catch (MissingADESchemaException e) {
			//
		}
	}

	return type;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(CityFurnitureType.class, this::unmarshalCityFurniture)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(GenericCityObjectType.class, this::unmarshalGenericCityObject)
						.with(DateAttributeType.class, this::unmarshalDateAttribute)
						.with(DoubleAttributeType.class, this::unmarshalDoubleAttribute)
						.with(IntAttributeType.class, this::unmarshalIntAttribute)
						.with(StringAttributeType.class, this::unmarshalStringAttribute)
						.with(UriAttributeType.class, this::unmarshalUriAttribute)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(PlantCoverType.class, this::unmarshalPlantCover)
						.with(SolitaryVegetationObjectType.class, this::unmarshalSolitaryVegetationObject)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(AppearancePropertyType.class, this::unmarshalAppearanceProperty)
						.with(MaterialType.class, this::unmarshalMaterial)
						.with(SimpleTextureType.class, this::unmarshalSimpleTexture)
						.with(TexturedSurfaceType.class, this::unmarshalTexturedSurface)
						.with(TextureTypeType.class, this::unmarshalTextureType)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(CityObjectGroupType.class, this::unmarshalCityObjectGroup)
						.with(CityObjectGroupMemberType.class, this::unmarshalCityObjectGroupMember)
						.with(CityObjectGroupParentType.class, this::unmarshalCityObjectGroupParent)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public boolean assignGenericProperty(ADEGenericElement genericProperty, QName substitutionGroup, CityGML dest) {
	String name = substitutionGroup.getLocalPart();
	boolean success = true;

	if (dest instanceof AbstractCityObject && name.equals("_GenericApplicationPropertyOfCityObject"))
		((AbstractCityObject)dest).addGenericApplicationPropertyOfCityObject(genericProperty);
	else if (dest instanceof AbstractSite && name.equals("_GenericApplicationPropertyOfSite"))
		((AbstractSite)dest).addGenericApplicationPropertyOfSite(genericProperty);
	else if (dest instanceof Address && name.equals("_GenericApplicationPropertyOfAddress"))
		((Address)dest).addGenericApplicationPropertyOfAddress(genericProperty);
	else if (dest instanceof CityModel && name.equals("_GenericApplicationPropertyOfCityModel"))
		((CityModel)dest).addGenericApplicationPropertyOfCityModel(genericProperty);
	else 
		success = false;

	return success;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(AddressType.class, this::unmarshalAddress)
						.with(AddressPropertyType.class, this::unmarshalAddressProperty)
						.with(CityModelType.class, this::unmarshalCityModel)
						.with(ExternalObjectReferenceType.class, this::unmarshalExternalObject)
						.with(ExternalReferenceType.class, this::unmarshalExternalReference)
						.with(GeneralizationRelationType.class, this::unmarshalGeneralizationRelation)
						.with(ImplicitGeometryType.class, this::unmarshalImplicitGeometry)
						.with(ImplicitRepresentationPropertyType.class, this::unmarshalImplicitRepresentationProperty)
						.with(XalAddressPropertyType.class, this::unmarshalXalAddressProperty)
						.with(FeaturePropertyType.class, this::unmarshalCityObjectMember)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(AuxiliaryTrafficAreaType.class, this::unmarshalAuxiliaryTrafficArea)
						.with(AuxiliaryTrafficAreaPropertyType.class, this::unmarshalAuxiliaryTrafficAreaProperty)
						.with(RailwayType.class, this::unmarshalRailway)
						.with(RoadType.class, this::unmarshalRoad)
						.with(SquareType.class, this::unmarshalSquare)
						.with(TrackType.class, this::unmarshalTrack)
						.with(TrafficAreaType.class, this::unmarshalTrafficArea)
						.with(TrafficAreaPropertyType.class, this::unmarshalTrafficAreaProperty)
						.with(TransportationComplexType.class, this::unmarshalTransportationComplex)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public boolean assignGenericProperty(ADEGenericElement genericProperty, QName substitutionGroup, CityGML dest) {
	String name = substitutionGroup.getLocalPart();
	boolean success = true;

	if (dest instanceof AbstractTransportationObject && name.equals("_GenericApplicationPropertyOfTransportationObject"))
		((AbstractTransportationObject)dest).addGenericApplicationPropertyOfTransportationObject(genericProperty);
	else if (dest instanceof AuxiliaryTrafficArea && name.equals("_GenericApplicationPropertyOfAuxiliaryTrafficArea"))
		((AuxiliaryTrafficArea)dest).addGenericApplicationPropertyOfAuxiliaryTrafficArea(genericProperty);
	else if (dest instanceof TransportationComplex && name.equals("_GenericApplicationPropertyOfTransportationComplex"))
		((TransportationComplex)dest).addGenericApplicationPropertyOfTransportationComplex(genericProperty);
	else if (dest instanceof Railway && name.equals("_GenericApplicationPropertyOfRailway"))
		((Railway)dest).addGenericApplicationPropertyOfRailway(genericProperty);
	else if (dest instanceof Road && name.equals("_GenericApplicationPropertyOfRoad"))
		((Road)dest).addGenericApplicationPropertyOfRoad(genericProperty);
	else if (dest instanceof Square && name.equals("_GenericApplicationPropertyOfSquare"))
		((Square)dest).addGenericApplicationPropertyOfSquare(genericProperty);
	else if (dest instanceof Track && name.equals("_GenericApplicationPropertyOfTrack"))
		((Track)dest).addGenericApplicationPropertyOfTrack(genericProperty);
	else if (dest instanceof TrafficArea && name.equals("_GenericApplicationPropertyOfTrafficArea"))
		((TrafficArea)dest).addGenericApplicationPropertyOfTrafficArea(genericProperty);
	else 
		success = false;

	return success;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(LandUseType.class, this::unmarshalLandUse)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public boolean assignGenericProperty(ADEGenericElement genericProperty, QName substitutionGroup, CityGML dest) {
	String name = substitutionGroup.getLocalPart();
	boolean success = true;

	if (dest instanceof AbstractWaterObject && name.equals("_GenericApplicationPropertyOfWaterObject"))
		((AbstractWaterObject)dest).addGenericApplicationPropertyOfWaterObject(genericProperty);		
	else if (dest instanceof AbstractWaterBoundarySurface && name.equals("_GenericApplicationPropertyOfWaterBoundarySurface"))
		((AbstractWaterBoundarySurface)dest).addGenericApplicationPropertyOfWaterBoundarySurface(genericProperty);		
	else if (dest instanceof WaterBody && name.equals("_GenericApplicationPropertyOfWaterBody"))
		((WaterBody)dest).addGenericApplicationPropertyOfWaterBody(genericProperty);		
	else if (dest instanceof WaterClosureSurface && name.equals("_GenericApplicationPropertyOfWaterClosureSurface"))
		((WaterClosureSurface)dest).addGenericApplicationPropertyOfWaterClosureSurface(genericProperty);		
	else if (dest instanceof WaterGroundSurface && name.equals("_GenericApplicationPropertyOfWaterGroundSurface"))
		((WaterGroundSurface)dest).addGenericApplicationPropertyOfWaterGroundSurface(genericProperty);		
	else if (dest instanceof WaterSurface && name.equals("_GenericApplicationPropertyOfWaterSurface"))
		((WaterSurface)dest).addGenericApplicationPropertyOfWaterSurface(genericProperty);		
	else
		success = false;

	return success;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
private CheckedTypeMapper<CityGML> getTypeMapper() {
	if (typeMapper == null) {
		lock.lock();
		try {
			if (typeMapper == null) {
				typeMapper = CheckedTypeMapper.<CityGML>create()
						.with(BreaklineReliefType.class, this::unmarshalBreaklineRelief)
						.with(GridPropertyType.class, this::unmarshalGridProperty)
						.with(MassPointReliefType.class, this::unmarshalMassPointRelief)
						.with(RasterReliefType.class, this::unmarshalRasterRelief)
						.with(ReliefComponentPropertyType.class, this::unmarshalReliefComponentProperty)
						.with(ReliefFeatureType.class, this::unmarshalReliefFeature)
						.with(TinPropertyType.class, this::unmarshalTinProperty)
						.with(TINReliefType.class, this::unmarshalTINRelief)
						.with(JAXBElement.class, this::unmarshal);
			}
		} finally {
			lock.unlock();
		}
	}

	return typeMapper;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public boolean assignGenericProperty(ADEGenericElement genericProperty, QName substitutionGroup, CityGML dest) {
	String name = substitutionGroup.getLocalPart();
	boolean success = true;

	if (dest instanceof AbstractReliefComponent && name.equals("_GenericApplicationPropertyOfReliefComponent"))
		((AbstractReliefComponent)dest).addGenericApplicationPropertyOfReliefComponent(genericProperty);
	else if (dest instanceof BreaklineRelief && name.equals("_GenericApplicationPropertyOfBreaklineRelief"))
		((BreaklineRelief)dest).addGenericApplicationPropertyOfBreaklineRelief(genericProperty);
	else if (dest instanceof MassPointRelief && name.equals("_GenericApplicationPropertyOfMassPointRelief"))
		((MassPointRelief)dest).addGenericApplicationPropertyOfMassPointRelief(genericProperty);
	else if (dest instanceof RasterRelief && name.equals("_GenericApplicationPropertyOfRasterRelief"))
		((RasterRelief)dest).addGenericApplicationPropertyOfRasterRelief(genericProperty);
	else if (dest instanceof ReliefFeature && name.equals("_GenericApplicationPropertyOfReliefFeature"))
		((ReliefFeature)dest).addGenericApplicationPropertyOfReliefFeature(genericProperty);
	else if (dest instanceof TINRelief && name.equals("_GenericApplicationPropertyOfTinRelief"))
		((TINRelief)dest).addGenericApplicationPropertyOfTinRelief(genericProperty);
	else 
		success = false;

	return success;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
/**
 * Returns a list for BuildingCallable read by CityGML file
 * 
 * @param pathtocitygmlfile
 * @param options
 * @return List<BuildingCallable>
 * @throws Exception
 */
public List<BuildingCallable> readCityGMLFile(String pathtocitygmlfile, Options options) throws Exception {

	this.options = options;
	
	List<BuildingCallable> buildings = new ArrayList<BuildingCallable>();
	
	CityGMLContext ctx = new CityGMLContext();
	CityGMLBuilder builder = ctx.createCityGMLBuilder();
	CityGMLInputFactory in = builder.createCityGMLInputFactory();
	CityGMLReader reader = in.createCityGMLReader(new File(pathtocitygmlfile));
	
	while (reader.hasNext()) {
		CityGML citygml = reader.nextFeature();
		
		if (citygml.getCityGMLClass() == CityGMLClass.CITY_MODEL) {
			CityModel cityModel = (CityModel)citygml;
			
			for (CityObjectMember cityObjectMember : cityModel.getCityObjectMember()) {
				AbstractCityObject cityObject = cityObjectMember.getCityObject();
				if (cityObject.getCityGMLClass() == CityGMLClass.BUILDING){
					
					Building building = (Building)cityObject;
					String buildingID = building.getId();
					BuildingCallable buildingcallable = new BuildingCallable();
					buildingcallable.setBsp(building.getBoundedBySurface());
					buildingcallable.setBuildingId(buildingID);
					buildingcallable.setOptions(options);
					buildings.add(buildingcallable);
				}	
			}
		}	
	}			
	
	reader.close();
	return buildings;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
@Override
public Worker<CityGML> createWorker() {
	DBImportWorker dbWorker = null;

	try {
		dbWorker = connection == null ? new DBImportWorker(schemaMapping, cityGMLBuilder, xlinkWorkerPool,
				uidCacheManager, filter, affineTransformer, importLogger, config, eventDispatcher) :
			new DBImportWorker(connection, databaseAdapter, schemaMapping, cityGMLBuilder, xlinkWorkerPool,
					uidCacheManager, filter, affineTransformer, importLogger, config, eventDispatcher);
	} catch (SQLException e) {
		LOG.error("Failed to create import worker: " + e.getMessage());
	}

	return dbWorker;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public FeatureReaderWorker(WorkerPool<CityGML> dbWorkerPool,
		Config config,
		EventDispatcher eventDispatcher) {
	this.dbWorkerPool = dbWorkerPool;
	this.eventDispatcher = eventDispatcher;

	useValidation = config.getProject().getImporter().getXMLValidation().isSetUseXMLValidation();
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public FeatureReaderWorkerFactory(WorkerPool<CityGML> dbWorkerPool,
		Config config,
		EventDispatcher eventDispatcher) {
	this.dbWorkerPool = dbWorkerPool;
	this.config = config;
	this.eventDispatcher = eventDispatcher;
}
 

import org.citygml4j.model.citygml.CityGML; //导入依赖的package包/类
public static CityGMLClass getCityGMLClass(int objectClassId) {
	for (Entry<Class<? extends AbstractGML>, Integer> entry : objectClassIds.entrySet()) {
		if (entry.getValue() == objectClassId) {
			Class<? extends AbstractGML> typeClass = entry.getKey();
			if (CityGML.class.isAssignableFrom(typeClass))				
				return CityGMLClass.fromModelClass(typeClass.asSubclass(CityGML.class));
		}
	}
	
	ADEExtension extension = ADEExtensionManager.getInstance().getExtensionByObjectClassId(objectClassId);
	if (extension != null)
		return CityGMLClass.ADE_COMPONENT;
	
	return CityGMLClass.UNDEFINED;
}