void queryMacroFileProvider::SaveMacros(queryMacroList *macros)
{
xmlTextWriterPtr writer;
writer = xmlNewTextWriterFilename((const char *)settings->GetMacrosFile().mb_str(wxConvUTF8), 0);
if (!writer)
{
wxMessageBox(_("Failed to open macros file!"));
return;
}
xmlTextWriterSetIndent(writer, 1);
if ((xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL) < 0) ||
(xmlTextWriterStartElement(writer, XML_STR("macros")) < 0))
{
wxMessageBox(_("Failed to write to macros file!"));
xmlFreeTextWriter(writer);
return;
}
((queryMacroList *)macros)->saveList(writer);
if (xmlTextWriterEndDocument(writer) < -1)
{
wxMessageBox(_("Failed to write to macros file!"));
}
xmlFreeTextWriter(writer);
}
void queryFavouriteFileProvider::SaveFavourites(queryFavouriteFolder *favourites)
{
xmlTextWriterPtr writer;
writer = xmlNewTextWriterFilename((const char *)settings->GetFavouritesFile().mb_str(wxConvUTF8), 0);
if (!writer)
{
wxMessageBox(_("Failed to write to favourites file!"));
return;
}
xmlTextWriterSetIndent(writer, 1);
if ((xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL) < 0) ||
(xmlTextWriterStartElement(writer, XML_STR("favourites")) < 0))
{
wxMessageBox(_("Failed to write to favourites file!"));
xmlFreeTextWriter(writer);
return;
}
((queryFavouriteFolder *)favourites)->saveFolder(writer);
if (xmlTextWriterEndDocument(writer) < 0)
{
wxMessageBox(_("Failed to write to favourites file!"));
}
xmlFreeTextWriter(writer);
}
int write_volumeindex(opendcp_t *opendcp) {
xmlIndentTreeOutput = 1;
xmlDocPtr doc;
xmlTextWriterPtr xml;
int rc;
dcp_log(LOG_INFO,"Writing VOLINDEX file %.256s",opendcp->volindex.filename);
/* create XML document */
xml = xmlNewTextWriterDoc(&doc,0);
/* volumeindex XML Start */
rc = xmlTextWriterStartDocument(xml, NULL, XML_ENCODING, NULL);
if (rc < 0) {
dcp_log(LOG_ERROR,"xmlTextWriterStartDocument failed");
return DCP_FATAL;
}
xmlTextWriterStartElement(xml, BAD_CAST "VolumeIndex");
xmlTextWriterWriteAttribute(xml, BAD_CAST "xmlns", BAD_CAST NS_AM[opendcp->ns]);
xmlTextWriterWriteFormatElement(xml, BAD_CAST "Index","%d",1);
xmlTextWriterEndElement(xml);
rc = xmlTextWriterEndDocument(xml);
if (rc < 0) {
dcp_log(LOG_ERROR,"xmlTextWriterEndDocument failed %s",opendcp->volindex.filename);
return DCP_FATAL;
}
xmlFreeTextWriter(xml);
xmlSaveFormatFile(opendcp->volindex.filename, doc, 1);
xmlFreeDoc(doc);
return DCP_SUCCESS;
}
/* Private exporting functions cpe_*<structure>*_export( xmlTextWriterPtr )
* More info in representive header file.
* returns the type of <structure>
*/
void cpe_lang_model_export_xml(const struct cpe_lang_model *spec, const char *file)
{
__attribute__nonnull__(spec);
__attribute__nonnull__(file);
// TODO: ad macro to check return value from xmlTextWriter* functions
xmlTextWriterPtr writer;
writer = xmlNewTextWriterFilename(file, 0);
if (writer == NULL) {
oscap_setxmlerr(xmlGetLastError());
return;
}
// Set properties of writer TODO: make public function to edit this ??
xmlTextWriterSetIndent(writer, 1);
xmlTextWriterSetIndentString(writer, BAD_CAST " ");
xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);
cpe_lang_export(spec, writer);
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
if (xmlGetLastError() != NULL)
oscap_setxmlerr(xmlGetLastError());
}
bool TasksetWriter::write(const std::string& filename, vector<Task*>& taskset) const {
xmlDocPtr doc;
tDebug() << "Writing Taskset to XML file: " << filename;
xmlTextWriterPtr writer;
writer = xmlNewTextWriterDoc(&doc, 0);
xmlTextWriterSetIndent(writer, 1);
if (xmlTextWriterSetIndentString(writer, (const xmlChar*) " ") != 0) {
tError() << "Fehler beim Setzen des Einrueckens!";
}
xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);
xmlTextWriterWriteComment(writer, (xmlChar*) "Hier kommen die Tasks");
xmlTextWriterStartElement(writer, (xmlChar*) "taskset");
xmlTextWriterWriteAttributeNS(writer, (xmlChar*) "xsi", (xmlChar*) "schemaLocation", (xmlChar*) "http://www.w3.org/2001/XMLSchema-instance", (xmlChar*) "http://www.tmsxmlns.com taskset.xsd");
xmlTextWriterWriteAttribute(writer, (xmlChar*) "xmlns", (xmlChar*) "http://www.tmsxmlns.com");
xmlTextWriterWriteRaw(writer, (xmlChar*) "\n");
for (size_t i = 0; i < taskset.size(); i++) {
xmlTextWriterWriteRaw(writer, (xmlChar*) "\n");
//taskset[i]->write(writer);
taskset[i]->writeToXML(writer);
xmlTextWriterWriteRaw(writer, (xmlChar*) "\n");
}
xmlTextWriterEndElement(writer); // close TaskSet
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
xmlSaveFile(filename.c_str(), doc);
xmlNodePtr cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
tError() << "Empty document.";
xmlFreeDoc(doc);
return false;
}
if (xmlStrcmp(cur->name, (const xmlChar *) "taskset")) {
tError() << "Document of the wrong type, root node != taskset";
xmlFreeDoc(doc);
return false;
}
if (isValid(doc) > 0) {
tDebug() << "Written document is valid";
} else {
tError() << "Written document is invalid";
xmlFreeDoc(doc);
return false;
}
xmlFreeDoc(doc);
return true;
}
ResultWriter::~ResultWriter() {
if(writer_ != nullptr){
// free the writer
xmlFreeTextWriter(writer_);
}
xmlCleanupParser();
}
void DFSerializeXMLBuffer(DFDocument *doc, NamespaceID defaultNS, int indent, DFBuffer *buf)
{
xmlOutputBufferPtr output = xmlOutputBufferCreateIO(StringBufferWrite,
StringBufferClose,
buf,
NULL);
xmlTextWriterPtr writer = xmlNewTextWriter(output);
int html = 0;
for (DFNode *child = doc->docNode->first; child != NULL; child = child->next) {
if (child->tag == HTML_HTML)
html = 1;
}
Serialization serialization;
bzero(&serialization,sizeof(serialization));
serialization.ic = iconv_open("UTF-8","UTF-16LE");
if (serialization.ic == ((iconv_t)-1)) {
fprintf(stderr,"FATAL: Can't open iconv descriptor\n");
abort();
}
serialization.writer = writer;
serialization.doc = doc;
serialization.defaultNS = defaultNS;
serialization.html = html;
serialization.indent = indent;
writeNode(&serialization,doc->docNode,0);
iconv_close(serialization.ic);
xmlFreeTextWriter(writer);
}
int generate_report(char dst_dir[DIR_LENGTH_MAX], char filename[FILENAME_LENGTH_MAX]) {
// for the xml writer, refer to http://xmlsoft.org/html/libxml-xmlwriter.html
char dst_file[FILENAME_LENGTH_MAX + DIR_LENGTH_MAX] = "";
strcat(dst_file, dst_dir);
strcat(dst_file, filename);
xmlTextWriterPtr writer;
writer = xmlNewTextWriterFilename(dst_file, 0);
// set the output format of the XML file
xmlTextWriterSetIndent(writer, 1);
xmlTextWriterSetIndentString(writer, " ");
xmlTextWriterStartDocument(writer, NULL, NULL, NULL);
/* Write an element named "X_ORDER_ID" as child of HEADER. */
xmlTextWriterWriteFormatElement(writer, "COMMENT ", " in this output file, %d means NOT_PROCESSED; %d means NO_FILE; %d means ERROR; %d means OK ", MODULE_NOT_PROCESSED, NO_FILE, MODULE_ERROR, MODULE_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_GET_OPT ", " %d ", get_opt_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_DETECT_FILE ", " %d ", detect_file_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_PARSE_FILENAME", " %d ", parse_filename_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_CREATE_DIR ", " %d ", create_dir_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_PARSE_XML ", " %d ", parse_XML_OK);
xmlTextWriterWriteFormatElement(writer, "OCG_SAVE_XML ", " %d ", save_XML_OK);
// xmlTextWriterWriteFormatElement(writer, "OCG_CALL_EMU ", " %d ", call_emu_OK);
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
LOG_I(OCG, "A report of OCG is generated in directory \"%s\"\n\n", dst_dir);
return MODULE_OK;
}
std::string XMLSchema::xml() const
{
xmlBuffer *b = xmlBufferCreate();
xmlTextWriterPtr w = xmlNewTextWriterMemory(b, 0);
xmlTextWriterSetIndent(w, 1);
xmlTextWriterStartDocument(w, NULL, "utf-8", NULL);
xmlTextWriterStartElementNS(w, (const xmlChar*)"pc",
(const xmlChar*)"PointCloudSchema", NULL);
xmlTextWriterWriteAttributeNS(w, (const xmlChar*) "xmlns",
(const xmlChar*)"pc", NULL,
(const xmlChar*)"http://pointcloud.org/schemas/PC/");
xmlTextWriterWriteAttributeNS(w, (const xmlChar*)"xmlns",
(const xmlChar*)"xsi", NULL,
(const xmlChar*)"http://www.w3.org/2001/XMLSchema-instance");
writeXml(w);
xmlTextWriterEndElement(w);
xmlTextWriterEndDocument(w);
std::string output((const char *)b->content, b->use);
xmlFreeTextWriter(w);
xmlBufferFree(b);
return output;
}
void XMLExporter::close()
{
//xmlTextWriterEndElement(m_writer);
xmlFreeTextWriter(m_writer);
xmlSaveFormatFileEnc(m_file.c_str(), m_doc, MY_ENCODING, 1);
xmlCleanupParser();
xmlMemoryDump();
}
static void cleanupSBOLWriter() {
xmlFreeTextWriter(WRITER);
xmlFreeDoc(OUTPUT);
WRITER = NULL;
OUTPUT = NULL;
deletePointerArray(PROCESSED);
PROCESSED = NULL;
xmlCleanupParser();
}
~LibXmlStuff() {
if (xpath_context)
xmlXPathFreeContext(xpath_context);
if (reader)
xmlFreeTextReader(reader);
if (writer)
xmlFreeTextWriter(writer);
}
static void writexml(const char *name)
{
mode = 'w';
writer = xmlNewTextWriterFilename(name, 0);
xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);
startnode("root");
all_decl();
endnode();
xmlFreeTextWriter(writer);
}
cpXmlCmdOutput::~cpXmlCmdOutput()
{
/* Here we could close open elements but since we do not want to
* write any other elements, we simply call xmlTextWriterEndDocument,
* which will do all the work */
if ( xmlTextWriterEndDocument( writer ) < 0 )
throw ::std::runtime_error( "Error ending to the output document" );
xmlFreeTextWriter( writer );
}
void Free_Writer(CXMLWRITER *test)
{
if (test->writer)
{
xmlTextWriterEndDocument(test->writer);
xmlFreeTextWriter(test->writer);
test->writer=NULL;
}
if (test->buffer) xmlBufferFree(test->buffer);
test->buffer=NULL;
}
c_XMLWriter::~c_XMLWriter() {
if (m_ptr) {
xmlFreeTextWriter(m_ptr);
}
if (m_output) {
xmlBufferFree(m_output);
}
if (m_uri_output) {
xmlOutputBufferClose(m_uri_output);
}
}
//----------------------------------------------------------------------------
// Finished a file and saves it
//----------------------------------------------------------------------------
void CXMLTreeNode::EndNewFile ()
{
assert(m_pWriter && m_pDoc && m_pszFileName);
if (m_pWriter && m_pDoc && m_pszFileName)
{
xmlFreeTextWriter(m_pWriter);
m_pWriter = NULL;
xmlSaveFileEnc(m_pszFileName, m_pDoc, MY_ENCODING);
}
}
void XMLInOut::DeleteDoc(void)
{
if (writer)
xmlFreeTextWriter(writer);
if (buf)
xmlBufferFree(buf);
writer = NULL;
buf = NULL;
sections.clear();
}
/**
* @brief Saves all the star planets.
*
* @return 0 on success.
*/
int dpl_saveAll (void)
{
int i;
/*char file[PATH_MAX];*/
xmlDocPtr doc;
xmlTextWriterPtr writer;
int np;
const Planet *p;
const Planet **sorted_p;
/* Create the writer. */
writer = xmlNewTextWriterDoc(&doc, 0);
if (writer == NULL) {
WARN("testXmlwriterDoc: Error creating the xml writer");
return -1;
}
/* Set the writer parameters. */
xmlw_setParams( writer );
/* Start writer. */
xmlw_start(writer);
xmlw_startElem( writer, "Assets" );
/* Sort planets. */
p = planet_getAll( &np );
sorted_p = malloc( sizeof(Planet*) * np );
for (i=0; i<np; i++)
sorted_p[i] = &p[i];
qsort( sorted_p, np, sizeof(Planet*), dpl_compPlanet );
/* Write planets. */
for (i=0; i<np; i++)
dpl_savePlanet( writer, sorted_p[i] );
/* Clean up sorted planet.s */
free(sorted_p);
/* End writer. */
xmlw_endElem( writer ); /* "Assets" */
xmlw_done( writer );
/* No need for writer anymore. */
xmlFreeTextWriter( writer );
/* Write data. */
xmlSaveFileEnc( "asset.xml", doc, "UTF-8" );
/* Clean up. */
xmlFreeDoc(doc);
return 0;
}
// SAX save settings
short int settingsXmlSave(const char *filename) {
int rc;
xmlTextWriterPtr writer;
// Create a new XmlWriter with no compression
writer = xmlNewTextWriterFilename(filename, 0);
if (writer == NULL) return 1;
// Start document with xml default encoding ISO 8859-1
rc = xmlTextWriterStartDocument(writer, NULL, XML_ENCODING, NULL);
if (rc < 0) return 2;
// Start root node "settings"
rc = xmlTextWriterStartElement(writer, BAD_CAST "settings");
if (rc < 0) return 2;
// Create child node "xap"
rc = xmlTextWriterStartElement(writer, BAD_CAST "xap");
if (rc < 0) return 2;
// Write <xap> elements
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "iface", "%s", hubConfig->interfacename);
if (rc < 0) return 4;
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "instance", "%s", hubConfig->xap_addr.instance);
if (rc < 0) return 4;
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "hbeatf", "%d", hubConfig->xap_hbeat);
if (rc < 0) return 4;
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "uid", "%s", hubConfig->xap_uid);
if (rc < 0) return 4;
rc = xmlTextWriterWriteFormatElement(writer, BAD_CAST "port", "%d", hubConfig->xap_port);
if (rc < 0) return 4;
// Close node "xap"
rc = xmlTextWriterEndElement(writer);
if (rc < 0) return 5;
// Close the rest nodes pending to close
rc = xmlTextWriterEndDocument(writer);
if (rc < 0) return 5;
// Free the writer
xmlFreeTextWriter(writer);
// Cleanup function for the XML library.
xmlCleanupParser();
// this is to debug memory for regression tests
xmlMemoryDump();
return 0;
}
XMLConversion::~XMLConversion()
{
if(_reader) {
xmlFreeTextReader(_reader);
_reader = NULL;
}
if(_writer) {
// xmlTextWriterEndDocument(_writer); //if hasn't been called ealier
xmlFreeTextWriter(_writer);// was crashing
_writer = NULL;
}
//xmlBufferFree(_buf);
}
/**
* @short Prepares the response for propfinds
*
* @param realpath Shared folder
* @param urlpath URL of the requested propfind
* @param depth Depth of query, 0 or 1.
* @param props Properties of the query
*
* @returns An onion_block with the XML data.
*/
onion_block *onion_webdav_write_propfind(const char *basepath, const char *realpath, const char *urlpath, int depth,
int props){
onion_block *data=onion_block_new();
xmlTextWriterPtr writer;
xmlBufferPtr buf;
buf = xmlBufferCreate();
if (buf == NULL) {
ONION_ERROR("testXmlwriterMemory: Error creating the xml buffer");
return data;
}
writer = xmlNewTextWriterMemory(buf, 0);
if (writer == NULL) {
ONION_ERROR("testXmlwriterMemory: Error creating the xml writer");
return data;
}
int error;
xmlTextWriterStartDocument(writer, NULL, "utf-8", NULL);
xmlTextWriterStartElement(writer, BAD_CAST "D:multistatus");
xmlTextWriterWriteAttribute(writer, BAD_CAST "xmlns:D" ,BAD_CAST "DAV:");
error=onion_webdav_write_props(writer, basepath, realpath, urlpath, NULL, props);
if (depth>0){
ONION_DEBUG("Get also all files");
DIR *dir=opendir(realpath);
if (!dir){
ONION_ERROR("Error opening dir %s to check files on it", realpath);
}
else{
struct dirent *de;
while ( (de=readdir(dir)) ){
if (de->d_name[0]!='.')
onion_webdav_write_props(writer, basepath, realpath, urlpath, de->d_name, props);
}
closedir(dir);
}
}
xmlTextWriterEndElement(writer);
xmlTextWriterEndElement(writer);
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
onion_block_add_str(data, (const char*)buf->content);
xmlBufferFree(buf);
if (error){
onion_block_free(data);
return NULL;
}
return data;
}
void temporal_convert_parallel_passages()
// This was used to convert file NT_order_of_OT_Quotations_in_NT.pps to xml.
// Then for converting NT_Parallel_Passages.pps.
// Then for converting OT_Parallel_Passages.pps.
{
bool set_opened = false;
xmlBufferPtr buffer = xmlBufferCreate();
xmlTextWriterPtr writer = xmlNewTextWriterMemory(buffer, 0);
xmlTextWriterStartDocument(writer, NULL, "UTF-8", NULL);
xmlTextWriterSetIndent(writer, 1);
xmlTextWriterStartElement(writer, BAD_CAST "ot-parallel-passages");
ReadText rt("/home/joe/parallel-passages/OT_Parallel_Passages.pps", true);
for (unsigned int i = 0; i < rt.lines.size(); i++) {
if (rt.lines[i].find("\\key ") == 0) {
rt.lines[i].erase(0, 5);
xmlTextWriterStartElement(writer, BAD_CAST "section");
xmlTextWriterWriteAttribute(writer, BAD_CAST "title", BAD_CAST rt.lines[i].c_str());
}
if (rt.lines[i].find("\\ref ") == 0) {
if (!set_opened) {
xmlTextWriterStartElement(writer, BAD_CAST "set");
set_opened = true;
}
xmlTextWriterStartElement(writer, BAD_CAST "reference");
rt.lines[i].erase(0, 5);
ustring book, chapter, verse;
decode_reference(rt.lines[i], book, chapter, verse);
book = books_id_to_english(books_paratext_to_id(book));
xmlTextWriterWriteAttribute(writer, BAD_CAST "book", BAD_CAST book.c_str());
xmlTextWriterWriteAttribute(writer, BAD_CAST "chapter", BAD_CAST chapter.c_str());
xmlTextWriterWriteAttribute(writer, BAD_CAST "verse", BAD_CAST verse.c_str());
xmlTextWriterEndElement(writer);
}
if (rt.lines[i].empty() || (rt.lines[i].find("\\com") == 0)) {
xmlTextWriterEndElement(writer);
set_opened = false;
}
if (rt.lines[i].empty()) {
xmlTextWriterEndElement(writer);
}
}
xmlTextWriterEndDocument(writer);
xmlTextWriterFlush(writer);
g_file_set_contents("/home/joe/ot-parallel-passages.xml", (const gchar *)buffer->content, -1, NULL);
if (writer)
xmlFreeTextWriter(writer);
if (buffer)
xmlBufferFree(buffer);
}
/**
* xml_writer_clear:
* @writer: A #XmlWriter
*
* Clears the current state of the #XmlWriter. This allows you
* to reuse the same writer for multiple files or buffers.
*/
void
xml_writer_clear (XmlWriter *writer)
{
XmlWriterPrivate *priv;
g_return_if_fail (XML_IS_WRITER (writer));
priv = writer->priv;
if (priv->writer)
xmlFreeTextWriter (priv->writer);
priv->writer = NULL;
}
int save_gpx(const char *fname,GList *save_list)
{
time_t t=time(NULL);
struct tm tm;
GList *l;
xmlTextWriterPtr writer;
writer=xmlNewTextWriterFilename(fname,0);
if (!writer)
return 0;
xmlTextWriterStartDocument(writer,NULL,"UTF-8",NULL);
xmlTextWriterStartElement(writer,(xmlChar *)"gpx");
xmlTextWriterWriteAttribute(writer,(xmlChar *)"version",(xmlChar *)"1.0");
xmlTextWriterWriteAttribute(writer,(xmlChar *)"creator",(xmlChar *)PACKAGE " " VERSION);
xmlTextWriterWriteAttribute(writer,(xmlChar *)"xmlns:xsi",(xmlChar *)"http://www.w3.org/2001/XMLSchema-instance");
xmlTextWriterWriteAttribute(writer,(xmlChar *)"xmlns",
(xmlChar *)"http://www.topografix.com/GPX/1/0");
xmlTextWriterWriteAttribute(writer,(xmlChar *)"xsi:schemaLocation",(xmlChar *)"http://www.topografix.com/GPX/1/0 http://www.topografix.com/GPX/1/0/gpx.xsd");
tm=*gmtime(&t);
xmlTextWriterWriteFormatElement(writer,(xmlChar *)"time","%04d-%02d-%02dT%02d:%02d:%02d",
tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,
tm.tm_hour,tm.tm_min,tm.tm_sec);
xmlTextWriterStartElement(writer,(xmlChar *)"trk");
xmlTextWriterStartElement(writer,(xmlChar *)"trkseg");
for(l=g_list_first(save_list);l;l=g_list_next(l)) {
struct t_punkt32 *p=(struct t_punkt32 *)l->data;
xmlTextWriterStartElement(writer,(xmlChar *)"trkpt");
xmlTextWriterWriteFormatAttribute(writer,(xmlChar *)"lat","%f",
p->latt);
xmlTextWriterWriteFormatAttribute(writer,(xmlChar *)"lon","%f",
p->longg);
if (p->time) {
t=p->time;
tm=*gmtime(&t);
xmlTextWriterWriteFormatElement(writer,(xmlChar*)"time",
"%04d-%02d-%02dT%02d:%02d:%02d",
tm.tm_year+1900,tm.tm_mon+1,tm.tm_mday,
tm.tm_hour,tm.tm_min,tm.tm_sec);
}
if (p->speed>0)
xmlTextWriterWriteFormatElement(writer,(xmlChar *)"speed","%f",p->speed*1.852/3.6);
xmlTextWriterEndElement(writer); /* /trkpt */
}
xmlTextWriterEndElement(writer); /*trkseg */
xmlTextWriterEndElement(writer); /* trk */
xmlTextWriterEndElement(writer); /* gpx */
xmlTextWriterEndDocument(writer);
xmlFreeTextWriter(writer);
return 1;
}
static int _exml_write(EXML *xml, xmlTextWriterPtr writer)
{
xmlTextWriterSetIndent( writer, 1 );
xmlTextWriterSetIndentString( writer, (xmlChar *) "\t" );
xmlTextWriterStartDocument( writer, NULL, NULL, NULL );
/* as of now, we do not write a DTD. This will be in effect with a new
* set of functions designed to manipulate the DTD, as well as added
* capability for reading DTDs from orthogonal read sources */
_exml_write_element(xml->top, writer);
xmlTextWriterEndDocument( writer );
xmlFreeTextWriter( writer );
return TRUE;
}
/**
Writes the report footer to Xml file..
Write the xml end doc info..
Release the writer pointer from the buffer.
Writes the buffer content to xml file.
Frees the xml buffer.
@internalComponent
@released
*/
void XmlWriter::EndReport(void)
{
xmlTextWriterEndElement(iXmlTextWriter);
xmlTextWriterEndElement(iXmlTextWriter);
xmlTextWriterEndDocument(iXmlTextWriter);
xmlFreeTextWriter(iXmlTextWriter);
iXmlFile.clear();
iXmlFile.write((const char *)iXmlBufPtr->content,iXmlBufPtr->use);
if(iXmlFile.fail()){
xmlBufferFree(iXmlBufPtr);
throw ExceptionReporter(NODISKSPACE, (char*)iXmlFileName.c_str());
}
xmlBufferFree(iXmlBufPtr);
}
void c_XMLWriter::sweep() {
if (m_ptr) {
assert(m_ptr != xmlTextWriterPtr(-1));
xmlFreeTextWriter(m_ptr);
if (debug) {
m_ptr = xmlTextWriterPtr(-1);
}
}
if (m_output) {
assert(m_output != xmlBufferPtr(-1));
xmlBufferFree(m_output);
if (debug) {
m_output = xmlBufferPtr(-1);
}
}
}
daeInt daeLIBXMLPlugin::write(daeURI *name, daeDocument *document, daeBool replace)
{
// Make sure database and document are both set
if (!database)
return DAE_ERR_INVALID_CALL;
if(!document)
return DAE_ERR_COLLECTION_DOES_NOT_EXIST;
// Extract just the file path from the URI
daeFixedName finalname;
if (!name->getPath(finalname,sizeof(finalname)))
{
printf( "can't get path in write\n" );
return DAE_ERR_BACKEND_IO;
}
// If replace=false, don't replace existing files
if(!replace)
{
// Using "stat" would be better, but it's not available on all platforms
FILE *tempfd = fopen(finalname,"r");
if(tempfd != NULL)
{
// File exists, return error
fclose(tempfd);
return DAE_ERR_BACKEND_FILE_EXISTS;
}
}
// Open the file we will write to
writer = xmlNewTextWriterFilename(name->getURI(), 0);
if ( !writer ) {
printf( "no libxml2 writer\n" );
return DAE_ERR_BACKEND_IO;
}
xmlChar indentString[10] = " ";
xmlTextWriterSetIndentString( writer, indentString );
xmlTextWriterSetIndent( writer, 1 );
xmlTextWriterStartDocument( writer, NULL, NULL, NULL );
writeElement( document->getDomRoot() );
xmlTextWriterEndDocument( writer );
xmlTextWriterFlush( writer );
xmlFreeTextWriter( writer );
return DAE_OK;
}
xml_writer::~xml_writer() throw() {
// close and flush the xml writer object. note - if this fails then
// there isn't much we can do, as this object is going to be deleted
// anyway.
try {
xmlTextWriterEndDocument(pimpl->writer);
} catch (...) {
// don't do anything here or we risk FUBARing the entire program.
// it might not be possible to end the document because the output
// stream went away. if so, then there is nothing to do but try
// and reclaim the extra memory.
}
xmlFreeTextWriter(pimpl->writer);
// finally, delete the PIMPL object
delete pimpl;
}
