XMLFileCatalog.cpp File Reference

#include "xercesc/framework/LocalFileFormatTarget.hpp"
#include "xercesc/framework/MemBufInputSource.hpp"
#include "xercesc/sax/SAXParseException.hpp"
#include "xercesc/sax/EntityResolver.hpp"
#include "xercesc/sax/InputSource.hpp"
#include "xercesc/parsers/XercesDOMParser.hpp"
#include "xercesc/util/PlatformUtils.hpp"
#include "xercesc/util/XercesDefs.hpp"
#include "xercesc/util/XMLUni.hpp"
#include "xercesc/util/XMLURL.hpp"
#include "xercesc/util/XMLString.hpp"
#include "xercesc/dom/DOM.hpp"
#include "GaudiKernel/MsgStream.h"
#include "GaudiKernel/Service.h"
#include "Reflex/PluginService.h"
#include "XMLFileCatalog.h"
#include <fstream>
#include <iostream>
#include <stdexcept>
#include <sys/types.h>
#include <sys/stat.h>
#include "uuid/uuid.h"

Include dependency graph for XMLFileCatalog.cpp:

Go to the source code of this file.

Classes
class	FCFactory< T >
Functions
	PLUGINSVC_FACTORY (XMLFileCatalog, IInterface *(std::string, IMessageSvc *)) namespace
std::string	Gaudi::createGuidAsString ()
	Create file identifier using UUID mechanism.

---

Function Documentation

PLUGINSVC_FACTORY	(	XMLFileCatalog	,
		IInterface *	std::string, IMessageSvc *
	)

Reference to catalog object

Constructor

Reset errors (Noop)

Warnings callback. Ignore them

Error handler

Fatal error handler

