LCD_DocManager.cc

Go to the documentation of this file.

// ----------------------------------------------------------------------------
// $Id: LCD_DocManager.cc,v 1.11 2004/02/02 22:12:48 uid561 Exp $
// ----------------------------------------------------------------------------
//
// LCD_DocManager.cxx
//
// Implementation file for the LCD classes supporting DOM:
//
//  LCD_DocumentImpl         implementation of above
//  LCD_DocManager           keeps track of all active LCD_Document's
//
// Other relevant classes have implementation, if any, in header file:
//  LCD_Document             largely virtual class describing interface
//  LCD_DocListener          entirely virtual
//
// Classes to handle the set of all XML documents known to a program
// (i.e., for which there are DOMs)

// There is a class LCD_DocumentImpl (should perhaps be an implementation of an
// interface) which acts as a small database describing a DOM.  There
// will be one instance per DOM.

// LCD_DocumentImpl has an enhanced set of query functions as compared to
// DOM_Document.  (Maybe I should change the name to LCD_Document.
// And maybe it should inherit from DOM_Document, except that,
// according to the DOM parser's documentation, the DOM_* classes
// cannot be subclassed.)

// There is another class (LCD_DocManager) which keeps track of all
// LCD_DocumentImpls.  There will be only one instance per program.

// The class LCD_DocListener just defines an interface for signing up
// to be notified of changes to a document.

#include "xercesc/util/PlatformUtils.hpp"
#include <algorithm>
//#include <strstream>
#include <list>
//#include <iterator>
#include <iostream>
using std::cout;

#include "LCD_DocManager.hh"
#include "LCD_Document.hh"
#include "LCD_DocErrorReporter.hh"
XERCES_CPP_NAMESPACE_USE

// LCD_DocManager methods, initialization
std::list <LCD_DocumentImpl*> *LCD_DocManager::active = 0;
bool                      LCD_DocManager::initDone = false;

/*
 *Comment
 */

int LCD_DocManager::deleteDocument(LCD_Document *pDoc) {
  // First check that we really were passed a LCD_DocumentImpl, not some other
  // class satisfying LCD_Document
  LCD_DocumentImpl *pDocImpl = dynamic_cast <LCD_DocumentImpl*>(pDoc);
  if ( pDocImpl ) {
    // see if we can find it among our list of docs
    std::list<LCD_DocumentImpl*>::iterator which;

    which = std::find(active->begin(), active->end(), pDocImpl);
    if (which != active->end()) {

      // delete it from list
      active->erase(which);

      // Actually get rid of it
      delete pDocImpl;
    }
    else {
      return 1;  // doc not found
    }
  }
  else {
    return 2;   // error code for bad arg.  Or throw an exception??
  }
  return 0;
}

// return list of LCD_DocumentImpls whose underlying document is of
// specified type (all if name is "*")



/*
 *Comment
 */
std::vector<LCD_Document*> *LCD_DocManager::getLCD_Documents(DOMString
                                                             docTypeName) {
  std::vector<LCD_Document*> *docs = new std::vector<LCD_Document*>;
  std::list<LCD_DocumentImpl*>::iterator docIt = active->begin();
  bool                        wild = ( docTypeName.equals(DOMString("*")) );

  while (docIt != active->end() ) {
    if ((wild) || (docTypeName.equals((*docIt)->getDocTypeName()) ) ) {
      docs->push_back(*docIt);
    }
    docIt++;
  }
  return docs;

}

// Look in all known documents of specified type to find element of
// specified type with  specified id.
// Return first one found (maybe should also somehow indicate which
// document it was found in??)


/*
 *Comment
 */
DOM_Element LCD_DocManager::getElement(DOMString id, DOMString elementName,
                                       DOMString docTypeName) {
  std::list<LCD_DocumentImpl*>::iterator docIt = active->begin();
  bool                           wild = (docTypeName.equals(DOMString("*")));

  while (docIt != active->end() ) {
    LCD_DocumentImpl* pDoc = *docIt;
    if ((wild) || (docTypeName.equals(pDoc->getDocTypeName()) )) {
      DOM_Element elt = pDoc->getElement(id, elementName);
      if (elt != 0) return elt;
    }
    docIt++;
  }
  return DOM_Element();
}


/*
 *Comment
 */
LCD_Document *LCD_DocManager::makeDocument(const std::string& XMLfilespec) {
  LCD_DocumentImpl *pNewDoc;

  //  if (!initDone) {
  if (active == 0) {
    // Initialize the XML4C2 system
    try
      {
        XMLPlatformUtils::Initialize();
        active = new std::list<LCD_DocumentImpl*>;
        initDone = true;
      }

    // Help! what to do if this fails?
    // This sort of failure is probably fatal
    catch (const XMLException& toCatch)
      {
        cout << "Error during xml4c platform initialization! :\n"
             << toCatch.getMessage() << "\n";
        return 0;
      }
  }

  pNewDoc = new LCD_DocumentImpl(XMLfilespec);

  try {
    pNewDoc->parse();

  }
  catch (const XMLException& toCatch2) {  // can't parse document
    // help.
    // This sort of failure is maybe recoverable
    cout << toCatch2.getMessage() << "\n";
    delete pNewDoc;
    return 0;
  }

  // Did we get any errors?  If so, can't use the document
  if ((pNewDoc->errReporter->getErrorCount()) ||
      (pNewDoc->errReporter->getFatalCount())    ) {
    cout << "Invalid XML source; cannot create document\n";
    delete pNewDoc;
    return 0;
  }

  active->push_front(pNewDoc);

  return pNewDoc;
}


/*
 *Comment
 */
LCD_Document *LCD_DocManager::getLCDDoc(DOM_Document domDoc) {
  std::list<LCD_DocumentImpl*>::iterator which = active->begin();

  while (which != active->end()) {
    if ( domDoc == (*which)->getDocument()) return *which;
    which++;
  }
  return 0;
}

---