xerces-c-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Bovy, Stephen J" <STEPHEN.B...@ca.com>
Subject RE: DOMWriter Questions
Date Wed, 07 Apr 2004 19:54:35 GMT
 

-----Original Message-----
From: Gareth Reakes [mailto:parthenon@sphinx.mythic-beasts.com] On
Behalf Of Gareth Reakes
Sent: Wednesday, April 07, 2004 12:17 PM
To: xerces-c-dev@xml.apache.org
Subject: Re: DOMWriter Questions

Hi,

> DOMImplementation *impl =
> DOMImplementationRegistry::getDOMImplementation(XMLString::transcode("
> Core"));

It specifies a specific implementation to use. For example Core or
Load/Save. Take a look at the specs a tutorial or the docs for more info

http://xml.apache.org/xerces-c/apiDocs/classDOMImplementationRegistry.ht
ml

>
> 2. What does XMLString::transcode("...") do, and why is it needed?

>>It converts from a string to the internal xerces format which supports
UTF16. Again, 
>>take a look at the docs for more info

Actually I think it is just the opposite In one of the samples there is
a StrX
class as follows:

// ---------------------------------------------------------------     
// This is a simple class that lets us do easy (though not terribly    
// efficient) trancoding of XMLCh data to local code page for display. 
// ---------------------------------------------------------------     
class StrX                                                             

I have modifed that sample class as follows:

// ---------------------------------------------------------------     
// This is a simple class that lets us do easy (though not terribly    
// efficient) trancoding of XMLCh data to local code page for display. 
// ---------------------------------------------------------------     
class StrX                                                             
{                                                                      
public :                                                               
    // -----------------------------------------------------------     
    //  Constructors and Destructor                                    
    // -----------------------------------------------------------     
    StrX ( ) { fLocalForm = NULL; }                                    
                                                                       
    StrX ( const XMLCh* const toTranscode ) {                          
        // Call the private transcoding method                         
        fLocalForm = XMLString::transcode ( toTranscode );             
    }                                                                  
                                                                       
    ~StrX ( ) {                                                        
        if ( fLocalForm ) XMLString::release ( &fLocalForm );          
    } // endif destructor                                              
                                                                       
    operator= ( const XMLCh* const toTranscode ) {                     
        if ( fLocalForm ) release ( );                                 
        // Call the private transcoding method                         
        fLocalForm = XMLString::transcode(toTranscode);                
    } // endif operator assignment                                     
                                                                      
    release ( ) {                                                     
        XMLString::release ( &fLocalForm );                           
        fLocalForm = NULL;                                            
    }                                                                 
                                                                      
    // -----------------------------------------------------------    
    //  Getter methods                                                
    // -----------------------------------------------------------    
    const char* local ( ) const                                       
    {                                                                 
        return fLocalForm;                                            
    }                                                                 
                                                                      
private :                                                             
    // -----------------------------------------------------------    
    //  Private data members                                          
    //                                                                
    //  fLocalForm                                                    
    //  This is the local code page form of the string.               
    // -----------------------------------------------------------    
    char*   fLocalForm;                                               
                                                                      
};                                                                    

                                                                 
inline ostream& operator<<(ostream& target, const StrX& toDump)  
{                                                                
    target << toDump.local();                                    
    return target;                                               
}                                                                

So I can use the above class as follows, which again is copied from the
samples.

// ---------------------------------------------------------------     
//  DOMCountHandlers: Overrides of the DOM ErrorHandler interface      
// ---------------------------------------------------------------     
bool DOMCountErrorHandler::handleError ( const DOMError& domError )    
{                                                                      
                                                                       
    fSawErrors = true;                                                 
    /*                                                                 
    if ( domError.getSeverity() == DOMError::DOM_SEVERITY_WARNING )    
        cerr << "\nWarning at file ";                                  
    else if ( domError.getSeverity() == DOMError::DOM_SEVERITY_ERROR ) 
        cerr << "\nError at file ";                                    
    else                                                               
        cerr << "\nFatal Error at file ";                              
    */                                                                 
    cerr << StrX ( domError.getLocation()->getURI() )                  
         << ", line " << domError.getLocation()->getLineNumber()       
         << ", char " << domError.getLocation()->getColumnNumber()     
         << "\n  Message: " << StrX ( domError.getMessage() ) << endl; 
                                                                       
    return true;                                                       
                                                                       
} // end of dom error handler                                          
                                                                       
My mods also allow me to do this:

// --------------------------------------------------------     
//  Recursively Count up the total number of child Elements     
//  under the specified Node.                                   
// --------------------------------------------------------     
int walkDomChildren ( DOMNode *n, PHSCHEMA ss, int testFlag )   
{                                                               
                                                                
    DOMNode *child;                                             
    DOMNamedNodeMap * nnm;                                      
    int count = 0;                                              
    int i, j;                                                   
                                                                
    // translation decoder objects                              
    StrX element;                                               
    StrX atrName;                                               
    StrX atrValue;                                              
                                                                
    if ( n ) {                                                  
                                                                
      if ( n->getNodeType() == DOMNode::ELEMENT_NODE ) {        
                                                                
        if ( testFlag )                                         
          fprintf (stderr, "********** Element ******\n" );     
                                                                
        element = n->getLocalName(); // get localized version of name

                                                                       
        if ( testFlag )                                                
          fprintf ( stderr, "  LocalName: %s\n", element );            
                                                                       
        count ++;                                                      
                                                                       
      } // endif got an element                                        
                                                                       
      nnm = n->getAttributes();                                        
                                                                       
      if ( nnm != NULL ) {                                             
                                                                       
        j = nnm->getLength();                                          
                                                                       
        if ( j )                                                       
          if ( testFlag )                                              
            fprintf(stderr,  "******** attributes ********\n" );       
                                                                       
        for ( i = 0; i < j; i++ ) {                                    
                                                                       
           atrName = nnm->item(i)->getNodeName();  // get localized atr
name                    
           atrValue = nnm->item(i)->getNodeValue(); // get localized atr
value                   
                                                                       
           if ( testFlag )                                             
             fprintf ( stderr, "  %s =\"%s\"\n", atrName, atrValue );  
                                                                       
           analyseDomChild ( ss, (char*) element,                      
                             (char*) atrName, (char*) atrValue );   
                                                                    
        } // end atribute loop                                      
                                                                    
        delete nnm;                                                 
                                                                    
      } // endif list attributes                                    
      
      // free char * objects

      element.release();                                            
      atrName.release();                                            
      atrValue.release();                                           
                                                                    
      for ( child = n->getFirstChild(); child != 0;                 
            child = child->getNextSibling() ) {                     
                                                                    
          count += walkDomChildren ( child, ss, testFlag );         
                                                                    
      } // end recursive loop                                       
                                                                    
    } // endif got a valid node                                     
                                                                    
    return count;                                                   
                                                                    
} // end of count elements recursively                              
                                                              
int analyseDomChild ( PHSCHEMA ss, char * element,            
                      char * atrName, char * atrValue )       
{                                                             
                                                              
  if ( ! strcmp ( element, "schema" ) ) {                     
                                                              
    if ( ! strcmp ( atrName, "targetNamespace" ) )            
      strcpy ( ss->nameSpace, atrValue );                     
                                                              
    if ( ! strcmp ( atrName, "elementFormDefault" ) )         
      if ( ! strcmp ( atrValue, "qualified" ) )               
        ss->elemntQual = 1;                                   
                                                              
    if ( ! strcmp ( atrName, "attributeFormDefault" ) )       
      if ( ! strcmp ( atrValue, "qualified" ) )               
        ss->attribQual = 1;                                   
                                                              
  } // endif schema                                           
                                                              
  return 0;                                                   
                                                              
} // analyse dom child                                        

All the above code is compiled and working on an IBM z/OS system where
EBCDIC is 
the "native" code page.

But as noted by the sample comment warnings

// ---------------------------------------------------------------     
// This is a simple class that lets us do easy (though not terribly    
// efficient) trancoding of XMLCh data to local code page for display. 
// ---------------------------------------------------------------     

The above is probably not a very efficient method .  Because it probably

entails creating and destroying a transcoder on the fly for every
string.

I am just guessing.  (any one else care to weight in ??? )

http://xml.apache.org/xerces-c/apiDocs/classXMLString.html#z985_14


> 3. What is the advantage of creating your own XML document using the 
> Xerces CreateDocument API versus just encoding the XML string 
> manually?  I'm new to XML, and to be honest, I don't quite see the 
> advantage of creating your own document.  It seems much easier to 
> encode the string manually.  In both cases, you would need to know the

> structure of the tree.

If I follow you correctly here then I think you are suggesting just
building a string up that is XML. If this is the case then you would not
be able to call any of the methods that DOm supports on this string. It
would be hard to ensure the XML is well formed and very hard to
manipulate it.


Gareth

-- 
Gareth Reakes, Managing Director            +44-1865-811184
Parthenon Computing                http://www.parthcomp.com




---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-c-dev-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-c-dev-help@xml.apache.org



---------------------------------------------------------------------
To unsubscribe, e-mail: xerces-c-dev-unsubscribe@xml.apache.org
For additional commands, e-mail: xerces-c-dev-help@xml.apache.org


Mime
View raw message