xml-copy-editor-code/src/housestylewriter.cpp

#include <set>
#include <string>
#include <vector>
#include <stdexcept>
#include <expat.h>
#include "housestylewriter.h"
#include "contexthandler.h"

using namespace std;

HouseStyleWriter::HouseStyleWriter ( vector<ContextMatch> &v ) :
        hswd ( new HouseStyleWriterData() )
{
    set<size_t> elementSet;
    size_t vectorsize = v.size();
    for ( size_t i = 0; i < vectorsize; ++i )
        elementSet.insert ( v[i].elementCount );

    hswd->setState ( STATE_UNKNOWN );
    hswd->v = v;
    hswd->elementSet = elementSet;

    XML_SetUserData ( p, hswd.get() );
    XML_SetElementHandler ( p, start, end );
    XML_SetCharacterDataHandler ( p, characterdata );
    XML_SetXmlDeclHandler ( p, xmldecl );
    XML_SetCdataSectionHandler ( p, cdatastart, cdataend );
    XML_SetDefaultHandler ( p, defaulthandler );
}

HouseStyleWriter::~HouseStyleWriter()
{}

string HouseStyleWriter::getOutput()
{
    return hswd->output;
}

void XMLCALL HouseStyleWriter::start ( void *data, const XML_Char *el, const XML_Char **attr )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->setState ( STATE_ON_START );

    if ( hswd->textnode.size() )
    {
        if ( hswd->elementSet.count ( hswd->getCount() ) )
            modify ( hswd->v, hswd->textnode, hswd->getCount() );
        hswd->output += xmliseTextNode ( hswd->textnode );
        hswd->textnode = "";
    }

    hswd->output += '<';
    hswd->output += el;
    for ( ; *attr; attr += 2 )
    {
        hswd->output += ' ';
        hswd->output += *attr;
        hswd->output += "=\"";
        hswd->output += xmliseAttribute ( * ( attr + 1 ) );
        hswd->output += '"';
    }
    hswd->output += '>';
}

void XMLCALL HouseStyleWriter::end ( void *data, const XML_Char *el )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    //++(hswd->elementCount);
    hswd->setState ( STATE_ON_END );

    if ( hswd->textnode.size() )
    {
        if ( hswd->elementSet.count ( hswd->getCount() ) )
            modify ( hswd->v, hswd->textnode, hswd->getCount() );
        hswd->output += xmliseTextNode ( hswd->textnode );
        hswd->textnode = "";
    }
    hswd->output += "</";
    hswd->output += el;
    hswd->output += '>';
}

void XMLCALL HouseStyleWriter::characterdata ( void *data, const XML_Char *s, int len )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->textnode.append ( s, len );
}

void XMLCALL HouseStyleWriter::xmldecl (
    void *data,
    const XML_Char *version,
    const XML_Char *encoding,
    int standalone )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->output += "<?xml version=\"";
    hswd->output += version;
    hswd->output += "\" encoding=\"UTF-8\"";
    if ( standalone != -1 )
    {
        hswd->output += " standalone=\"";
        hswd->output += ( standalone ) ? "yes" : "no";
        hswd->output += "\"";
    }
    hswd->output += "?>";
}

void XMLCALL HouseStyleWriter::cdatastart ( void *data )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->setState ( STATE_ON_CDATA_START );

    if ( hswd->textnode.size() )
    {
        if ( hswd->elementSet.count ( hswd->getCount() ) )
            modify ( hswd->v, hswd->textnode, hswd->getCount() );
        hswd->output += hswd->textnode;
        hswd->textnode = "";
    }

    hswd->output += "<![CDATA[";
}

void XMLCALL HouseStyleWriter::cdataend ( void *data )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->setState ( STATE_ON_CDATA_END );

    if ( hswd->textnode.size() )
    {
        if ( hswd->elementSet.count ( hswd->getCount() ) )
            modify ( hswd->v, hswd->textnode, hswd->getCount() );
        hswd->output += hswd->textnode;
        hswd->textnode = "";
    }

    hswd->output += "]]>";
}

void XMLCALL HouseStyleWriter::defaulthandler (
    void *data,
    const XML_Char *s,
    int len )
{
    HouseStyleWriterData *hswd;
    hswd = ( HouseStyleWriterData * ) data;
    hswd->output.append ( s, len );
}

void HouseStyleWriter::modify (
    vector<ContextMatch> &v,
    string &buffer,
    unsigned elementCount )
{
    int vectorsize, os_adjust, exclusion;
    vectorsize = v.size();
    os_adjust = exclusion = 0;
    string cmp1, cmp2;

    for ( int i = 0; i < vectorsize; ++i )
    {
        unsigned vectorElementCount = v[i].elementCount;
        if ( vectorElementCount < elementCount )
            continue;
        else if ( vectorElementCount > elementCount )
            break;
        else if ( vectorElementCount == elementCount )
        {
            int offset = ( int ) v[i].offset + os_adjust;

            if ( offset < exclusion )
                continue;

            // check match is as expected
            try
            {
                cmp1 = v[i].match;
                cmp2 = buffer.substr ( offset, v[i].match.size() );
            }
            catch ( std::exception& e )
            {
                continue;
            }

            if ( cmp1.compare ( cmp2 ) )
                continue;

            buffer.replace ( offset, v[i].match.size(), v[i].replace.c_str() );

            os_adjust += v[i].replace.size() - v[i].match.size();
            exclusion = offset + v[i].replace.size();
        }
    }
}