diff options
Diffstat (limited to 'writerfilter/source/resourcemodel/TagLogger.cxx')
| -rw-r--r-- | writerfilter/source/resourcemodel/TagLogger.cxx | 350 |
1 files changed, 350 insertions, 0 deletions
diff --git a/writerfilter/source/resourcemodel/TagLogger.cxx b/writerfilter/source/resourcemodel/TagLogger.cxx new file mode 100644 index 000000000000..1d9b23623e56 --- /dev/null +++ b/writerfilter/source/resourcemodel/TagLogger.cxx @@ -0,0 +1,350 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org 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 version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +#include <fstream> +#include <string.h> +#include <resourcemodel/TagLogger.hxx> +#include <resourcemodel/util.hxx> +#include <resourcemodel/QNameToString.hxx> + +namespace writerfilter +{ + XMLTag::Pointer_t XMLTag::NIL(new XMLTag("NIL")); + + void XMLTag::addAttr(string sName, string sValue) + { + XMLAttribute aAttr(sName, sValue); + + mAttrs.push_back(aAttr); + } + + void XMLTag::addAttr(string sName, const ::rtl::OUString & sValue) + { + addAttr(sName, + OUStringToOString + (sValue, RTL_TEXTENCODING_ASCII_US).getStr()); + } + + void XMLTag::addAttr(string sName, sal_uInt32 nValue) + { + char buffer[256]; + snprintf(buffer, sizeof(buffer), "%" SAL_PRIdINT32, nValue); + addAttr(sName, buffer); + } + + void XMLTag::addTag(XMLTag::Pointer_t pTag) + { + if (pTag != XMLTag::Pointer_t()) + mTags.push_back(pTag); + } + + void XMLTag::chars(const string & rChars) + { + mChars = rChars; + } + + const string & XMLTag::getTag() const + { + return mTag; + } + + string XMLTag::toString() const + { + if (mChars.length() > 0) + return mChars; + + string sResult; + + if (mMode == START || mMode == COMPLETE) + { + sResult += "<" + mTag; + + XMLAttributes_t::const_iterator aIt = mAttrs.begin(); + while (aIt != mAttrs.end()) + { + sResult += " "; + sResult += aIt->mName; + sResult += "=\""; + sResult += xmlify(aIt->mValue); + sResult += "\""; + + aIt++; + } + + sResult +=">"; + + if (mTags.size() > 0) + { + XMLTags_t::const_iterator aItTags = mTags.begin(); + while (aItTags != mTags.end()) + { + if ((*aItTags).get() != NULL) + sResult += (*aItTags)->toString(); + + aItTags++; + } + } + } + + if (mMode == END || mMode == COMPLETE) + sResult += "</" + mTag + ">"; + + return sResult; + } + + ostream & XMLTag::output(ostream & o) const + { + if (mMode == START || mMode == COMPLETE) + { + o << "<" << mTag; + + XMLAttributes_t::const_iterator aItAttrs(mAttrs.begin()); + while (aItAttrs != mAttrs.end()) + { + o << " " << aItAttrs->mName << "=\"" + << xmlify(aItAttrs->mValue) + << "\""; + + aItAttrs++; + } + + o << ">"; + + XMLTags_t::const_iterator aItTags(mTags.begin()); + while (aItTags != mTags.end()) + { + (*aItTags)->output(o); + aItTags++; + } + + o << mChars; + } + + if (mMode == END || mMode == COMPLETE) + o << "</" << mTag << ">"; + + return o; + } + + struct eqstr + { + bool operator()(const char* s1, const char* s2) const + { + return strcmp(s1, s2) == 0; + } + }; + + typedef hash_map<const char *, TagLogger::Pointer_t, hash<const char *>, eqstr> TagLoggerHashMap_t; + static TagLoggerHashMap_t * tagLoggers = NULL; + + TagLogger::TagLogger() + { + } + + TagLogger::~TagLogger() + { + } + + TagLogger::Pointer_t TagLogger::getInstance(const char * name) + { + if (tagLoggers == NULL) + tagLoggers = new TagLoggerHashMap_t(); + + TagLoggerHashMap_t::iterator aIt = tagLoggers->end(); + + if (! tagLoggers->empty()) + aIt = tagLoggers->find(name); + + if (aIt == tagLoggers->end()) + { + TagLogger::Pointer_t pTagLogger(new TagLogger()); + pair<const char *, TagLogger::Pointer_t> entry(name, pTagLogger); + aIt = tagLoggers->insert(entry).first; + } + + return aIt->second; + } + + XMLTag::Pointer_t TagLogger::currentTag() const + { + bool bEmpty=mTags.empty(); + if (!bEmpty) + return mTags.top(); + + return XMLTag::NIL; + } + + void TagLogger::startDocument() + { + XMLTag::Pointer_t pTag(new XMLTag("root")); + mTags.push(pTag); + mpRoot = pTag; + } + + void TagLogger::element(const string & name) + { + startElement(name); + endElement(name); + } + + void TagLogger::startElement(const string & name) + { + XMLTag::Pointer_t pTag(new XMLTag(name)); + currentTag()->addTag(pTag); + mTags.push(pTag); + } + + void TagLogger::attribute(const string & name, const string & value) + { + currentTag()->addAttr(name, value); + } + + void TagLogger::attribute(const string & name, const ::rtl::OUString & value) + { + currentTag()->addAttr(name, value); + } + + void TagLogger::attribute(const string & name, sal_uInt32 value) + { + currentTag()->addAttr(name, value); + } + + void TagLogger::addTag(XMLTag::Pointer_t pTag) + { + currentTag()->addTag(pTag); + } + + void TagLogger::chars(const string & rChars) + { + currentTag()->chars(xmlify(rChars)); + } + + void TagLogger::chars(const ::rtl::OUString & rChars) + { + chars(OUStringToOString(rChars, RTL_TEXTENCODING_ASCII_US).getStr()); + } + + void TagLogger::endElement(const string & name) + { + string nameRemoved = currentTag()->getTag(); + + if (name == nameRemoved) + mTags.pop(); + else { + XMLTag::Pointer_t pTag(new XMLTag("end.mismatch")); + pTag->addAttr("name", name); + pTag->addAttr("top", nameRemoved); + + currentTag()->addTag(pTag); + } + + } + + void TagLogger::endDocument() + { + mTags.pop(); + } + + ostream & TagLogger::output(ostream & o) const + { + return mpRoot->output(o); + } + + void TagLogger::dump(const char * name) + { + TagLoggerHashMap_t::iterator aIt(tagLoggers->find(name)); + if (aIt != tagLoggers->end()) + { + string fileName; + char * temp = getenv("TAGLOGGERTMP"); + + if (temp != NULL) + fileName += temp; + else + fileName += "/tmp"; + + fileName += "/writerfilter."; + fileName += name; + fileName += ".xml"; + + ofstream dumpStream(fileName.c_str()); + aIt->second->output(dumpStream); + } + } + + PropertySetToTagHandler::~PropertySetToTagHandler() + { + } + + void PropertySetToTagHandler::resolve + (XMLTag & rTag, writerfilter::Reference<Properties>::Pointer_t pProps) + { + if (pProps.get() != NULL) + { + PropertySetToTagHandler aHandler(mpIdToString); + pProps->resolve(aHandler); + rTag.addTag(aHandler.getTag()); + } + } + + void PropertySetToTagHandler::attribute(Id name, Value & val) + { + XMLTag::Pointer_t pTag(new XMLTag("attribute")); + + pTag->addAttr("name", (*QNameToString::Instance())(name)); + pTag->addAttr("value", val.toString()); + + resolve(*pTag, val.getProperties()); + + mpTag->addTag(pTag); + } + + void PropertySetToTagHandler::sprm(Sprm & rSprm) + { + XMLTag::Pointer_t pTag(new XMLTag("sprm")); + + string sName; + + if (mpIdToString != IdToString::Pointer_t()) + sName = mpIdToString->toString(rSprm.getId()); + + pTag->addAttr("name", sName); + + static char sBuffer[256]; + snprintf(sBuffer, sizeof(sBuffer), + "0x%" SAL_PRIxUINT32 "x, %" SAL_PRIxUINT32 "d", rSprm.getId(), + rSprm.getId()); + pTag->addAttr("id", sBuffer); + pTag->addAttr("value", rSprm.getValue()->toString()); + + resolve(*pTag, rSprm.getProps()); + + mpTag->addTag(pTag); + } + + +} |