XalanDOMString.hpp

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the  "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#if !defined(XALANDOMSTRING_HEADER_GUARD_1357924680)
#define XALANDOMSTRING_HEADER_GUARD_1357924680
 
 
 
#include <xalanc/XalanDOM/XalanDOMDefinitions.hpp>
 
 
 
#include <cassert>
 
 
 
#include <xalanc/Include/STLHelper.hpp>
#include <xalanc/Include/XalanMemoryManagement.hpp>
#include <xalanc/Include/XalanVector.hpp>
 
 
 
#include <xalanc/XalanDOM/XalanDOMException.hpp>
 
 
 
namespace XALAN_CPP_NAMESPACE {
 
 
 
class XALAN_DOM_EXPORT XalanDOMString
{
public:
 
    typedef XalanVector<XalanDOMChar>       XalanDOMCharVectorType;
    typedef XalanVector<char>               CharVectorType;
    typedef XalanVector<wchar_t>            WideCharVectorType;
 
    typedef XalanDOMChar                value_type;
    typedef XalanDOMChar&               reference;
    typedef const XalanDOMChar&         const_reference;
 
    typedef XalanSize_t     size_type;
 
    typedef XalanDOMCharVectorType::iterator                iterator;
    typedef XalanDOMCharVectorType::const_iterator          const_iterator;
    typedef XalanDOMCharVectorType::reverse_iterator        reverse_iterator;
    typedef XalanDOMCharVectorType::const_reverse_iterator  const_reverse_iterator;
 
    static const size_type  npos;
 
    XalanDOMString(MemoryManager&  theManager XALAN_DEFAULT_CONSTRUCTOR_MEMMGR);
 
    explicit
    XalanDOMString(
            const char*         theString,
            MemoryManager&  theManager XALAN_DEFAULT_MEMMGR,
            size_type           theCount = size_type(npos));
 
    XalanDOMString(
            const XalanDOMString&   theSource,
            MemoryManager&      theManager XALAN_DEFAULT_CONSTRUCTOR_MEMMGR,
            size_type               theStartPosition = 0,
            size_type               theCount = size_type(npos));
 
    explicit
    XalanDOMString(
            const XalanDOMChar*     theString,
            MemoryManager&      theManager XALAN_DEFAULT_MEMMGR,
            size_type               theCount = size_type(npos));
 
    XalanDOMString(
            size_type       theCount,
            XalanDOMChar    theChar,
            MemoryManager&  theManager XALAN_DEFAULT_MEMMGR);
 
    XalanDOMString*
    clone(MemoryManager&  theManager);
 
    ~XalanDOMString()
    {
    }
 
    XalanDOMString&
    operator=(const XalanDOMString& theRHS)
    {
        return assign(theRHS);
    }
 
    XalanDOMString&
    operator=(const XalanDOMChar*   theRHS)
    {
        return assign(theRHS);
    }
 
    XalanDOMString&
    operator=(const char*   theRHS)
    {
        return assign(theRHS);
    }
 
    XalanDOMString&
    operator=(XalanDOMChar  theRHS)
    {
        return assign(1, theRHS);
    }
 
    iterator
    begin()
    {
        invariants();
 
        return m_data.begin();
    }
 
    const_iterator
    begin() const
    {
        invariants();
 
        return m_data.begin();
    }
 
    iterator
    end()
    {
        invariants();
 
        return m_data.empty() == true ? m_data.end() : m_data.end() - 1;
    }
 
    const_iterator
    end() const
    {
        invariants();
 
        return m_data.empty() == true ? m_data.end() : m_data.end() - 1;
    }
 
    reverse_iterator
    rbegin()
    {
        invariants();
 
        reverse_iterator    i = m_data.rbegin();
 
        if (m_data.empty() == false)
        {
            ++i;
        }
 
        return i;
    }
 
    const_reverse_iterator
    rbegin() const
    {
        invariants();
 
        const_reverse_iterator  i = m_data.rbegin();
 
        if (m_data.empty() == false)
        {
            ++i;
        }
 
        return i;
    }
 
    reverse_iterator
    rend()
    {
        invariants();
 
        return m_data.rend();
    }
 
    const_reverse_iterator
    rend() const
    {
        invariants();
 
        return m_data.rend();
    }
 
    size_type
    size() const
    {
        invariants();
 
        return m_size;
    }
 
    size_type
    length() const
    {
        invariants();
 
        return size();
    }
 
    size_type
    max_size() const
    {
        invariants();
 
        return ~size_type(0);
    }
 
    void
    resize(
            size_type       theCount,
            XalanDOMChar    theChar);
 
    void
    resize(size_type    theCount)
    {
        invariants();
 
        resize(theCount, XalanDOMChar(0));
    }
 
    size_type
    capacity() const
    {
        invariants();
 
        const XalanDOMCharVectorType::size_type     theCapacity =
                m_data.capacity();
 
        return theCapacity == 0 ? 0 : size_type(theCapacity - 1);
    }
 
    void
    reserve(size_type   theCount = 0)
    {
        invariants();
 
        m_data.reserve(theCount + 1);
    }
 
