writer.cpp

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

			out.startElement(attr,0,0);
			out.characters(val);
			out.endElement(/*attr*/);
			if(valueCount>1){
				iom_issueerr("max one primitive-type value allowed");
			}
		}
	}
}

void iom_file::writeAttrs(XmlWriter &out, IomObject &obj)
{
	tagv_type::iterator tag=tagList.find(obj->getTag());
	// class not found?
	if(tag==tagList.end()){
		std::string msg="unknown type <";
		msg+=+obj->getTag_c();
		msg+=">";
		iom_issueerr(msg.c_str());
		// write all attributes
		for(int attri=0;attri<obj->getAttrCount();attri++){
			int attr=obj->getAttrName(attri);
			writeAttr(out, obj,attr);
		}
	}else{
		// class found
		attrv_type attrv=tag->second;
		for(attrv_type::size_type attri=0;attri<attrv.size();attri++){
			int attr=attrv[attri].second;
			writeAttr(out, obj,attr);
		}
	}
}

/** write all baskets to an xml file.
 */
int iom_file::save()
{
	// build class/attribute list
	if(ilibasket.isNull()){
		iom_issueerr("model required to save data");
		return IOM_ERR_ILLEGALSTATE;
	}
	buildTagList();

	// read rest of file (before we overwrite it!)
	IomIterator bi=new iom_iterator(this);
	while(!bi->next_basket().isNull()){
		; // empty
	}

	// open file for write
	XmlWriter out;
	int ind=0;
	out.open(filename);out.printNewLine();

	// write header
	XmlWrtAttr trsfAttr[]={XmlWrtAttr(ustrings::get_xmlns(),ustrings::get_NS_INTERLIS22())};
	out.printIndent(ind);
	out.startElement(tags::get_TRANSFER(),trsfAttr,sizeof(trsfAttr)/sizeof(trsfAttr[0]));out.printNewLine();
	{
		ind++;
		out.printIndent(ind);
		XStr version("2.2");
		XmlWrtAttr headAttr[]={
			XmlWrtAttr(ustrings::get_VERSION(),version.unicodeForm())
			,XmlWrtAttr(ustrings::get_SENDER(),getHeadSecSender())
		};
		out.startElement(tags::get_HEADERSECTION(),headAttr,sizeof(headAttr)/sizeof(headAttr[0]));out.printNewLine();
		{
			ind++;
			out.printIndent(ind);
			out.startElement(tags::get_ALIAS(),0,0);out.printNewLine();
			{
				ind++;
				ind--;
			}
			out.printIndent(ind);
			out.endElement(/*ALIAS*/);out.printNewLine();
			out.printIndent(ind);
			out.startElement(tags::get_COMMENT(),0,0);
			out.characters(getHeadSecComment());
			out.endElement(/*COMMENT*/);out.printNewLine();
			ind--;
		}
		out.printIndent(ind);
		out.endElement(/*HEADERSECTION*/);out.printNewLine();
		ind--;
	}

	// write DATASECTION
	{
		ind++;
		out.printIndent(ind);
		out.startElement(tags::get_DATASECTION(),0,0);out.printNewLine();
		{
			ind++;

			// write all baskets
			for(std::vector<IomBasket>::size_type basketi=0;basketi<basketv.size();basketi++){
				IomBasket basket=basketv.at(basketi);
				const XMLCh *topics=basket->getTopics();
				const XMLCh *kind=encodeBasketKind(basket->getKind());
				const XMLCh *startstate=basket->getKind()!=IOM_FULL ? basket->getStartState() : 0;
				const XMLCh *endstate=basket->getKind()!=IOM_FULL ? basket->getEndState() : 0;
				const XMLCh *consistency=encodeConsistency(basket->getConsistency());
				XmlWrtAttr basketAttr[]={
					XmlWrtAttr(ustrings::get_BID(),basket->getOid(),true)
					,XmlWrtAttr(topics ? ustrings::get_TOPICS():0,topics)
					,XmlWrtAttr(kind ? ustrings::get_KIND():0 ,kind)
					,XmlWrtAttr(startstate ? ustrings::get_STARTSTATE():0,startstate)
					,XmlWrtAttr(endstate ? ustrings::get_ENDSTATE():0,endstate)
					,XmlWrtAttr(consistency ? ustrings::get_CONSISTENCY():0,consistency)
				};
				out.printIndent(ind);
				if(basket->getTag()==0){
					iom_issueerr("basket requires a TOPIC name");
					return IOM_ERR_ILLEGALSTATE;
				}
				out.startElement(basket->getTag(),basketAttr,sizeof(basketAttr)/sizeof(basketAttr[0]));out.printNewLine();
				{
					ind++;
					// write all objects
					IomIterator obji=new iom_iterator(basket);
					IomObject obj=obji->next_object();
					while(!obj.isNull()){
						out.printIndent(ind);
						const XMLCh *bid=obj->getBid();
						const XMLCh *ops=encodeOperation(obj->getOperation());
						const XMLCh *consistency=encodeConsistency(basket->getConsistency());
						XmlWrtAttr objAttr[]={
							XmlWrtAttr(ustrings::get_TID(),obj->getOid(),true)
							,XmlWrtAttr(bid ? ustrings::get_BID():0,bid,true)
							,XmlWrtAttr(ops ? ustrings::get_OPERATION():0 ,ops)
							,XmlWrtAttr(consistency ? ustrings::get_CONSISTENCY():0,consistency)
						};
						out.startElement(obj->getTag(),objAttr,sizeof(objAttr)/sizeof(objAttr[0]));
						writeAttrs(out,obj);
						out.endElement(/*object*/);out.printNewLine();
						obj=obji->next_object();
					}
					ind--;
				}
				out.printIndent(ind);
				out.endElement(/*basket*/);out.printNewLine();
			}
			ind--;
		}
		out.printIndent(ind);
		out.endElement(/*DATASECTION*/);out.printNewLine();
		ind--;
	}
	out.printIndent(ind);
	out.endElement(/*TRANSFER*/);out.printNewLine();
	// close file
	out.close();
	return 0;
}

