reader.cpp

来自「支持各种栅格图像和矢量图像读取的库」· C++ 代码 · 共 920 行 · 第 1/2 页

/* This file is part of the iom project.
 * For more information, please see <http://www.interlis.ch>.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */


/** @file
 * adapter to xml parser 
 * @defgroup reader xml reader functions
 * @{
 */

#include <assert.h>
#include <string.h>

#include <xercesc/util/XMLString.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>

#include <iom/iom_p.h>

XMLStringPool *ParserHandler::namev=0;


/** read complete HEADERSECTION
 *  Requires: call to setFilename()
 */
int iom_file::readHeader(const char *model)
{
	handler=dbgnew class ParserHandler(this,model);
	parser=XMLReaderFactory::createXMLReader();
	// Do not report validation errors
    parser->setFeature(XMLUni::fgSAX2CoreValidation, false);
	// use scanner that performs well-formedness checking only.
	parser->setProperty(XMLUni::fgXercesScannerName,(void *)XMLUni::fgWFXMLScanner);
    parser->setContentHandler(handler);
    parser->setErrorHandler(handler);
	return readLoop(filename);
}


int iom_file::readLoop(const char *filename)
{
	try{
		if (!parser->parseFirst(filename, token))
		{
			iom_issueerr("scanFirst() failed");
			return IOM_ERR_XMLPARSER;
		}
		bool gotMore = true;
		while (gotMore && !parser->getErrorCount()){
			gotMore = parser->parseNext(token);
		}
		parser->parseReset(token);
	}
	catch (const XMLException& toCatch) {
            char* message = XMLString::transcode(toCatch.getMessage());
			iom_issueerr(message);
            XMLString::release(&message);
            return IOM_ERR_XMLPARSER;
    }
	return 0;
}


/** read one (next) basket
 */
int iom_file::readBasket(IomFile file)
{
	return 1;
}

/** sets filename
 */
void iom_file::setFilename(const char *filename1)
{
	if(filename)free((void *)filename);
	filename=strdup(filename1);
}

/** @}
 */

//#include <xercesc/util/XMLUniDefs.hpp>
//#include <xercesc/util/XMLUni.hpp>
//#include <xercesc/sax/AttributeList.hpp>

Element::Element()
	: object(0)
	, propertyName(0)
	, oid(0)
	, bid(0)
	, orderPos(0)
{
}
Element::Element(const Element& src) 
	: object(src.object)
	, propertyName(src.propertyName)
	, oid(XMLString::replicate(src.oid))
	, bid(XMLString::replicate(src.bid))
	, orderPos(src.orderPos)
{
}
Element& Element::operator=(const Element& src){
	if(this!=&src){
		object=src.object;
		if(bid){
			XMLString::release(&bid);
		}
		if(src.bid){
			bid=XMLString::replicate(src.bid);
		}
		if(oid){
			XMLString::release(&oid);
		}
		if(src.oid){
			oid=XMLString::replicate(src.oid);
		}
		propertyName=src.propertyName;
		orderPos=src.orderPos;
	}
	return *this;
}
Element::~Element(){
	if(bid)XMLString::release(&bid);
	if(oid)XMLString::release(&oid);
}

const XMLCh *Element::getOid()
{
	return oid;
}

void Element::setOid(const XMLCh *oid1)
{
	if(oid)XMLString::release(&oid);
	oid=XMLString::replicate(oid1);
}

const XMLCh *Element::getBid()
{
	return bid;
}

void Element::setBid(const XMLCh *bid1)
{
	if(bid)XMLString::release(&bid);
	bid=XMLString::replicate(bid1);
}

unsigned int Element::getOrderPos()
{
	return orderPos;
}

void Element::setOrderPos(unsigned int value)
{
	orderPos=value;
}

static const XMLCh* stripX(const XMLCh* value)
{
	if(XMLString::startsWith(value,X("x"))){
		return value+1;
	}
	return value;
}

ParserHandler::ParserHandler(struct iom_file *inputfile,const char* model1) 
	: locator(0)
	,file(inputfile)
	,model(model1 ? strdup(model1) : 0)
	,skip(0)
	,level(0)
	,state(BEFORE_TRANSFER)
	,dataContainer(0)
	,object(0)
{
	//  setupTag2MetaobjMapping();
}

ParserHandler::~ParserHandler()
{
	if(model){
		free(model);
		model=0;
	}
}