Definition at line 45 of file XMLFileCatalog.cpp.

          {
  typedef const string& CSTR;
  inline string _toString(const XMLCh *toTranscode)  {
    char * buff = XMLString::transcode(toTranscode);
    string tmp(buff==0 ? "" : buff);
    XMLString::release(&buff);
    return tmp;
  }
  struct __Init  {
    __Init() { 
      try { XMLPlatformUtils::Initialize();      }
      catch (const XMLException& e)   {
        cout << "Xerces-c error in initialization:" << _toString(e.getMessage()) << endl;
      }
    }
    ~__Init() {
      XMLPlatformUtils::Terminate(); 
    }
  };
  __Init __In__;

  struct XMLStr  {
    XMLCh* m_xml;
    XMLStr(CSTR c)                { m_xml=XMLString::transcode(c.c_str());  }
    ~XMLStr()                     { if (m_xml) XMLString::release(&m_xml);  }
    operator const XMLCh*() const { return m_xml;                           }
  };
  struct XMLTag : public XMLStr {
    string m_str;
    XMLTag(CSTR s) : XMLStr(s), m_str(s) {  }
    ~XMLTag()                            {  }
    operator CSTR () const  { return m_str; }
  };
  bool operator==(const XMLTag& b, CSTR c) {  return c==b.m_str; }
  bool operator==(CSTR c, const XMLTag& b) {  return c==b.m_str; }
  struct XMLCollection  {
    DOMElement* m_node;
    XMLCollection(DOMNode* n, bool use_children=true) : m_node((DOMElement*)n) {
      if ( use_children )  {
        if ( m_node ) m_node = (DOMElement*)m_node->getFirstChild();
        if ( m_node && m_node->getNodeType() != DOMNode::ELEMENT_NODE ) ++(*this);
      }
    }
    operator bool()  const                { return 0 != m_node;                         }
    operator DOMNode* () const            { return m_node;                              }
    operator DOMElement* () const         { return m_node;                              }
    DOMElement* operator->() const        { return m_node;                              }
    string attr(const XMLTag& tag) const  { return _toString(m_node->getAttribute(tag));}
    string attr(CSTR tag)  const          { return attr(XMLTag(tag));                   }
    string tag() const                    { return _toString(m_node->getTagName());     }
    void operator++()   {
      while(m_node)  {
        m_node = (DOMElement*)m_node->getNextSibling();
        if ( m_node && m_node->getNodeType() == DOMNode::ELEMENT_NODE ) {
          return;
        }
      }
    }
  };
  struct ErrHandler : public ErrorHandler    {
    IMessageSvc* m_msg;
    ErrHandler(IMessageSvc* m) : m_msg(m) {}
    void resetErrors()                          {      }
    void warning(const SAXParseException& /* e */)    {     }
    void error(const SAXParseException& e);
    void fatalError(const SAXParseException& e);
  };
  struct DTDRedirect : public EntityResolver  {
    InputSource* resolveEntity(const XMLCh* const /* pubId */, const XMLCh* const /* sysId */)  {
      static const char* dtdID = "redirectinmem.dtd";
      static const char* dtd = \
        "\
        <!ELEMENT POOLFILECATALOG (META*,File*)>\
        <!ELEMENT META EMPTY>\
        <!ELEMENT File (physical,logical,metadata*)>\
        <!ATTLIST META name CDATA #REQUIRED>\
        <!ATTLIST META type CDATA #REQUIRED>\
        <!ELEMENT physical (pfn)+>\
        <!ELEMENT logical (lfn)*>\
        <!ELEMENT metadata EMPTY>\
        <!ELEMENT lfn EMPTY>\
        <!ELEMENT pfn EMPTY>\
        <!ATTLIST File ID ID  #REQUIRED>\
        <!ATTLIST pfn name ID #REQUIRED>\
        <!ATTLIST pfn filetype CDATA #IMPLIED>\
        <!ATTLIST lfn name ID #REQUIRED>\
        <!ATTLIST metadata att_name  CDATA #REQUIRED>\
        <!ATTLIST metadata att_value CDATA #REQUIRED>\
        ";
      static const size_t len = strlen(dtd);
      return new MemBufInputSource((const XMLByte*)dtd,len,dtdID,false);
    }
  };

  void ErrHandler::error(const SAXParseException& e)  {
    string m(_toString(e.getMessage()));
    if (m.find("The values for attribute 'name' must be names or name tokens")!=string::npos ||
      m.find("The values for attribute 'ID' must be names or name tokens")!=string::npos   ||
      m.find("for attribute 'name' must be Name or Nmtoken")!=string::npos                 ||
      m.find("for attribute 'ID' must be Name or Nmtoken")!=string::npos      )
      return;
    string sys(_toString(e.getSystemId()));
    MsgStream log(m_msg,"XMLCatalog");
    log << MSG::ERROR << "Error at file \""  << sys
      << "\", line " << e.getLineNumber() << ", column " << e.getColumnNumber() << endmsg
      << "Message: " << m << endmsg;
  }
  void ErrHandler::fatalError(const SAXParseException& e)  {
    MsgStream log(m_msg,"XMLCatalog");
    string m(_toString(e.getMessage()));
    string sys(_toString(e.getSystemId()));
    log << MSG::ERROR << "Fatal Error at file \"" << sys
      << "\", line " << e.getLineNumber() << ", column " << e.getColumnNumber() << endmsg
      << "Message: " << m << endmsg;
    throw runtime_error( "Standard pool exception : Fatal Error on the DOM Parser" );
  }

  const XMLTag EmptyCatalog("<!-- Edited By POOL -->\n"
                              "<!DOCTYPE POOLFILECATALOG SYSTEM \"InMemory\">\n"
                              "<POOLFILECATALOG>\n"
                              "</POOLFILECATALOG>\n");
  const XMLTag PFNCOLL         ("physical");
  const XMLTag LFNCOLL         ("logical");
  const XMLTag PFNNODE         ( "pfn");
  const XMLTag LFNNODE         ( "lfn");
  const XMLTag Attr_type       ( "type");
  const XMLTag Attr_ID         ( "ID");
  const XMLTag Attr_name       ( "name");
  const XMLTag Attr_ftype      ( "filetype");
  const XMLTag MetaNode        ( "metadata");
  const XMLTag Attr_metaName   ( "att_name");
  const XMLTag Attr_metaValue  ( "att_value");
}