int iom_file::getQualifiedTypeName(IomObject &aclass)
{
	static const XMLCh  period[] =
	{
		chPeriod,  chNull
	};
	IomObject topic=ilibasket->getObject(aclass->getAttrObj(tags::get_container(),0)->getRefOid());
	IomObject model=ilibasket->getObject(topic->getAttrObj(tags::get_container(),0)->getRefOid());
	// class at model level?
	XMLCh *qname;
	if(model->getTag()==tags::get_iom04_metamodel_TransferDescription()){
		const XMLCh *modelName=topic->getAttrValue(tags::get_name());
		const XMLCh *className=aclass->getAttrValue(tags::get_name());
		int qnLen=XMLString::stringLen(modelName)+1+XMLString::stringLen(className)+1;
		qname=dbgnew XMLCh[qnLen];
		XMLString::copyString(qname,modelName);
		XMLString::catString(qname,period);
		XMLString::catString(qname,className);
	}else{
		const XMLCh *modelName=model->getAttrValue(tags::get_name());
		const XMLCh *topicName=topic->getAttrValue(tags::get_name());
		const XMLCh *className=aclass->getAttrValue(tags::get_name());
		int qnLen=XMLString::stringLen(modelName)+1+XMLString::stringLen(topicName)+1+XMLString::stringLen(className)+1;
		qname=dbgnew XMLCh[qnLen];
		XMLString::copyString(qname,modelName);
		XMLString::catString(qname,period);
		XMLString::catString(qname,topicName);
		XMLString::catString(qname,period);
		XMLString::catString(qname,className);
	}
	int classId=ParserHandler::getTagId(qname);
	delete[] qname;
	return classId;
}

void iom_file::buildTagList()
{
	// for all links class--(attribute|role)
	IomIterator obji=new iom_iterator(ilibasket);
	IomObject obj;
	while(!(obj=obji->next_object()).isNull()){
		if(obj->getTag()==tags::get_iom04_metamodel_Table() || obj->getTag()==tags::get_iom04_metamodel_AssociationDef()){
			// get qualified name of class
			int classId=getQualifiedTypeName(obj);
			// add to tag list
			tagv_type::iterator tag=tagList.find(classId);
			if(tag==tagList.end()){
				// not found, add empty attr list
				attrv_type attrv;
				tagList[classId]=attrv;
			}else{
				// found, don't change
			}
		}else if(obj->getTag()==tags::get_iom04_metamodel_ViewableAttributesAndRoles()){
			// get class
			IomObject aclass=ilibasket->getObject(obj->getAttrObj(tags::get_viewable(),0)->getRefOid());
			// get qualified name of class
			int classId=getQualifiedTypeName(aclass);
			// get attribute or role
			IomObject leafref=obj->getAttrObj(tags::get_attributesAndRoles(),0);
			// get name
			IomObject leafele=ilibasket->getObject(leafref->getRefOid());
			const XMLCh *leafName=leafele->getAttrValue(tags::get_name());
			int attrId=ParserHandler::getTagId(leafName);
			// get element index
			int eleIdx=leafref->getRefOrderPos()-1;
			// add to tag list
			tagv_type::iterator tag=tagList.find(classId);
			if(tag==tagList.end()){
				// not found, add
				attrv_type attrv;
				std::pair<int,int> ele(eleIdx,attrId);
				attrv.push_back(ele);
				tagList[classId]=attrv;
			}else{
				// found, replace
				attrv_type attrv=tag->second;
				std::pair<int,int> ele(eleIdx,attrId);
				attrv.push_back(ele);
				tagList[classId]=attrv;
			}
		}
	}

	// in all classes sort attrs according to pos
	tagv_type::iterator tag=tagList.begin();
	for(;tag!=tagList.end();tag++){
		attrv_type attrv=tag->second;
		std::sort(attrv.begin(),attrv.end());
		tagList[tag->first]=attrv;		
	}
	
}

