msdSax2Parser.cc

//-----------------------------------------------------
//msdSax2Parser.cc
// 
// Project: PDBe API Framework 
// Module: Implementation of validation method for validating 
// a given xml / URL according to a given XML schema
// 
// Data Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//------------------------------------------------------

#include <iostream>
#include <xercesc/sax2/SAX2XMLReader.hpp>
#include <xercesc/sax2/XMLReaderFactory.hpp>
#include <xercesc/util/XMLString.hpp>
#include <xercesc/util/PlatformUtils.hpp>
#include <xercesc/util/Janitor.hpp>
#include <xercesc/framework/URLInputSource.hpp>
#ifndef __MSD_SAX_2_PARSER__
 #include "msdSax2Parser.h"
#endif
// Classes/data/variables must be namespace qualified since
// C++ Namespace support is ENABLED in Xerces.


using namespace std;
using namespace xercesc;


//  msdSax2Handler: Overrides of the SAX ErrorHandler interface
// ---------------------------------------------------------------------------
void msdSax2Handler::error(const SAXParseException& e)
{
  fSawErrors = true;
  errors << "[Error] " << XMLString::transcode(e.getSystemId())
         << ": line " << e.getLineNumber()
         << ", col " << e.getColumnNumber()
         << ": " << XMLString::transcode(e.getMessage()) << std::endl;
}
 
void msdSax2Handler::fatalError(const SAXParseException& e)
{
  fSawErrors = true;
  errors << "[Fatal Error] " << XMLString::transcode(e.getSystemId())
         << ": line " << e.getLineNumber()
         << ", col " << e.getColumnNumber()
         << ": " << XMLString::transcode(e.getMessage()) << std::endl;
}
 
void msdSax2Handler::warning(const SAXParseException& e)
{
  fSawErrors = true;
  errors << "[Warning] " << XMLString::transcode(e.getSystemId())
         << ": line " << e.getLineNumber()
         << ", col " << e.getColumnNumber()
         << ": " << XMLString::transcode(e.getMessage()) << std::endl;
}

const char* msdSax2Handler::getErrors()
{
  return errors.str().c_str();
}




const char* msdSax2Parser::validate(char* xmlFile) {

  std::ostringstream result;

  // Before any calls to Xerces-C++ APIs, we must initialize
  // the Xerces system and set its internal variables.
  try {
    XMLPlatformUtils::Initialize();
  }
  catch (const XMLException& toCatch) {
    // The message must be transcoded from XMLCh to the native code page.
    char* message = XMLString::transcode(toCatch.getMessage());
    result << "Error during initialization! :\n";
    result << "XMLException message is: \n"
         << message << "\n";
    // Release the parameter char string that was allocated.
    XMLString::release(&message);
    return result.str().c_str();
  }

  SAX2XMLReader* parser = XMLReaderFactory::createXMLReader();

  // The externalSchemaLocation string must be
  // transcoded to the native code page.
  XMLCh* externalSchemaLocation = XMLString::transcode("http://www.geodesy.org/river# River.xsd");

  // The ArrayJanitor template class provides auto_ptr-like functionality.
  ArrayJanitor<XMLCh> janValue(externalSchemaLocation);

  // Associates the schema grammar with the instance document using namespaces.
  // A secure validating parser MUST NOT rely on the schema location in the
  // instance document !
  parser->setProperty(XMLUni::fgXercesSchemaExternalSchemaLocation, externalSchemaLocation);

  // Reports all validation errors (not only well-formedness).
  parser->setFeature(XMLUni::fgSAX2CoreValidation, true);

  // Performs namespace processing.
  parser->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);

  // Performs schema processing.
  parser->setFeature(XMLUni::fgXercesSchema, true);

  // Checks the schema grammar itself for additional errors.
  parser->setFeature(XMLUni::fgXercesSchemaFullChecking, true);

  // Adds the errorHandler with customized error messages.
  msdSax2Handler* errorHandler = new msdSax2Handler();
  parser->setErrorHandler(errorHandler);

  try {
    //XMLURL xmlUrl(XMLString::transcode(xmlFile));
    //URLInputSource in(xmlUrl);
    //parser->parse(in);
        parser->parse(xmlFile);
    result << errorHandler->getErrors();
  }
  catch (const XMLException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    result << "XMLException message is: \n"
         << message << "\n";
    XMLString::release(&message);
    return result.str().c_str();
  }
  catch (const SAXParseException& toCatch) {
    char* message = XMLString::transcode(toCatch.getMessage());
    result << "SAXParseException message is: \n"
         << message << "\n";
    XMLString::release(&message);
    return result.str().c_str();
  }

  delete parser;
  delete errorHandler;
  return result.str().c_str();
}

---