QPatternist::Base64Binary Class Reference

Implements the value instance of the xs:base64Binary type. More...

#include <qbase64binary_p.h>

Inheritance diagram for QPatternist::Base64Binary:

Public Types
typedef AtomicValue::Ptr	Ptr
Public Types inherited from QPatternist::AtomicValue
typedef QList< AtomicValue::Ptr >	List
typedef QExplicitlySharedDataPointer< AtomicValue >	Ptr

Public Functions
const QByteArray &	asByteArray () const
virtual QString	stringValue () const
virtual ItemType::Ptr	type () const
Public Functions inherited from QPatternist::AtomicValue
virtual bool	evaluateEBV (const QExplicitlySharedDataPointer< DynamicContext > &context) const
virtual bool	hasError () const
virtual	~AtomicValue ()
Public Functions inherited from QSharedData
	QSharedData ()
	Constructs a QSharedData object with a reference count of 0. More...
	QSharedData (const QSharedData &)
	Constructs a QSharedData object with reference count 0. More...
Public Functions inherited from QPatternist::CppCastingHelper< AtomicValue >
const TCastTarget *	as () const
TCastTarget *	as ()

Static Public Functions
static AtomicValue::Ptr	fromLexical (const QString &value)
static Base64Binary::Ptr	fromValue (const QByteArray &data)
Static Public Functions inherited from QPatternist::AtomicValue
static ItemType::Ptr	qtToXDMType (const QXmlItem &item)
static QVariant	toQt (const AtomicValue *const value)
static QVariant	toQt (const AtomicValue::Ptr &value)
static Item	toXDM (const QVariant &value)

Protected Functions
	Base64Binary (const QByteArray &val)
Protected Functions inherited from QPatternist::AtomicValue
	AtomicValue ()
Protected Functions inherited from QPatternist::CppCastingHelper< AtomicValue >
	CppCastingHelper ()

Protected Variables
const QByteArray	m_value

Static Private Functions
static void	base64Decode (const QByteArray &in, QByteArray &out, bool &ok)
	Assumes in is a lexical representation of xs:base64Binary, and converts it to the binary data set in out. More...

Static Private Attributes
static const char	Base64DecMap [128]

Friends
class	CommonValues

Additional Inherited Members
Public Variables inherited from QSharedData
QAtomicInt	ref

Detailed Description

Implements the value instance of the xs:base64Binary type.

Author

Frans Englich frans.nosp@m..eng.nosp@m.lich@.nosp@m.noki.nosp@m.a.com

Definition at line 70 of file qbase64binary_p.h.

Typedefs

Ptr

typedef AtomicValue::Ptr QPatternist::Base64Binary::Ptr

Definition at line 75 of file qbase64binary_p.h.

Constructors and Destructors

Base64Binary()

Base64Binary::Base64Binary ( const QByteArray &  val )

protected

Definition at line 54 of file qbase64binary.cpp.

Referenced by asByteArray(), fromLexical(), and fromValue().

                                                : m_value(val)
{
}

Functions

asByteArray()

const QByteArray& QPatternist::Base64Binary::asByteArray ( ) const

inline

Definition at line 86 of file qbase64binary_p.h.

Referenced by QPatternist::HexBinaryToBase64BinaryCaster::castFrom(), QPatternist::Base64BinaryToHexBinaryCaster::castFrom(), QPatternist::XsdTypeChecker::checkConstrainingFacets(), and QPatternist::AtomicValue::toQt().

        {
            return m_value;
        }

base64Decode()

void Base64Binary::base64Decode ( const QByteArray &  in, QByteArray &  out, bool &  ok  )

staticprivate

Assumes in is a lexical representation of xs:base64Binary, and converts it to the binary data set in out.

If instr is invalid Base64 content, ok is set to false, and the returned QByteArray has an undefined value.

We cannot use QByteArray::fromBase64() because it doesn't do the necessary validation that we need to properly implement W3C XML Schema's xs:base64Binary type.

Definition at line 78 of file qbase64binary.cpp.

Referenced by fromLexical().

