haiku.git

/*
 * Copyright (c) 1999-2000, Eric Moon.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions, and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


// XML.cpp
// e.moon 1jul99

#include "XML.h"
#include "Importer.h"

#include <Autolock.h>
#include <Debug.h>

#include "array_delete.h"
#include "set_tools.h"

using namespace std;

__USE_CORTEX_NAMESPACE

// -------------------------------------------------------- //
// static members
// -------------------------------------------------------- //

XML::doc_type_map XML::s_docTypeMap;
BLocker XML::s_docTypeLock("XML::s_docTypeLock");

const BMimeType XML::DocumentType::s_defaultMimeType("text/xml");

// -------------------------------------------------------- //
// document type operations
// -------------------------------------------------------- //

// takes responsibility for the given type object

/*static*/
void XML::AddDocumentType(
	XML::DocumentType*					type) {
	
	ASSERT(type);
	BAutolock _l(s_docTypeLock);

//	s_docTypeMap.insert(
//		make_pair(type->rootElement, type));
	s_docTypeMap.insert(
		pair<const BString, XML::DocumentType*>(type->rootElement, type));
}
	
// -------------------------------------------------------- //
// import/export operations
// -------------------------------------------------------- //

// identify object in stream
// returns:
// - B_OK on success, or
// - B_BAD_TYPE if no document type matches the root
//   element of the stream, or 
// - B_IO_ERROR if the document is malformed, or if a
//   read error occurs.

/*static*/
status_t XML::Identify(
	BDataIO*										stream,
	DocumentType**							outType,
	list<BString>*							outErrors) {

	ASSERT(stream);
	
	// prepare the input buffer
	const uint32 bufferSize = 4096;
	char* buffer = new char[bufferSize];
	array_delete<char> _d(buffer);

	// prepare an Importer to figure document type (from first element)
	Importer i(*outErrors);
	i.setIdentifyMode();
		
	while(
		i.context().state() == ImportContext::PARSING) {

		// read chunk (no 0 terminator)
		ssize_t readCount = stream->Read(buffer, bufferSize);
		if(readCount == 0)
			 // done
			break;
		else if(readCount < 0) {
			// error
			BString err = "Read error: '";
			err << strerror(readCount) << "'; ABORTING.";
			outErrors->push_back(err);

			return B_IO_ERROR;
		}
		
		// feed to parser
		if(!i.parseBuffer(
			buffer, readCount, !stream)) {
			break;
		}
	}

	// return found type	
	if(i.docType()) {
		*outType = i.docType();
		return B_OK;
	}
	else return B_BAD_TYPE;
}

// read the root object from the given stream

/*static*/
status_t XML::Read(
	BDataIO*										stream,
	IPersistent**								outObject,
	list<BString>*							outErrors) {

	Importer i(*outErrors);
	status_t err = _DoRead(stream, i, outErrors);
	if(err == B_OK) {
		// return completed object
		ASSERT(i.target());
		*outObject = i.target();
	}
	return err;
}

/*static*/
status_t XML::Read(
	BDataIO*										stream,
	IPersistent**								outObject,
	ImportContext*							context) {

	Importer i(context);
	status_t err = _DoRead(stream, i, &context->errors());
	if(err == B_OK) {
		// return completed object
		ASSERT(i.target());
		*outObject = i.target();
	}
	return err;
}

// [e.moon 26nov99]
// populate the provided root object from the given
// XML stream.  you need to give the expected root
// (document) element name corresponding to the
// item you provide.
// returns:
// - B_OK on success, or
// - B_IO_ERROR if the document is malformed, or if a
//   read error occurs, or
// - B_ERROR

/*static*/
status_t XML::Read(
	BDataIO*										stream,
	IPersistent*								rootObject,
	XML::DocumentType*					documentType,
	list<BString>*							outErrors) {

	Importer i(*outErrors, rootObject, documentType);
	return _DoRead(stream, i, outErrors);
}

/*static*/
status_t XML::Read(
	BDataIO*										stream,
	IPersistent*								rootObject,
	XML::DocumentType*					documentType,
	ImportContext*							context) {

	Importer i(context, rootObject, documentType);
	return _DoRead(stream, i, &context->errors());
}

/*static*/
status_t XML::_DoRead(
	BDataIO*										stream,
	Importer&										i,
	list<BString>*							outErrors) {
	
	// prepare the input buffer
	const uint32 bufferSize = 4096;
	char* buffer = new char[bufferSize];
	array_delete<char> _d(buffer);

	while(
		i.context().state() == ImportContext::PARSING) {

		// read chunk (no 0 terminator)
		ssize_t readCount = stream->Read(buffer, bufferSize);
		if(readCount == 0)
			 // done
			break;
		else if(readCount < 0) {
			// error
			BString err = "Read error: '";
			err << strerror(readCount) << "'; ABORTING.";
			outErrors->push_back(err);
			return B_IO_ERROR;
		}
		
		// feed to parser
		if(!i.parseBuffer(
			buffer, readCount, !stream)) {
			break;
		}
	}

	status_t err = B_ERROR;
	if(i.context().state() == ImportContext::COMPLETE)
		err = B_OK;

	// clean up
	return err;
}

// write the given object to the given stream

/*static*/
status_t XML::Write(
	BDataIO*										stream,
	IPersistent*								object,
	BString*										outError) {

	ASSERT(object);
	
	ExportContext context(stream);
	status_t err = context.writeObject(object);
	if(err < B_OK)
		*outError = context.errorText();
	return err;
}

// -------------------------------------------------------- //
// XML::DocumentType
// -------------------------------------------------------- //

class _NullMapping : public XMLElementMapping {
public:
	_NullMapping(
		const char*									_element) :
		XMLElementMapping(_element) {}
	
	IPersistent* create() const { return 0; }
};

XML::DocumentType::~DocumentType() {
	// clean up
	ptr_set_delete(m_mappingSet.begin(), m_mappingSet.end());
}

XML::DocumentType::DocumentType(
	const char*									_rootElement,
	const char*									_mimeType) :
	rootElement(_rootElement),
	mimeType(_mimeType ? _mimeType : s_defaultMimeType.Type()) {}

// *** 'factory' interface

// The DocumentType takes ownership of the given mapping
// object.  If a mapping for the element already exists,
// the provided object is deleted and the method returns
// B_NAME_IN_USE.
status_t XML::DocumentType::addMapping(
	XMLElementMapping*					mapping) {

	pair<mapping_set::iterator, bool> ret =	m_mappingSet.insert(mapping);
	if(!ret.second) {
		delete mapping;
		return B_NAME_IN_USE;
	} else
		return B_OK;
}

IPersistent* XML::DocumentType::objectFor(
	const char*									element) {

	_NullMapping m(element);
	mapping_set::iterator it = m_mappingSet.find(&m);

	return (it != m_mappingSet.end()) ?
		(*it)->create() : 0;
}

// END -- XML.cpp --