/** @}
 */


//UTF-8
static const XMLCh  gUTF8[] =
{
    chLatin_U, chLatin_T, chLatin_F, chDash, chDigit_8, chNull
};

//</
static const XMLCh  gEndElement[] =
{
    chOpenAngle, chForwardSlash, chNull
};

//<?xml version="
static const XMLCh  gXMLDecl_VersionInfo[] =
{
    chOpenAngle, chQuestion, chLatin_x,     chLatin_m,  chLatin_l,  chSpace,
    chLatin_v,   chLatin_e,  chLatin_r,     chLatin_s,  chLatin_i,  chLatin_o,
    chLatin_n,   chEqual,    chDoubleQuote, chNull
};

static const XMLCh gXMLDecl_ver10[] =
{
    chDigit_1, chPeriod, chDigit_0, chNull
};

//encoding="
static const XMLCh  gXMLDecl_EncodingDecl[] =
{
    chLatin_e,  chLatin_n,  chLatin_c,  chLatin_o,      chLatin_d, chLatin_i,
    chLatin_n,  chLatin_g,  chEqual,    chDoubleQuote,  chNull
};

//"
static const XMLCh  gXMLDecl_separator[] =
{
    chDoubleQuote, chSpace, chNull
};

//?>
static const XMLCh  gXMLDecl_endtag[] =
{
    chQuestion, chCloseAngle,  chNull
};


const XMLCh *XmlWrtAttr::getName()
{
	return name;
}

const XMLCh *XmlWrtAttr::getValue()
{
	return value;
}
bool XmlWrtAttr::isOid()
{
	return oidAttr;
}
XmlWrtAttr::XmlWrtAttr(const XMLCh *name1,const XMLCh *value1)
	: name(name1)
	, value(value1)
	,oidAttr(false)
{
}
XmlWrtAttr::XmlWrtAttr(const XMLCh *name1,const XMLCh *value1,bool isOid)
	: name(name1)
	, value(value1)
	,oidAttr(isOid)
{
}

void XmlWriter::open(const char *filename)
{
	/*
	out=fopen("filename","w");
	fputs("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>",out);
	newline();

    XMLTransService::Codes resCode;
    transcoder = XMLPlatformUtils::fgTransService->makeNewTranscoderFor
    (
        "UTF-8"
        , resCode
        , 16 * 1024
    );
	*/
	destination=new LocalFileFormatTarget(filename); 
	out= new XMLFormatter(gUTF8
                 ,gXMLDecl_ver10
                 ,destination
                 ,XMLFormatter::NoEscapes
                 ,XMLFormatter::UnRep_CharRef);

    out->setUnRepFlags(XMLFormatter::UnRep_CharRef);

    *out << gXMLDecl_VersionInfo << gXMLDecl_ver10 << gXMLDecl_separator;
    *out << gXMLDecl_EncodingDecl << gUTF8 << gXMLDecl_separator;
    *out << gXMLDecl_endtag;
}

void XmlWriter::startElement(int tagid,XmlWrtAttr attrv[],int attrc)
{
	const XMLCh *tagName=ParserHandler::getTagName(tagid);

    *out  << XMLFormatter::NoEscapes
                 << chOpenAngle << tagName;


	for(int i=0;i<attrc;i++){
		if(attrv[i].getName()){
			*out  << XMLFormatter::NoEscapes
					 << chSpace << attrv[i].getName()
					 << chEqual << chDoubleQuote
					 << XMLFormatter::AttrEscapes;
			if(attrv[i].isOid()){
				*out << chLatin_x; 
			}
			*out << attrv[i].getValue()
					 << XMLFormatter::NoEscapes
					 << chDoubleQuote;
		}
	}

    *out << XMLFormatter::NoEscapes << chCloseAngle;
	stack.push(tagid);
}

void XmlWriter::endElement()
{
	const XMLCh *tagName=ParserHandler::getTagName(stack.top());
	stack.pop();
    *out  << XMLFormatter::NoEscapes
                 << chOpenAngle 
				 << chForwardSlash << tagName << chCloseAngle;
}

void XmlWriter::characters(const XMLCh *const chars)
{
    //fFormatter->setUnRepFlags(XMLFormatter::UnRep_CharRef);
	out->formatBuf(chars, XMLString::stringLen(chars), XMLFormatter::CharEscapes);
}
XmlWriter::XmlWriter()
: out(0)
, destination(0)
{
}
XmlWriter::~XmlWriter()
{
	close();
}
void XmlWriter::close()
{
	//fclose(out);out=0;
	if(destination){
		delete destination;destination=0;
	}
	if(out){
		delete out;out=0;
	}
}

void XmlWriter::printNewLine()
{
	static const XMLCh  gEOLSeq[] =
	{
		chLF, chNull
	};
   *out << gEOLSeq;
}

void XmlWriter::printIndent(int level)
{
	for(int i = 0; i < level; i++)
		*out << chSpace << chSpace;
}