    void
    clear()
    {
        invariants();
 
        m_data.erase(m_data.begin(), m_data.end());
 
        m_size = 0;
 
        invariants();
    }
 
    iterator
    erase(iterator  thePosition)
    {
        invariants();
 
        m_data.erase(thePosition);
 
        --m_size;
 
        invariants();
 
        return thePosition;
    }
 
    iterator
    erase(
            iterator   theFirst,
            iterator   theLast)
    {
        invariants();
 
        m_data.erase(theFirst, theLast);
 
        m_size = m_data.size() - 1;
 
        invariants();
 
        return theFirst;
    }
 
    XalanDOMString&
    erase(
            size_type   theStartPosition = 0,
            size_type   theCount = size_type(npos));
 
    bool
    empty() const
    {
        invariants();
 
        return m_size == 0 ? true : false;
    }
 
    const_reference
    operator[](size_type    theIndex) const
    {
        invariants();
 
        return m_data[theIndex];
    }
 
    reference
    operator[](size_type    theIndex)
    {
        invariants();
 
        return m_data[theIndex];
    }
 
    const_reference
    at(size_type    theIndex) const
    {
        invariants();
 
        return m_data.at(theIndex);
    }
 
    reference
    at(size_type    theIndex)
    {
        invariants();
 
        return m_data.at(theIndex);
    }
 
    const XalanDOMChar*
    c_str() const
    {
        invariants();
 
        return m_data.empty() == true ? &s_empty : &m_data[0];
    }
 
    const XalanDOMChar*
    data() const
    {
        invariants();
 
        return c_str();
    }
 
    void
    swap(XalanDOMString&    theOther)
    {
        invariants();
 
        m_data.swap(theOther.m_data);
 
        std::swap(m_size, theOther.m_size);
    }
 
    XalanDOMString&
    operator+=(const XalanDOMString&    theSource)
    {
        return append(theSource);
    }
 
    XalanDOMString&
    operator+=(const XalanDOMChar*  theString)
    {
        return append(theString);
    }
 
    XalanDOMString&
    operator+=(XalanDOMChar theChar)
    {
        append(1, theChar);
 
        return *this;
    }
 
    XalanDOMString&
    assign(const XalanDOMChar*  theSource)
    {
        invariants();
 
        erase();
 
        invariants();
 
        return append(theSource);
    }
 
    XalanDOMString&
    assign(
            const XalanDOMChar*     theSource,
            size_type               theCount)
    {
        invariants();
 
        erase();
 
        invariants();
 
        return append(theSource, theCount);
    }
 
    XalanDOMString&
    assign(const char*  theSource)
    {
        invariants();
 
        erase();
 
        invariants();
 
        return append(theSource);
    }
 
    XalanDOMString&
    assign(
            const char*     theSource,
            size_type       theCount)
    {
        invariants();
 
        erase();
 
        invariants();
 
        return append(theSource, theCount);
    }
 
    XalanDOMString&
    assign(
            const XalanDOMString&   theSource,
            size_type               thePosition,
            size_type               theCount);
 
    XalanDOMString&
    assign(const XalanDOMString&    theSource)
    {
        invariants();
 
        if (&theSource != this)
        {
            m_data = theSource.m_data;
 
            m_size = theSource.m_size;
        }
 
        invariants();
 
        return *this;
    }
 
    XalanDOMString&
    assign(
            size_type       theCount,
            XalanDOMChar    theChar)
    {
        invariants();
 
        erase();
 
        invariants();
 
        return append(theCount, theChar);
    }
 
    XalanDOMString&
    assign(
        iterator    theFirstPosition,
        iterator    theLastPosition);
 
    XalanDOMString&
    append(const XalanDOMString&    theSource)
    {
        return append(theSource.c_str(), theSource.length());
    }
 
    XalanDOMString&
    append(
            const XalanDOMString&   theSource,
            size_type               thePosition,
            size_type               theCount)
    {
        assert(thePosition < theSource.length() &&
               (theCount == size_type(npos) || thePosition + theCount <= theSource.length()));
 
        return append(theSource.c_str() + thePosition, theCount);
    }
 
    XalanDOMString&
    append(
            const XalanDOMChar*     theString,
            size_type               theCount);
 
    XalanDOMString&
    append(const XalanDOMChar*  theString)
    {
        return append(theString, length(theString));
    }
 
    XalanDOMString&
    append(
            const char*     theString,
            size_type       theCount);
 
    XalanDOMString&
    append(const char*  theString)
    {
        return append(theString, length(theString));
    }
 
    XalanDOMString&
    append(
            size_type       theCount,
            XalanDOMChar    theChar);
 
    void
    push_back(XalanDOMChar  theChar)
    {
        invariants();
 
        append(1, theChar);
 
        invariants();
    }
 
    XalanDOMString&
    insert(
            size_type               thePosition,
            const XalanDOMString&   theString)
    {
        return insert(thePosition, theString.c_str(), theString.length());
    }
 
    XalanDOMString&
    insert(
            size_type               thePosition1,
            const XalanDOMString&   theString,
            size_type               thePosition2,
            size_type               theCount)
    {
        return insert(thePosition1, theString.c_str() + thePosition2, theCount);
    }
 
    XalanDOMString&
    insert(