Implementing IXmlWriter Part 7: Cleaning Up

This is part 7/14 of my Implementing IXmlWriter post series.

Wow, I can’t believe that it’s been over a month already since my last IXmlWriter post. I guess my vacation ruined my exercise plan and my blogging habits. It’s well past time to get back into both.

Rather than introduce a new test case, I’m going to spend today “cleaning up” the previous version of IXmlWriter.

The first cleanup method is trivial but overdue — I will separate the implementation of IXmlWriter from its interface, as a user of IXmlWriter shouldn’t be particularly concerned about its implementation. In other words, I will separate it into a .h and a .cpp file. For now, IXmlWriter will continue to expose some implementation details (e.g. its private members), but these details should change relatively infrequently. If I ever need to completely separate its implementation from its interface, I will consider making it into a COM-like object or using the Pimpl idiom.

Secondly, I will disable the default, compiler-created copy constructor and assignment operator. While they would work under the current implementation, there isn’t a unit test ensuring they will continue to work as I change the implementation. I’m also not exactly sure how useful these abilities are — why would someone want to copy an instance of IXmlWriter? Finally, imagine the confusion if a user accidentally declared a function to use an IXmlWriter rather than an IXmlWriter&. In general, I think it is best to disable a class’s copy constructor and assignment operator by default and enable them only as required.

Finally, and perhaps more controversially, I didn’t like that the definitions of the translations required for character data and attribute values were stored as member variables of the class as they seemed to pollute its “private interface” somewhat. Even worse, I didn’t like that these translations were initialized every time the class is instantiated; the translations are constant data and this initialization seems wasteful. Finally, I’m not so sure a std::map object is the best choice to store these values as it seems unnecessarily complex. Therefore, I decided to store the translations as an array of structs and modify the TranslateString() function accordingly.

Here’s the resulting header file:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// StringXmlWriter.h

class StringXmlWriter
{
private:
    std::stack<std::string> m_openedElements;
    std::string m_xmlStr;
    bool m_unclosedStartElement;

public:
    StringXmlWriter();
    std::string GetXmlString() const;
    void WriteAttributeString(const std::string& localName,
                              const std::string& value);
    void WriteElementString(const std::string& localName,
                            const std::string& value);
    void WriteEndElement();
    void WriteStartElement(const std::string& localName);
    void WriteString(const std::string& value);

private:
    // Disable copy construction and assignment
    StringXmlWriter(const StringXmlWriter&);
    StringXmlWriter& operator=(const StringXmlWriter&);
};

Here’s the implementation file:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136


// StringXmlWriter.cpp

#include "StringXmlWriter.h"

#define ARRAYSIZE(x) ( sizeof(x) / sizeof(x[0]) )

struct CharTranslation
{
    char OriginalChar;
    const char* ReplacementString;
};

static const CharTranslation AttributeValueTranslations[] =
{
    { '"', "&quot;" },
    { '&', "&amp;" },
};

static const CharTranslation CharDataTranslations[] =
{
    { '&', "&amp;" },
    { '<', "&lt;" },
    { '>', "&gt;" },
};

struct OriginalCharEquals :
    public std::binary_function<CharTranslation, char, bool>
{
    bool operator() (const CharTranslation& translation, char ch) const
    {
        return (translation.OriginalChar == ch);
    }
};

static std::string TranslateString(const std::string& originalStr,
                                   const CharTranslation* translations,
                                   int numTranslations)
{
    // Actually one past end, needed for proper std::find_if semantics
    const CharTranslation* endTranslations = translations + numTranslations;

    std::string translatedStr;
    for (std::string::const_iterator stringIter = originalStr.begin();
         stringIter != originalStr.end();
         ++stringIter) {
        char ch = *stringIter;

        const CharTranslation* translation = std::find_if
            (
            translations,
            endTranslations,
            std::bind2nd(OriginalCharEquals(), ch)
            );
        if (translation != endTranslations) {
            translatedStr += translation->ReplacementString;
        } else {
            translatedStr += ch;
        }
    }

    return translatedStr;
}

StringXmlWriter::StringXmlWriter() : m_unclosedStartElement(false)
{
}

std::string StringXmlWriter::GetXmlString() const
{
    return m_xmlStr;
}

void StringXmlWriter::WriteAttributeString(const std::string& localName,
                                           const std::string& value)
{
    m_xmlStr += ' ';
    m_xmlStr += localName;
    m_xmlStr += "=\"";
    m_xmlStr += TranslateString
        (
        value,
        AttributeValueTranslations,
        ARRAYSIZE(AttributeValueTranslations)
        );
    m_xmlStr += '"';
}

void StringXmlWriter::WriteElementString(const std::string& localName,
                                         const std::string& value)
{
    WriteStartElement(localName);
    WriteString(value);
    WriteEndElement();
}

void StringXmlWriter::WriteEndElement()
{
    if (m_unclosedStartElement) {
        m_xmlStr += "/>";
        m_unclosedStartElement = false;
    } else {
        std::string lastOpenedElement = m_openedElements.top();
        m_xmlStr += "</";
        m_xmlStr += lastOpenedElement;
        m_xmlStr += '>';
    }
    m_openedElements.pop();
}

void StringXmlWriter::WriteStartElement(const std::string& localName)
{
    if (m_unclosedStartElement) {
        m_xmlStr += '>';
        m_unclosedStartElement = false;
    }

    m_openedElements.push(localName);
    m_xmlStr += '<';
    m_xmlStr += localName;
    m_unclosedStartElement = true;
}

void StringXmlWriter::WriteString(const std::string& value)
{
    if (m_unclosedStartElement) {
        m_xmlStr += '>';
        m_unclosedStartElement = false;
    }

    m_xmlStr += TranslateString
        (
        value,
        CharDataTranslations,
        ARRAYSIZE(CharDataTranslations)
        );
}

By the way, if you can figure out a more elegant way to perform the translations, I’d love to hear it. I looked at std::transform but that can only do T->T translations. I wish I could have figured out a way to avoid writing the OriginalCharEquals function object and used something like std::equal_to, but I couldn’t find one which could compare the char OriginalChar member of CharTranslation to a separate char variable. Finally, I think the character-by-character translation method is likely slow and produces a rather large number of reallocations.