{
    out.resize(0);

    if(in.isEmpty())
    {
        ok = false;
        return;
    }

    ok = true;
    int len = in.size(), tail = len;
    const char *const data = in.data();
    unsigned int eqCount = 0;

    // Find the tail end of the actual encoded data even if
    // there is/are trailing CR and/or LF.
    while(data[tail - 1] == '=')
    {
        --tail;
        if(data[tail] != '=')
            len = tail;
        else
            ++eqCount;
    }

    if(eqCount > 2)
    {
        ok = false;
        return;
    }

    unsigned int outIdx = 0;
    const int count = len; // We modify len below
    out.resize((count));

    for(int idx = 0; idx < count; ++idx)
    {
        const unsigned char ch = data[idx];
        if((ch > 47 && ch < 58) ||
            (ch > 64 && ch < 91) ||
            (ch > 96 && ch < 123) ||
            ch == '+' ||
            ch == '/')
        {
            out[outIdx++] = Base64DecMap[ch];
        }
        else if(ch == '=')
        {
            if((idx + 1) == count || data[idx + 1] == '=')
            {
                out[++outIdx] = Base64DecMap[ch];
                continue;
            }

            ok = false;
            return;
        }
        else if(ch == ' ')
        {
            /* One space is ok, and the previously applied whitespace facet(not implemented
             * at this time of writing) have ensured it's only one space, so we assume that. */
            --tail;
            --len;
            continue;
        }
        else
        {
            ok = false;
            return;
        }
    }

    if(outIdx % 4 != 0)
    {
        ok = false;
        return;
    }

    out.resize(len);

    // 4-byte to 3-byte conversion
    len = (tail > (len / 4)) ? tail - (len / 4) : 0;
    int sidx = 0, didx = 0;
    if(len > 1)
    {
      while(didx < len - 2)
      {
          out[didx] =(((out[sidx] << 2) & 255) | ((out[sidx + 1] >> 4) & 003));
          out[didx + 1] =(((out[sidx + 1] << 4) & 255) | ((out[sidx + 2] >> 2) & 017));
          out[didx + 2] =(((out[sidx + 2] << 6) & 255) | (out[sidx + 3] & 077));
          sidx += 4;
          didx += 3;
      }
    }

    if(didx < len)
        out[didx] =(((out[sidx] << 2) & 255) | ((out[sidx + 1] >> 4) & 003));

    if(++didx < len)
        out[didx] =(((out[sidx + 1] << 4) & 255) | ((out[sidx + 2] >> 2) & 017));

    // Resize the output buffer
    if(len == 0 || len < out.size())
      out.resize(len);
}

fromLexical()

AtomicValue::Ptr Base64Binary::fromLexical ( const QString &  value )

static

Creates an instance representing value.

Definition at line 185 of file qbase64binary.cpp.

Referenced by QPatternist::StringToBase64BinaryCaster::castFrom().

{
    const QString simple(str.simplified());
    if(simple.isEmpty())
        return AtomicValue::Ptr(new Base64Binary(QByteArray()));

    bool ok = false;
    QByteArray result;
    base64Decode(simple.toUtf8(), result, ok);

    if(ok)
        return AtomicValue::Ptr(new Base64Binary(result));
    else
        return ValidationError::createError();
}

fromValue()

Base64Binary::Ptr Base64Binary::fromValue ( const QByteArray &  data )

static

Definition at line 201 of file qbase64binary.cpp.

Referenced by QPatternist::HexBinaryToBase64BinaryCaster::castFrom().

{
    return Base64Binary::Ptr(new Base64Binary(data));
}

stringValue()

QString Base64Binary::stringValue ( ) const

virtual

Implements QPatternist::AtomicValue.

Reimplemented in QPatternist::HexBinary.

Definition at line 206 of file qbase64binary.cpp.

{
    return QString::fromLatin1(m_value.toBase64().constData());
}

type()

ItemType::Ptr Base64Binary::type ( ) const

virtual

Implements QPatternist::AtomicValue.

Reimplemented in QPatternist::HexBinary.

Definition at line 211 of file qbase64binary.cpp.

{
    return BuiltinTypes::xsBase64Binary;
}

Friends and Related Functions

CommonValues

friend class CommonValues

friend

Definition at line 73 of file qbase64binary_p.h.

Properties

Base64DecMap

const char Base64Binary::Base64DecMap

staticprivate

Initial value:

=
{
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3F,
     0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
     0x3C, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
     0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
     0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
     0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
     0x00, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
     0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
     0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
     0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00
}

Definition at line 110 of file qbase64binary_p.h.

Referenced by Base64Binary(), and base64Decode().

m_value

const QByteArray QPatternist::Base64Binary::m_value

protected

Definition at line 94 of file qbase64binary_p.h.

Referenced by asByteArray(), QPatternist::HexBinary::stringValue(), and stringValue().

---

The documentation for this class was generated from the following files:

• /src/xmlpatterns/data/qbase64binary_p.h
• /src/xmlpatterns/data/qbase64binary.cpp