bool xisClassDef(int tag)
{
	const XMLCh *const type=ParserHandler::getTagName(tag);
	if(!XMLString::compareString(type,X("iom04.metamodel.Table"))){
		return true;
	}
	return false;
}
bool xisAssociationDef(int tag)
{
	const XMLCh *const type=ParserHandler::getTagName(tag);
	if(!XMLString::compareString(type,X("iom04.metamodel.AssociationDef"))){
		return true;
	}
	return false;
}
bool xisTopicDef(int tag)
{ 
	const XMLCh *const type=ParserHandler::getTagName(tag);
	if(!XMLString::compareString(type,X("iom04.metamodel.Topic"))){
		return true;
	}
	return false;
}

void  ParserHandler::startElement (const XMLCh *const uri
									, const XMLCh *const localname
									, const XMLCh *const qname
									, const Attributes &attrs)
{
    	level++;
    	if(skip>0){
    		skip++;
    		return;
    	}
		int tag=getTagId(localname);
		if(state==BEFORE_TRANSFER && tag==tags::get_TRANSFER()){
    		state=BEFORE_DATASECTION;
    		return;
    	}
		if(state==BEFORE_DATASECTION && tag==tags::get_HEADERSECTION()){
			const XMLCh* sender=0;
			const XMLCh* version=0;
			for(unsigned int attri=0;attri<attrs.getLength();attri++){
				if(!XMLString::compareString(attrs.getLocalName(attri),ustrings::get_SENDER())){
					sender=attrs.getValue(attri);
				}
				if(!XMLString::compareString(attrs.getLocalName(attri),ustrings::get_VERSION())){
					version=attrs.getValue(attri);
				}

			}
			if(!sender){
				// SENDER is mandatory
				iom_issueparserr("Attribute SENDER missing in file ",IOM_ERRKIND_MISSING,locator->getLineNumber(),locator->getColumnNumber());
			}else{
				file->setHeadSecSender(sender);
			}
			if(!version){
				// VERSION is mandatory
				iom_issueparserr("Attribute VERSION missing in file ",IOM_ERRKIND_MISSING,locator->getLineNumber(),locator->getColumnNumber());
			}else{
				file->setHeadSecVersion(version);
				if (XMLString::compareString(version,X("2.2")))
				{
					iom_issueparserr("The VERSION attribute must be \"2.2\"",IOM_ERRKIND_INVALID,locator->getLineNumber(),locator->getColumnNumber());
				}

			}
    		state=START_HEADERSECTION;
    		return;
    	}

		if(state==BEFORE_DATASECTION && tag==tags::get_DATASECTION()){
    		state=BEFORE_BASKET;
    		return;
    	}
    	if(state==BEFORE_BASKET){
			const XMLCh* bid=0;
			const XMLCh* consistency=0;
			for(unsigned int attri=0;attri<attrs.getLength();attri++){
				if(!XMLString::compareString(attrs.getLocalName(attri),ustrings::get_BID())){
					bid=attrs.getValue(attri);
				}
				if(!XMLString::compareString(attrs.getLocalName(attri),ustrings::get_CONSISTENCY())){
					consistency=attrs.getValue(attri);
				}
			}
			dataContainer=dbgnew struct iom_basket();
			dataContainer->setXMLLineNumber(locator->getLineNumber());
			dataContainer->setXMLColumnNumber(locator->getColumnNumber());
			if(!bid){
				// BOID is mandatory
				iom_issueparserr("Attribute BID missing in basket ",IOM_ERRKIND_MISSING,locator->getLineNumber(),locator->getColumnNumber());
			}else{
				dataContainer->setOid(stripX(bid));
			}
			if(consistency){
				if(!XMLString::compareString(consistency,ustrings::get_COMPLETE())){
				    dataContainer->setConsistency(IOM_COMPLETE);
				}else if(!XMLString::compareString(consistency,ustrings::get_INCOMPLETE())){
				    dataContainer->setConsistency(IOM_INCOMPLETE);
				}else if(!XMLString::compareString(consistency,ustrings::get_INCONSISTENT())){
				    dataContainer->setConsistency(IOM_INCONSISTENT);
				}else if(!XMLString::compareString(consistency,ustrings::get_ADAPTED())){
				    dataContainer->setConsistency(IOM_ADAPTED);
				}else{
					iom_issueparserr("Attribute CONSISTENCY has wrong value in basket ",IOM_ERRKIND_INVALID,locator->getLineNumber(),locator->getColumnNumber());
				}
			}
			dataContainer->setTag(tag);
			dataContainer->file=file;
		  	state=BEFORE_OBJECT;
			return;
    	}
    	// SegmentSequence
		if(state==SS_AFTER_COORD){
			pushReturnState(SS_AFTER_COORD);
			if(tag==tags::get_COORD()){
				state=CV_COORD;
				object=dbgnew struct iom_object();
				object->setTag(tags::get_COORD());
			}else{
				state=ST_BEFORE_PROPERTY;
				object=dbgnew struct iom_object();
				object->setTag(tag);
			}
			return;
		}
    	
    	// PolylineValue
		if((state==PV_POLYLINE 
				|| state==PV_AFTER_LINEATTR) 
				&& tag==tags::get_CLIPPED()){
			state=PV_CLIPPED;
			changeReturnState(PV_AFTER_CLIPPED);
			object->setConsistency(IOM_INCOMPLETE);
			return;
		}
		if(state==PV_POLYLINE && tag==tags::get_LINEATTR()){
			state=PV_LINEATTR;
			return;
		}
		if(state==PV_LINEATTR){
			pushReturnState(PV_AFTER_LINEATTRSTRUCT);
			state=ST_BEFORE_PROPERTY;
			object=dbgnew struct iom_object();
			object->setTag(tag);
			return;
		}
		if(state==PV_AFTER_CLIPPED && tag==tags::get_CLIPPED()){
			state=PV_CLIPPED;
			pushReturnState(PV_AFTER_CLIPPED);
			return;
		}
		if((state==PV_POLYLINE 
				|| state==PV_CLIPPED 
				|| state==PV_AFTER_LINEATTR)
				&& tag==tags::get_COORD()){
			pushReturnState(SS_AFTER_COORD);
			object=dbgnew struct iom_object();
			object->setTag(tags::get_SEGMENTS());
			Element ele;
			ele.object=object;
			ele.propertyName=tags::get_segment();
			objStack.push(ele);
			state=CV_COORD;
			object=dbgnew struct iom_object();
			object->setTag(tags::get_COORD());
			return;
		}
		
		// SurfaceValue
		if(state==SV_SURFACE && tag==tags::get_CLIPPED()){
			state=SV_CLIPPED;
			changeReturnState(SV_AFTER_CLIPPED);
			Element top=objStack.top();objStack.pop();
			Element ele=objStack.top();
			objStack.push(top);
			ele.object->setConsistency(IOM_INCOMPLETE);
			return;
		}
		if(state==SV_AFTER_CLIPPED && tag==tags::get_CLIPPED()){
			pushReturnState(SV_AFTER_CLIPPED);
			state=SV_CLIPPED;
			object=dbgnew struct iom_object();
			object->setTag(tags::get_SURFACE());
			Element ele;
			ele.object=object;
			ele.propertyName=tags::get_boundary();
			objStack.push(ele);
			return;
		}
		if((state==SV_SURFACE || state==SV_CLIPPED 
				|| state==BD_AFTER_BOUNDARY)
				&& tag==tags::get_BOUNDARY()){
			object=dbgnew struct iom_object();
			object->setTag(tags::get_BOUNDARY());
			Element ele;
			ele.object=object;
			ele.propertyName=tags::get_polyline();
			objStack.push(ele);
			state=BD_BOUNDARY;
			return;
		}
		if((state==BD_BOUNDARY || state==BD_AFTER_POLYLINE)
				&& tags::get_POLYLINE()){
			pushReturnState(BD_AFTER_POLYLINE);
			state=PV_POLYLINE;
			object=dbgnew struct iom_object();
			object->setTag(tags::get_POLYLINE());
			Element ele;
			ele.object=object;
			ele.propertyName=tags::get_sequence();
			objStack.push(ele);
			return;
		}
    	
    	// CoordValue
		if(state==CV_COORD && tag==tags::get_C1()){
			state=CV_C1;
			// ensure we save collected characters only inside C1
			propertyValue.reset();
			return;
		}
		if(state==CV_AFTER_C1 && tag==tags::get_C2()){
			state=CV_C2;
			// ensure we save collected characters only inside C2
			propertyValue.reset();
			return;
		}
		if(state==CV_AFTER_C2 && tag==tags::get_C3()){
			state=CV_C3;
			// ensure we save collected characters only inside C3
			propertyValue.reset();
			return;
		}
		if(state==ST_BEFORE_CHARACTERS && tag==tags::get_SURFACE()){
			pushReturnState(ST_AFTER_SURFACE);
			state=SV_SURFACE;
			object=dbgnew struct iom_object();
			object->setTag(tags::get_MULTISURFACE());
			Element ele;
			ele.object=object;
			ele.propertyName=tags::get_surface();
			objStack.push(ele);
			object=dbgnew struct iom_object();
			object->setTag(tags::get_SURFACE());
			//ele=ceisnew Element();
			ele.object=object;
			ele.propertyName=tags::get_boundary();
			objStack.push(ele);
			return;
		}
		if(state==ST_BEFORE_CHARACTERS && tag==tags::get_POLYLINE()){
			pushReturnState(ST_AFTER_POLYLINE);
			state=PV_POLYLINE;
			object=dbgnew struct iom_object();
			object->setTag(tags::get_POLYLINE());