mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2025-06-15 22:57:12 +02:00
Separated major non mandatory libraries into their onwn modules.
Consolidated and simplified the module API system. Various other fixes and improvements.
This commit is contained in:
Sandu Liviu Catalin
193
modules/xml/Attribute.cpp
Normal file
193
modules/xml/Attribute.cpp
Normal file
@ -0,0 +1,193 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Attribute.hpp"
|
||||
#include "Module.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <sqrat.h>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Attribute::Validate() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return true;
|
||||
// Invalid document reference
|
||||
_SqMod->SqThrow("Invalid XML document reference");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Attribute::SetName(CSStr name)
|
||||
{
|
||||
if (!m_Attr.set_name(name))
|
||||
_SqMod->SqThrow("Unable to set xml attribute name");
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Attribute::SetValue(CSStr name)
|
||||
{
|
||||
if (!m_Attr.set_value(name))
|
||||
_SqMod->SqThrow("Unable to set xml attribute value");
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Attribute::AsLong(Object & def) const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object >::push(_SqVM, def);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushSLongObject(_SqVM, m_Attr.as_llong(longint));
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Attribute::AsUlong(Object & def) const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object >::push(_SqVM, def);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushULongObject(_SqVM, m_Attr.as_ullong(longint));
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Attribute::ApplyLong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Whether the operation succeeded
|
||||
bool res = false;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
res = m_Attr.set_value(longint);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the result
|
||||
return res;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Attribute::ApplyUlong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Whether the operation succeeded
|
||||
bool res = false;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
res = m_Attr.set_value(longint);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the result
|
||||
return res;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Attribute::GetLong() const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushSLongObject(_SqVM, m_Attr.as_llong());
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Attribute::SetLong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
m_Attr = longint;
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Attribute::GetUlong() const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushULongObject(_SqVM, m_Attr.as_ullong());
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Attribute::SetUlong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
m_Attr = longint;
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
427
modules/xml/Attribute.hpp
Normal file
427
modules/xml/Attribute.hpp
Normal file
@ -0,0 +1,427 @@
|
||||
#ifndef _XML_ATTRIBUTE_HPP_
|
||||
#define _XML_ATTRIBUTE_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Common.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* A light-weight handle for manipulating attributes in DOM tree.
|
||||
*/
|
||||
class Attribute
|
||||
{
|
||||
// --------------------------------------------------------------------------------------------
|
||||
friend class Node;
|
||||
|
||||
protected:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_attribute Type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Explicit constructor.
|
||||
*/
|
||||
Attribute(const DocumentRef doc, const Type & attr)
|
||||
: m_Doc(doc), m_Attr(attr)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the document reference and throw an error if invalid.
|
||||
*/
|
||||
bool Validate() const;
|
||||
|
||||
private:
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
DocumentRef m_Doc; /* The main xml document instance. */
|
||||
Type m_Attr; /* The managed node attribute. */
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
Attribute()
|
||||
: m_Doc(), m_Attr()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor. (disabled)
|
||||
*/
|
||||
Attribute(const Attribute & o)
|
||||
: m_Doc(o.m_Doc), m_Attr(o.m_Attr)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~Attribute()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator. (disabled)
|
||||
*/
|
||||
Attribute & operator = (const Attribute & o)
|
||||
{
|
||||
m_Doc = o.m_Doc;
|
||||
m_Attr = o.m_Attr;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to compare two instances of this type.
|
||||
*/
|
||||
Int32 Cmp(const Attribute & o)
|
||||
{
|
||||
if (m_Attr == o.m_Attr)
|
||||
return 0;
|
||||
else if (m_Attr > o.m_Attr)
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to convert an instance of this type to a string.
|
||||
*/
|
||||
CSStr ToString() const
|
||||
{
|
||||
return m_Attr.value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether this instance references a valid xml document.
|
||||
*/
|
||||
bool IsValid() const
|
||||
{
|
||||
return m_Doc;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Return the number of active references to this document instance.
|
||||
*/
|
||||
Uint32 GetRefCount() const
|
||||
{
|
||||
return m_Doc.Count();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether the attribute is empty.
|
||||
*/
|
||||
bool IsEmpty() const
|
||||
{
|
||||
return m_Attr.empty();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get hash value (unique for handles to the same object).
|
||||
*/
|
||||
SQInteger GetHashValue() const
|
||||
{
|
||||
return (SQInteger)m_Attr.hash_value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve attribute name.
|
||||
*/
|
||||
CSStr GetName() const
|
||||
{
|
||||
return m_Attr.name();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve attribute name.
|
||||
*/
|
||||
void SetName(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the attribute name.
|
||||
*/
|
||||
bool ApplyName(CSStr name)
|
||||
{
|
||||
return m_Attr.set_name(name);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve attribute value.
|
||||
*/
|
||||
CSStr GetValue() const
|
||||
{
|
||||
return m_Attr.value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve attribute value.
|
||||
*/
|
||||
void SetValue(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the attribute value.
|
||||
*/
|
||||
bool ApplyValue(CSStr value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a string or the specified default value if empty.
|
||||
*/
|
||||
CSStr AsString(CSStr def) const
|
||||
{
|
||||
return m_Attr.as_string(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a integer or the specified default value if empty.
|
||||
*/
|
||||
Int32 AsInt(Int32 def) const
|
||||
{
|
||||
return m_Attr.as_int(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned integer or the specified default value if empty.
|
||||
*/
|
||||
Uint32 AsUint(Uint32 def) const
|
||||
{
|
||||
return m_Attr.as_uint(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a floating point or the specified default value if empty.
|
||||
*/
|
||||
SQFloat AsFloat(SQFloat def) const
|
||||
{
|
||||
return (SQFloat)m_Attr.as_float(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a double floating point or the specified default value if empty.
|
||||
*/
|
||||
SQFloat AsDouble(SQFloat def) const
|
||||
{
|
||||
return (SQFloat)m_Attr.as_double(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a long integer or the specified default value if empty.
|
||||
*/
|
||||
Object AsLong(Object & def) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned long integer or the specified default value if empty.
|
||||
*/
|
||||
Object AsUlong(Object & def) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a boolean or the specified default value if empty.
|
||||
*/
|
||||
bool AsBool(bool def) const
|
||||
{
|
||||
return m_Attr.as_bool(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a string.
|
||||
*/
|
||||
bool ApplyString(CSStr value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a integer.
|
||||
*/
|
||||
bool ApplyInt(Int32 value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned integer.
|
||||
*/
|
||||
bool ApplyUint(Uint32 value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a floating point.
|
||||
*/
|
||||
bool ApplyFloat(SQFloat value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a double floating point.
|
||||
*/
|
||||
bool ApplyDouble(SQFloat value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a long integer.
|
||||
*/
|
||||
bool ApplyLong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned long integer.
|
||||
*/
|
||||
bool ApplyUlong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a boolean.
|
||||
*/
|
||||
bool ApplyBool(bool value)
|
||||
{
|
||||
return m_Attr.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a string.
|
||||
*/
|
||||
CSStr GetString() const
|
||||
{
|
||||
return m_Attr.as_string();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a string.
|
||||
*/
|
||||
void SetString(CSStr value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a integer.
|
||||
*/
|
||||
Int32 GetInt() const
|
||||
{
|
||||
return m_Attr.as_int();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a integer.
|
||||
*/
|
||||
void SetInt(Int32 value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned integer.
|
||||
*/
|
||||
Uint32 GetUint() const
|
||||
{
|
||||
return m_Attr.as_uint();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned integer.
|
||||
*/
|
||||
void SetUint(Uint32 value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a floating point.
|
||||
*/
|
||||
SQFloat GetFloat() const
|
||||
{
|
||||
return (SQFloat)m_Attr.as_float();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a floating point.
|
||||
*/
|
||||
void SetFloat(SQFloat value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a double floating point.
|
||||
*/
|
||||
SQFloat GetDouble() const
|
||||
{
|
||||
return (SQFloat)m_Attr.as_double();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a double floating point.
|
||||
*/
|
||||
void SetDouble(SQFloat value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a long integer.
|
||||
*/
|
||||
Object GetLong() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a long integer.
|
||||
*/
|
||||
void SetLong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned long integer.
|
||||
*/
|
||||
Object GetUlong() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned long integer.
|
||||
*/
|
||||
void SetUlong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a boolean.
|
||||
*/
|
||||
bool GetBool() const
|
||||
{
|
||||
return m_Attr.as_bool();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a boolean.
|
||||
*/
|
||||
void SetBool(bool value)
|
||||
{
|
||||
m_Attr = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve next attribute in the attribute list of the parent node.
|
||||
*/
|
||||
Attribute NextAttribute() const
|
||||
{
|
||||
return Attribute(m_Doc, m_Attr.next_attribute());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve previous attribute in the attribute list of the parent node.
|
||||
*/
|
||||
Attribute PrevAttribute() const
|
||||
{
|
||||
return Attribute(m_Doc, m_Attr.previous_attribute());
|
||||
}
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_ATTRIBUTE_HPP_
|
||||
25
modules/xml/Common.cpp
Normal file
25
modules/xml/Common.cpp
Normal file
@ -0,0 +1,25 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Common.hpp"
|
||||
#include "Module.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool ParseResult::Validate() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return true;
|
||||
// Invalid document reference
|
||||
_SqMod->SqThrow("Invalid XML document reference");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void ParseResult::Check() const
|
||||
{
|
||||
if (m_Result.status != status_ok)
|
||||
_SqMod->SqThrow("XML parse error [%s]", m_Result.description());
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
392
modules/xml/Common.hpp
Normal file
392
modules/xml/Common.hpp
Normal file
@ -0,0 +1,392 @@
|
||||
#ifndef _XML_COMMON_HPP_
|
||||
#define _XML_COMMON_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "ModBase.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <assert.h>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <pugixml.hpp>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* SOFTWARE INFORMATION
|
||||
*/
|
||||
#define SQXML_NAME "Squirrel XML Module"
|
||||
#define SQXML_AUTHOR "Sandu Liviu Catalin (S.L.C)"
|
||||
#define SQXML_COPYRIGHT "Copyright (C) 2016 Sandu Liviu Catalin"
|
||||
#define SQXML_HOST_NAME "SqModXMLHost"
|
||||
#define SQXML_VERSION 001
|
||||
#define SQXML_VERSION_STR "0.0.1"
|
||||
#define SQXML_VERSION_MAJOR 0
|
||||
#define SQXML_VERSION_MINOR 0
|
||||
#define SQXML_VERSION_PATCH 1
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
using namespace pugi;
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
class Node;
|
||||
class Text;
|
||||
class Document;
|
||||
class Attribute;
|
||||
class XPathNode;
|
||||
class XPathNodeSet;
|
||||
class XPathVariable;
|
||||
class XPathVariableSet;
|
||||
class XPathVariableQuery;
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Manages a reference counted xml document instance.
|
||||
*/
|
||||
class DocumentRef
|
||||
{
|
||||
// --------------------------------------------------------------------------------------------
|
||||
friend class Document;
|
||||
|
||||
public:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_document Type; /* The managed type. */
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef Type* Pointer; /* Pointer to the managed type. */
|
||||
typedef const Type* ConstPtr; /* Constant pointer to the managed type. */
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef Type& Reference; /* Reference to the managed type. */
|
||||
typedef const Type& ConstRef; /* Constant reference to the managed type. */
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef unsigned int Counter; /* Reference counter type. */
|
||||
|
||||
private:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
Pointer m_Ptr; /* The document reader, writer and manager instance. */
|
||||
Counter* m_Ref; /* Reference count to the managed instance. */
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Grab a strong reference to a document instance.
|
||||
*/
|
||||
void Grab()
|
||||
{
|
||||
if (m_Ptr)
|
||||
++(*m_Ref);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Drop a strong reference to a document instance.
|
||||
*/
|
||||
void Drop()
|
||||
{
|
||||
if (m_Ptr && --(*m_Ref) == 0)
|
||||
{
|
||||
delete m_Ptr;
|
||||
delete m_Ref;
|
||||
m_Ptr = NULL;
|
||||
m_Ref = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Base constructor.
|
||||
*/
|
||||
DocumentRef(VoidP /* unused */)
|
||||
: m_Ptr(new Type())
|
||||
, m_Ref(new Counter(1))
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor (null).
|
||||
*/
|
||||
DocumentRef()
|
||||
: m_Ptr(NULL), m_Ref(NULL)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor.
|
||||
*/
|
||||
DocumentRef(const DocumentRef & o)
|
||||
: m_Ptr(o.m_Ptr), m_Ref(o.m_Ref)
|
||||
|
||||
{
|
||||
Grab();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~DocumentRef()
|
||||
{
|
||||
Drop();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator.
|
||||
*/
|
||||
DocumentRef & operator = (const DocumentRef & o)
|
||||
{
|
||||
if (m_Ptr != o.m_Ptr)
|
||||
{
|
||||
Drop();
|
||||
m_Ptr = o.m_Ptr;
|
||||
m_Ref = o.m_Ref;
|
||||
Grab();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Perform an equality comparison between two document instances.
|
||||
*/
|
||||
bool operator == (const DocumentRef & o) const
|
||||
{
|
||||
return (m_Ptr == o.m_Ptr);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Perform an inequality comparison between two document instances.
|
||||
*/
|
||||
bool operator != (const DocumentRef & o) const
|
||||
{
|
||||
return (m_Ptr != o.m_Ptr);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Implicit conversion to boolean for use in boolean operations.
|
||||
*/
|
||||
operator bool () const
|
||||
{
|
||||
return m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Implicit conversion to the managed instance pointer.
|
||||
*/
|
||||
operator Pointer ()
|
||||
{
|
||||
return m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Implicit conversion to the managed instance pointer.
|
||||
*/
|
||||
operator ConstPtr () const
|
||||
{
|
||||
return m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Implicit conversion to the managed instance reference.
|
||||
*/
|
||||
operator Reference ()
|
||||
{
|
||||
assert(m_Ptr);
|
||||
return *m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Implicit conversion to the managed instance reference.
|
||||
*/
|
||||
operator ConstRef () const
|
||||
{
|
||||
assert(m_Ptr);
|
||||
return *m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Member operator for dereferencing the managed pointer.
|
||||
*/
|
||||
Pointer operator -> () const
|
||||
{
|
||||
assert(m_Ptr != NULL);
|
||||
return m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Indirection operator for obtaining a reference of the managed pointer.
|
||||
*/
|
||||
Reference operator * () const
|
||||
{
|
||||
assert(m_Ptr != NULL);
|
||||
return *m_Ptr;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the number of active references to the managed instance.
|
||||
*/
|
||||
Counter Count() const
|
||||
{
|
||||
return (m_Ptr && m_Ref) ? (*m_Ref) : 0;
|
||||
}
|
||||
};
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Allows the user to inspect the result of certain operations and act accordingly.
|
||||
*/
|
||||
class ParseResult
|
||||
{
|
||||
// --------------------------------------------------------------------------------------------
|
||||
friend class Document;
|
||||
friend class Node;
|
||||
|
||||
protected:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_parse_result Result;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Explicit constructor.
|
||||
*/
|
||||
ParseResult(const DocumentRef doc, const Result & result)
|
||||
: m_Doc(doc), m_Result(result)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the document reference and throw an error if invalid.
|
||||
*/
|
||||
bool Validate() const;
|
||||
|
||||
private:
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
DocumentRef m_Doc; /* The main xml document instance. */
|
||||
Result m_Result; /* The managed parse result. */
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
ParseResult()
|
||||
: m_Doc(), m_Result()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor. (disabled)
|
||||
*/
|
||||
ParseResult(const ParseResult & o)
|
||||
: m_Doc(o.m_Doc), m_Result(o.m_Result)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~ParseResult()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator. (disabled)
|
||||
*/
|
||||
ParseResult & operator = (const ParseResult & o)
|
||||
{
|
||||
m_Doc = o.m_Doc;
|
||||
m_Result = o.m_Result;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to compare two instances of this type.
|
||||
*/
|
||||
Int32 Cmp(const ParseResult & o)
|
||||
{
|
||||
if (m_Result.status == o.m_Result.status)
|
||||
return 0;
|
||||
else if (m_Result.status > o.m_Result.status)
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to convert an instance of this type to a string.
|
||||
*/
|
||||
CSStr ToString() const
|
||||
{
|
||||
return m_Result.description();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether this instance references a valid xml document.
|
||||
*/
|
||||
bool IsValid() const
|
||||
{
|
||||
return m_Doc;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Return the number of active references to this document instance.
|
||||
*/
|
||||
Uint32 GetRefCount() const
|
||||
{
|
||||
return m_Doc.Count();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Cast to bool operator.
|
||||
*/
|
||||
bool IsOk() const
|
||||
{
|
||||
return m_Result;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Parsing status code.
|
||||
*/
|
||||
Int32 GetStatus() const
|
||||
{
|
||||
return (Int32)m_Result.status;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Last parsed offset. (in char_t units from start of input data)
|
||||
*/
|
||||
SQInteger GetOffset() const
|
||||
{
|
||||
return (SQInteger)m_Result.offset;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Source document encoding.
|
||||
*/
|
||||
Int32 GetEncoding() const
|
||||
{
|
||||
return m_Result.encoding;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve error description as a string.
|
||||
*/
|
||||
CSStr GetDescription() const
|
||||
{
|
||||
return m_Result.description();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Check the parse result and throw the necessary errors.
|
||||
*/
|
||||
void Check() const;
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_COMMON_HPP_
|
||||
41
modules/xml/Document.cpp
Normal file
41
modules/xml/Document.cpp
Normal file
@ -0,0 +1,41 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Document.hpp"
|
||||
#include "Node.hpp"
|
||||
#include "Module.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Document::Validate() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return true;
|
||||
// Invalid document reference
|
||||
_SqMod->SqThrow("Invalid XML document reference");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Document::CanLoad() const
|
||||
{
|
||||
// Is the document even valid?
|
||||
if (!Validate())
|
||||
return false;
|
||||
// Are there any other references?
|
||||
else if (m_Doc.Count() == 1)
|
||||
return true;
|
||||
// To load new values now, would mean to cause undefined behavior in existing references
|
||||
_SqMod->SqThrow("Loading is disabled while document is referenced");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Node Document::GetNode() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return Node(m_Doc, m_Doc->document_element());
|
||||
return Node();
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
221
modules/xml/Document.hpp
Normal file
221
modules/xml/Document.hpp
Normal file
@ -0,0 +1,221 @@
|
||||
#ifndef _XML_DOCUMENT_HPP_
|
||||
#define _XML_DOCUMENT_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Common.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Class that can read/write and alter the contents of XML files.
|
||||
*/
|
||||
class Document
|
||||
{
|
||||
protected:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_document Type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor. (disabled)
|
||||
*/
|
||||
Document(const Document & o);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator. (disabled)
|
||||
*/
|
||||
Document & operator = (const Document & o);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the document reference and throw an error if invalid.
|
||||
*/
|
||||
bool Validate() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See if the document is allowed to overwrite its contents and throw an error if not.
|
||||
*/
|
||||
bool CanLoad() const;
|
||||
|
||||
private:
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
DocumentRef m_Doc; /* The main xml document instance. */
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
Document()
|
||||
: m_Doc(NULL)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~Document()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to compare two instances of this type.
|
||||
*/
|
||||
Int32 Cmp(const Document & o) const
|
||||
{
|
||||
if (m_Doc && !o.m_Doc)
|
||||
return 1;
|
||||
else if (!m_Doc && o.m_Doc)
|
||||
return -1;
|
||||
else if (!m_Doc && !o.m_Doc)
|
||||
return 0;
|
||||
else if (*m_Doc == *o.m_Doc)
|
||||
return 0;
|
||||
else if (*m_Doc > *o.m_Doc)
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to convert an instance of this type to a string.
|
||||
*/
|
||||
CSStr ToString() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return m_Doc->name();
|
||||
return _SC("");
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether this instance references a valid xml document.
|
||||
*/
|
||||
bool IsValid() const
|
||||
{
|
||||
return m_Doc;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Return the number of active references to this document instance.
|
||||
*/
|
||||
Uint32 GetRefCount() const
|
||||
{
|
||||
return m_Doc ? *(m_Doc.m_Ref) : 0;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Removes all nodes, leaving the empty document.
|
||||
*/
|
||||
void Reset()
|
||||
{
|
||||
if (Validate())
|
||||
m_Doc->reset();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Removes all nodes, then copies the entire contents of the specified document.
|
||||
*/
|
||||
void Reset(const Document & doc)
|
||||
{
|
||||
if (Validate() && doc.Validate())
|
||||
m_Doc->reset(*doc.m_Doc);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load document from zero-terminated string. (LoadString collides with the windows api)
|
||||
*/
|
||||
ParseResult LoadData(CSStr source)
|
||||
{
|
||||
if (CanLoad())
|
||||
return ParseResult(m_Doc, m_Doc->load_string(source));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load document from zero-terminated string. (LoadString collides with the windows api)
|
||||
*/
|
||||
ParseResult LoadData(CSStr source, Uint32 options)
|
||||
{
|
||||
if (CanLoad())
|
||||
return ParseResult(m_Doc, m_Doc->load_string(source, options));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load document from file on disk.
|
||||
*/
|
||||
ParseResult LoadFile(CSStr filepath)
|
||||
{
|
||||
if (CanLoad())
|
||||
return ParseResult(m_Doc, m_Doc->load_file(filepath));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load document from file on disk.
|
||||
*/
|
||||
ParseResult LoadFile(CSStr filepath, Uint32 options)
|
||||
{
|
||||
if (CanLoad())
|
||||
return ParseResult(m_Doc, m_Doc->load_file(filepath, options));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load document from file on disk.
|
||||
*/
|
||||
ParseResult LoadFile(CSStr filepath, Uint32 options, Int32 encoding)
|
||||
{
|
||||
if (CanLoad())
|
||||
return ParseResult(m_Doc, m_Doc->load_file(filepath, options, (xml_encoding)encoding));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Save XML to file on disk.
|
||||
*/
|
||||
void SaveFile(CSStr filepath)
|
||||
{
|
||||
if (Validate())
|
||||
m_Doc->save_file(filepath);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Save XML to file on disk.
|
||||
*/
|
||||
void SaveFile(CSStr filepath, CSStr indent)
|
||||
{
|
||||
if (Validate())
|
||||
m_Doc->save_file(filepath, indent);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Save XML to file on disk.
|
||||
*/
|
||||
void SaveFile(CSStr filepath, CSStr indent, Uint32 format)
|
||||
{
|
||||
if (Validate())
|
||||
m_Doc->save_file(filepath, indent, format);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Save XML to file on disk.
|
||||
*/
|
||||
void SaveFile(CSStr filepath, CSStr indent, Uint32 format, Int32 encoding)
|
||||
{
|
||||
if (Validate())
|
||||
m_Doc->save_file(filepath, indent, format, (xml_encoding)encoding);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the document root node.
|
||||
*/
|
||||
Node GetNode() const;
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_DOCUMENT_HPP_
|
||||
592
modules/xml/Module.cpp
Normal file
592
modules/xml/Module.cpp
Normal file
@ -0,0 +1,592 @@
|
||||
// --------------------------------------------------------------------------------------------
|
||||
#include "Module.hpp"
|
||||
#include "Common.hpp"
|
||||
#include "Attribute.hpp"
|
||||
#include "Text.hpp"
|
||||
#include "Node.hpp"
|
||||
#include "Document.hpp"
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
#include <sqrat.h>
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
#if defined(WIN32) || defined(_WIN32)
|
||||
#include <Windows.h>
|
||||
#endif
|
||||
|
||||
namespace SqMod {
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
PluginFuncs* _Func = NULL;
|
||||
PluginCallbacks* _Clbk = NULL;
|
||||
PluginInfo* _Info = NULL;
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
HSQAPI _SqAPI = NULL;
|
||||
HSQEXPORTS _SqMod = NULL;
|
||||
HSQUIRRELVM _SqVM = NULL;
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Bind speciffic functions to certain server events.
|
||||
*/
|
||||
void BindCallbacks();
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Undo changes made with BindCallbacks().
|
||||
*/
|
||||
void UnbindCallbacks();
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Register the module API under the specified virtual machine.
|
||||
*/
|
||||
void RegisterAPI(HSQUIRRELVM vm);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Initialize the plugin by obtaining the API provided by the host plugin.
|
||||
*/
|
||||
void OnSquirrelInitialize()
|
||||
{
|
||||
// Attempt to import the plugin API exported by the host plugin
|
||||
_SqMod = sq_api_import(_Func);
|
||||
// Did we failed to obtain the plugin exports?
|
||||
if(!_SqMod)
|
||||
OutputError("Failed to attach [%s] on host plugin.", SQXML_NAME);
|
||||
else
|
||||
{
|
||||
// Obtain the Squirrel API
|
||||
_SqAPI = _SqMod->GetSquirrelAPI();
|
||||
// Expand the Squirrel API into global functions
|
||||
sq_api_expand(_SqAPI);
|
||||
}
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Load the module on the virtual machine provided by the host module.
|
||||
*/
|
||||
void OnSquirrelLoad()
|
||||
{
|
||||
// Make sure that we have a valid plugin API
|
||||
if (!_SqMod)
|
||||
return; /* Unable to proceed. */
|
||||
// Obtain the Squirrel API and VM
|
||||
_SqVM = _SqMod->GetSquirrelVM();
|
||||
// Make sure that a valid virtual machine exists
|
||||
if (!_SqVM)
|
||||
return; /* Unable to proceed. */
|
||||
// Set this as the default database
|
||||
DefaultVM::Set(_SqVM);
|
||||
// Register the module API
|
||||
RegisterAPI(_SqVM);
|
||||
// Notify about the current status
|
||||
OutputMessage("Registered: %s", SQXML_NAME);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* The virtual machine is about to be terminated and script resources should be released.
|
||||
*/
|
||||
void OnSquirrelTerminate()
|
||||
{
|
||||
OutputMessage("Terminating: %s", SQXML_NAME);
|
||||
// Release the current database (if any)
|
||||
DefaultVM::Set(NULL);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the module API to make sure we don't run into issues.
|
||||
*/
|
||||
bool CheckAPIVer(CCStr ver)
|
||||
{
|
||||
// Obtain the numeric representation of the API version
|
||||
long vernum = strtol(ver, NULL, 10);
|
||||
// Check against version mismatch
|
||||
if (vernum == SQMOD_API_VER)
|
||||
return true;
|
||||
// Log the incident
|
||||
OutputError("API version mismatch on %s", SQXML_NAME);
|
||||
OutputMessage("=> Requested: %ld Have: %ld", vernum, SQMOD_API_VER);
|
||||
// Invoker should not attempt to communicate through the module API
|
||||
return false;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* React to command sent by other plugins.
|
||||
*/
|
||||
static int OnInternalCommand(unsigned int type, const char * text)
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case SQMOD_INITIALIZE_CMD:
|
||||
if (CheckAPIVer(text))
|
||||
OnSquirrelInitialize();
|
||||
break;
|
||||
case SQMOD_LOAD_CMD:
|
||||
OnSquirrelLoad();
|
||||
break;
|
||||
case SQMOD_TERMINATE_CMD:
|
||||
OnSquirrelTerminate();
|
||||
break;
|
||||
default: break;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* The server was initialized and this plugin was loaded successfully.
|
||||
*/
|
||||
static int OnInitServer()
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
static void OnShutdownServer(void)
|
||||
{
|
||||
// The server may still send callbacks
|
||||
UnbindCallbacks();
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void BindCallbacks()
|
||||
{
|
||||
_Clbk->OnInitServer = OnInitServer;
|
||||
_Clbk->OnInternalCommand = OnInternalCommand;
|
||||
_Clbk->OnShutdownServer = OnShutdownServer;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void UnbindCallbacks()
|
||||
{
|
||||
_Clbk->OnInitServer = NULL;
|
||||
_Clbk->OnInternalCommand = NULL;
|
||||
_Clbk->OnShutdownServer = NULL;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void RegisterAPI(HSQUIRRELVM vm)
|
||||
{
|
||||
Table xmlns(vm);
|
||||
|
||||
xmlns.Bind(_SC("ParseResult"), Class< ParseResult >(vm, _SC("SqXmlParseResult"))
|
||||
/* Constructors */
|
||||
.Ctor()
|
||||
.Ctor< const ParseResult & >()
|
||||
/* Core Metamethods */
|
||||
.Func(_SC("_cmp"), &ParseResult::Cmp)
|
||||
.Func(_SC("_tostring"), &ParseResult::ToString)
|
||||
/* Properties */
|
||||
.Prop(_SC("Valid"), &ParseResult::IsValid)
|
||||
.Prop(_SC("References"), &ParseResult::GetRefCount)
|
||||
.Prop(_SC("Ok"), &ParseResult::IsOk)
|
||||
.Prop(_SC("Status"), &ParseResult::GetStatus)
|
||||
.Prop(_SC("Offset"), &ParseResult::GetOffset)
|
||||
.Prop(_SC("Encoding"), &ParseResult::GetEncoding)
|
||||
.Prop(_SC("Description"), &ParseResult::GetDescription)
|
||||
/* Functions */
|
||||
.Func(_SC("Check"), &ParseResult::Check)
|
||||
);
|
||||
|
||||
xmlns.Bind(_SC("Attribute"), Class< Attribute >(vm, _SC("SqXmlAttribute"))
|
||||
/* Constructors */
|
||||
.Ctor()
|
||||
.Ctor< const Attribute & >()
|
||||
/* Core Metamethods */
|
||||
.Func(_SC("_cmp"), &Attribute::Cmp)
|
||||
.Func(_SC("_tostring"), &Attribute::ToString)
|
||||
/* Properties */
|
||||
.Prop(_SC("Valid"), &Attribute::IsValid)
|
||||
.Prop(_SC("References"), &Attribute::GetRefCount)
|
||||
.Prop(_SC("Empty"), &Attribute::IsEmpty)
|
||||
.Prop(_SC("Hash"), &Attribute::GetHashValue)
|
||||
.Prop(_SC("Name"), &Attribute::GetName, &Attribute::SetName)
|
||||
.Prop(_SC("Value"), &Attribute::GetValue, &Attribute::SetValue)
|
||||
.Prop(_SC("Int"), &Attribute::GetInt, &Attribute::SetInt)
|
||||
.Prop(_SC("Uint"), &Attribute::GetUint, &Attribute::SetUint)
|
||||
.Prop(_SC("Float"), &Attribute::GetFloat, &Attribute::SetFloat)
|
||||
.Prop(_SC("Double"), &Attribute::GetDouble, &Attribute::SetDouble)
|
||||
.Prop(_SC("Long"), &Attribute::GetLong, &Attribute::SetLong)
|
||||
.Prop(_SC("Ulong"), &Attribute::GetUlong, &Attribute::SetUlong)
|
||||
.Prop(_SC("Bool"), &Attribute::GetBool, &Attribute::SetBool)
|
||||
.Prop(_SC("Next"), &Attribute::NextAttribute)
|
||||
.Prop(_SC("Prev"), &Attribute::PrevAttribute)
|
||||
/* Functions */
|
||||
.Func(_SC("SetName"), &Attribute::ApplyName)
|
||||
.Func(_SC("SetValue"), &Attribute::ApplyValue)
|
||||
.Func(_SC("AsString"), &Attribute::AsString)
|
||||
.Func(_SC("AsInt"), &Attribute::AsInt)
|
||||
.Func(_SC("AsUint"), &Attribute::AsUint)
|
||||
.Func(_SC("AsFloat"), &Attribute::AsFloat)
|
||||
.Func(_SC("AsDouble"), &Attribute::AsDouble)
|
||||
.Func(_SC("AsLong"), &Attribute::AsLong)
|
||||
.Func(_SC("AsUlong"), &Attribute::AsUlong)
|
||||
.Func(_SC("AsBool"), &Attribute::AsBool)
|
||||
.Func(_SC("SetString"), &Attribute::ApplyString)
|
||||
.Func(_SC("SetInt"), &Attribute::ApplyInt)
|
||||
.Func(_SC("SetUint"), &Attribute::ApplyUint)
|
||||
.Func(_SC("SetFloat"), &Attribute::ApplyFloat)
|
||||
.Func(_SC("SetDouble"), &Attribute::ApplyDouble)
|
||||
.Func(_SC("SetLong"), &Attribute::ApplyLong)
|
||||
.Func(_SC("SetUlong"), &Attribute::ApplyUlong)
|
||||
.Func(_SC("SetBool"), &Attribute::ApplyBool)
|
||||
);
|
||||
|
||||
xmlns.Bind(_SC("Text"), Class< Text >(vm, _SC("SqXmlText"))
|
||||
/* Constructors */
|
||||
.Ctor()
|
||||
.Ctor< const Text & >()
|
||||
/* Core Metamethods */
|
||||
.Func(_SC("_cmp"), &Text::Cmp)
|
||||
.Func(_SC("_tostring"), &Text::ToString)
|
||||
/* Properties */
|
||||
.Prop(_SC("Valid"), &Text::IsValid)
|
||||
.Prop(_SC("References"), &Text::GetRefCount)
|
||||
.Prop(_SC("Empty"), &Text::IsEmpty)
|
||||
.Prop(_SC("Value"), &Text::GetValue)
|
||||
.Prop(_SC("Int"), &Text::GetInt, &Text::SetInt)
|
||||
.Prop(_SC("Uint"), &Text::GetUint, &Text::SetUint)
|
||||
.Prop(_SC("Float"), &Text::GetFloat, &Text::SetFloat)
|
||||
.Prop(_SC("Double"), &Text::GetDouble, &Text::SetDouble)
|
||||
.Prop(_SC("Long"), &Text::GetLong, &Text::SetLong)
|
||||
.Prop(_SC("Ulong"), &Text::GetUlong, &Text::SetUlong)
|
||||
.Prop(_SC("Bool"), &Text::GetBool, &Text::SetBool)
|
||||
.Prop(_SC("Data"), &Text::GetData)
|
||||
/* Functions */
|
||||
.Func(_SC("AsString"), &Text::AsString)
|
||||
.Func(_SC("AsInt"), &Text::AsInt)
|
||||
.Func(_SC("AsUint"), &Text::AsUint)
|
||||
.Func(_SC("AsFloat"), &Text::AsFloat)
|
||||
.Func(_SC("AsDouble"), &Text::AsDouble)
|
||||
.Func(_SC("AsLong"), &Text::AsLong)
|
||||
.Func(_SC("AsUlong"), &Text::AsUlong)
|
||||
.Func(_SC("AsBool"), &Text::AsBool)
|
||||
.Func(_SC("SetString"), &Text::ApplyString)
|
||||
.Func(_SC("SetInt"), &Text::ApplyInt)
|
||||
.Func(_SC("SetUint"), &Text::ApplyUint)
|
||||
.Func(_SC("SetFloat"), &Text::ApplyFloat)
|
||||
.Func(_SC("SetDouble"), &Text::ApplyDouble)
|
||||
.Func(_SC("SetLong"), &Text::ApplyLong)
|
||||
.Func(_SC("SetUlong"), &Text::ApplyUlong)
|
||||
.Func(_SC("SetBool"), &Text::ApplyBool)
|
||||
);
|
||||
|
||||
xmlns.Bind(_SC("Node"), Class< Node >(vm, _SC("SqXmlNode"))
|
||||
/* Constructors */
|
||||
.Ctor()
|
||||
.Ctor< const Node & >()
|
||||
/* Core Metamethods */
|
||||
.Func(_SC("_cmp"), &Node::Cmp)
|
||||
.Func(_SC("_tostring"), &Node::ToString)
|
||||
/* Properties */
|
||||
.Prop(_SC("Valid"), &Node::IsValid)
|
||||
.Prop(_SC("References"), &Node::GetRefCount)
|
||||
.Prop(_SC("Empty"), &Node::IsEmpty)
|
||||
.Prop(_SC("Hash"), &Node::GetHashValue)
|
||||
.Prop(_SC("OffsetDebug"), &Node::GetOffsetDebug)
|
||||
.Prop(_SC("Type"), &Node::GetType)
|
||||
.Prop(_SC("Name"), &Node::GetName, &Node::SetName)
|
||||
.Prop(_SC("Value"), &Node::GetValue, &Node::SetValue)
|
||||
.Prop(_SC("FirstAttr"), &Node::GetFirstAttr)
|
||||
.Prop(_SC("LastAttr"), &Node::GetLastAttr)
|
||||
.Prop(_SC("FirstChild"), &Node::GetFirstChild)
|
||||
.Prop(_SC("LastChild"), &Node::GetLastChild)
|
||||
.Prop(_SC("NextSibling"), &Node::GetNextSibling)
|
||||
.Prop(_SC("PrevSibling"), &Node::GetPrevSibling)
|
||||
.Prop(_SC("Parent"), &Node::GetParent)
|
||||
.Prop(_SC("Root"), &Node::GetRoot)
|
||||
.Prop(_SC("Text"), &Node::GetText)
|
||||
.Prop(_SC("ChildValue"), &Node::GetChildValue)
|
||||
/* Functions */
|
||||
.Overload< ParseResult (Node::*)(CSStr) >(_SC("AppendBuffer"), &Node::AppendBuffer)
|
||||
.Overload< ParseResult (Node::*)(CSStr, Uint32) >(_SC("AppendBuffer"), &Node::AppendBuffer)
|
||||
.Overload< ParseResult (Node::*)(CSStr, Uint32, Int32) >(_SC("AppendBuffer"), &Node::AppendBuffer)
|
||||
.Func(_SC("SetName"), &Node::ApplyName)
|
||||
.Func(_SC("SetValue"), &Node::ApplyValue)
|
||||
.Func(_SC("GetChild"), &Node::Child)
|
||||
.Func(_SC("GetAttr"), &Node::GetAttribute)
|
||||
.Func(_SC("GetAttribute"), &Node::GetAttribute)
|
||||
.Func(_SC("GetAttrFrom"), &Node::AttributeFrom)
|
||||
.Func(_SC("GetAttributeFrom"), &Node::AttributeFrom)
|
||||
.Func(_SC("GetNextSibling"), &Node::NextSibling)
|
||||
.Func(_SC("GetPrevSibling"), &Node::PrevSibling)
|
||||
.Func(_SC("GetChildValue"), &Node::ChildValue)
|
||||
.Func(_SC("AppendAttr"), &Node::AppendAttr)
|
||||
.Func(_SC("PrependAttr"), &Node::PrependAttr)
|
||||
.Func(_SC("InsertAttrAfter"), &Node::InsertAttrAfter)
|
||||
.Func(_SC("InsertAttrBefore"), &Node::InsertAttrBefore)
|
||||
.Func(_SC("AppendAttrCopy"), &Node::AppendAttrCopy)
|
||||
.Func(_SC("PrependAttrCopy"), &Node::PrependAttrCopy)
|
||||
.Func(_SC("InsertAttrCopyAfter"), &Node::InsertAttrCopyAfter)
|
||||
.Func(_SC("InsertAttrCopyBefore"), &Node::InsertAttrCopyBefore)
|
||||
.Func(_SC("AppendChild"), &Node::AppendChild)
|
||||
.Func(_SC("PrependChild"), &Node::PrependChild)
|
||||
.Func(_SC("AppendChildNode"), &Node::AppendChildNode)
|
||||
.Func(_SC("PrependChildNode"), &Node::PrependChildNode)
|
||||
.Func(_SC("AppendChildType"), &Node::AppendChildType)
|
||||
.Func(_SC("PrependChildType"), &Node::PrependChildType)
|
||||
.Func(_SC("InsertChildAfter"), &Node::InsertChildAfter)
|
||||
.Func(_SC("InsertChildBefore"), &Node::InsertChildBefore)
|
||||
.Func(_SC("InsertChildTypeAfter"), &Node::InsertChildTypeAfter)
|
||||
.Func(_SC("InsertChildTypeBefore"), &Node::InsertChildTypeBefore)
|
||||
.Func(_SC("AppendCopy"), &Node::AppendCopy)
|
||||
.Func(_SC("PrependCopy"), &Node::PrependCopy)
|
||||
.Func(_SC("InsertCopyAfter"), &Node::InsertCopyAfter)
|
||||
.Func(_SC("InsertCopyBefore"), &Node::InsertCopyBefore)
|
||||
.Func(_SC("AppendMove"), &Node::AppendMove)
|
||||
.Func(_SC("PrependMove"), &Node::PrependMove)
|
||||
.Func(_SC("InsertMoveAfter"), &Node::InsertMoveAfter)
|
||||
.Func(_SC("InsertMoveBefore"), &Node::InsertMoveBefore)
|
||||
.Func(_SC("RemoveAttr"), &Node::RemoveAttr)
|
||||
.Func(_SC("RemoveAttrInst"), &Node::RemoveAttrInst)
|
||||
.Func(_SC("RemoveChild"), &Node::RemoveChild)
|
||||
.Func(_SC("RemoveChildInst"), &Node::RemoveChildInst)
|
||||
.Overload< Node (Node::*)(CSStr, CSStr) const >(_SC("FindChildByAttr"), &Node::FindChildByAttr)
|
||||
.Overload< Node (Node::*)(CSStr, CSStr, CSStr) const >(_SC("FindChildByAttr"), &Node::FindChildByAttr)
|
||||
.Func(_SC("FindElemByPath"), &Node::FindElemByPath)
|
||||
);
|
||||
|
||||
xmlns.Bind(_SC("Document"), Class< Document, NoCopy< Document > >(vm, _SC("SqXmlDocument"))
|
||||
/* Constructors */
|
||||
.Ctor()
|
||||
/* Core Metamethods */
|
||||
.Func(_SC("_cmp"), &Document::Cmp)
|
||||
.Func(_SC("_tostring"), &Document::ToString)
|
||||
/* Properties */
|
||||
.Prop(_SC("Valid"), &Document::IsValid)
|
||||
.Prop(_SC("References"), &Document::GetRefCount)
|
||||
.Prop(_SC("Node"), &Document::GetNode)
|
||||
/* Functions */
|
||||
.Overload< void (Document::*)(void) >(_SC("Reset"), &Document::Reset)
|
||||
.Overload< void (Document::*)(const Document &) >(_SC("Reset"), &Document::Reset)
|
||||
.Overload< ParseResult (Document::*)(CSStr) >(_SC("LoadString"), &Document::LoadData)
|
||||
.Overload< ParseResult (Document::*)(CSStr, Uint32) >(_SC("LoadString"), &Document::LoadData)
|
||||
.Overload< ParseResult (Document::*)(CSStr) >(_SC("LoadFile"), &Document::LoadFile)
|
||||
.Overload< ParseResult (Document::*)(CSStr, Uint32) >(_SC("LoadFile"), &Document::LoadFile)
|
||||
.Overload< ParseResult (Document::*)(CSStr, Uint32, Int32) >(_SC("LoadFile"), &Document::LoadFile)
|
||||
.Overload< void (Document::*)(CSStr) >(_SC("SaveFile"), &Document::SaveFile)
|
||||
.Overload< void (Document::*)(CSStr, CSStr) >(_SC("SaveFile"), &Document::SaveFile)
|
||||
.Overload< void (Document::*)(CSStr, CSStr, Uint32) >(_SC("SaveFile"), &Document::SaveFile)
|
||||
.Overload< void (Document::*)(CSStr, CSStr, Uint32, Int32) >(_SC("SaveFile"), &Document::SaveFile)
|
||||
);
|
||||
|
||||
RootTable(vm).Bind(_SC("SqXml"), xmlns);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlNodeType"), Enumeration(vm)
|
||||
.Const(_SC("Null"), Int32(node_null))
|
||||
.Const(_SC("Document"), Int32(node_document))
|
||||
.Const(_SC("Element"), Int32(node_element))
|
||||
.Const(_SC("PCData"), Int32(node_pcdata))
|
||||
.Const(_SC("CData"), Int32(node_cdata))
|
||||
.Const(_SC("Comment"), Int32(node_comment))
|
||||
.Const(_SC("Pi"), Int32(node_pi))
|
||||
.Const(_SC("Declaration"), Int32(node_declaration))
|
||||
.Const(_SC("Doctype"), Int32(node_doctype))
|
||||
);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlParse"), Enumeration(vm)
|
||||
.Const(_SC("Minimal"), Int32(parse_minimal))
|
||||
.Const(_SC("Default"), Int32(parse_default))
|
||||
.Const(_SC("Full"), Int32(parse_full))
|
||||
.Const(_SC("Pi"), Int32(parse_pi))
|
||||
.Const(_SC("Comments"), Int32(parse_comments))
|
||||
.Const(_SC("CData"), Int32(parse_cdata))
|
||||
.Const(_SC("WSPCData"), Int32(parse_ws_pcdata))
|
||||
.Const(_SC("Escapes"), Int32(parse_escapes))
|
||||
.Const(_SC("EOL"), Int32(parse_eol))
|
||||
.Const(_SC("WConvAttribute"), Int32(parse_wconv_attribute))
|
||||
.Const(_SC("WNormAttribute"), Int32(parse_wnorm_attribute))
|
||||
.Const(_SC("Declaration"), Int32(parse_declaration))
|
||||
.Const(_SC("Doctype"), Int32(parse_doctype))
|
||||
.Const(_SC("WSPCDataSingle"), Int32(parse_ws_pcdata_single))
|
||||
.Const(_SC("TrimPCData"), Int32(parse_trim_pcdata))
|
||||
.Const(_SC("Fragment"), Int32(parse_fragment))
|
||||
.Const(_SC("EmbedPCData"), Int32(parse_embed_pcdata))
|
||||
);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlEncoding"), Enumeration(vm)
|
||||
.Const(_SC("Auto"), Int32(encoding_auto))
|
||||
.Const(_SC("Utf8"), Int32(encoding_utf8))
|
||||
.Const(_SC("Utf16LE"), Int32(encoding_utf16_le))
|
||||
.Const(_SC("Utf16BE"), Int32(encoding_utf16_be))
|
||||
.Const(_SC("Utf16"), Int32(encoding_utf16))
|
||||
.Const(_SC("Utf32LE"), Int32(encoding_utf32_le))
|
||||
.Const(_SC("Utf32BE"), Int32(encoding_utf32_be))
|
||||
.Const(_SC("Utf32"), Int32(encoding_utf32))
|
||||
.Const(_SC("WChar"), Int32(encoding_wchar))
|
||||
.Const(_SC("Latin1"), Int32(encoding_latin1))
|
||||
);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlFormat"), Enumeration(vm)
|
||||
.Const(_SC("Indent"), Int32(format_indent))
|
||||
.Const(_SC("WriteBOM"), Int32(format_write_bom))
|
||||
.Const(_SC("Raw"), Int32(format_raw))
|
||||
.Const(_SC("NoDeclaration"), Int32(format_no_declaration))
|
||||
.Const(_SC("NoEscapes"), Int32(format_no_escapes))
|
||||
.Const(_SC("SaveFileText"), Int32(format_save_file_text))
|
||||
.Const(_SC("IndentAttributes"), Int32(format_indent_attributes))
|
||||
.Const(_SC("Default"), Int32(format_default))
|
||||
);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlParseStatus"), Enumeration(vm)
|
||||
.Const(_SC("Ok"), Int32(status_ok))
|
||||
.Const(_SC("FileNotFound"), Int32(status_file_not_found))
|
||||
.Const(_SC("IOError"), Int32(status_io_error))
|
||||
.Const(_SC("OutOfMemory"), Int32(status_out_of_memory))
|
||||
.Const(_SC("InternalError"), Int32(status_internal_error))
|
||||
.Const(_SC("UnrecognizedTag"), Int32(status_unrecognized_tag))
|
||||
.Const(_SC("BadPi"), Int32(status_bad_pi))
|
||||
.Const(_SC("BadComment"), Int32(status_bad_comment))
|
||||
.Const(_SC("BadCData"), Int32(status_bad_cdata))
|
||||
.Const(_SC("BadDoctype"), Int32(status_bad_doctype))
|
||||
.Const(_SC("BadPCData"), Int32(status_bad_pcdata))
|
||||
.Const(_SC("BadStartElement"), Int32(status_bad_start_element))
|
||||
.Const(_SC("BadAttribute"), Int32(status_bad_attribute))
|
||||
.Const(_SC("BadEndElement"), Int32(status_bad_end_element))
|
||||
.Const(_SC("EndElementMismatch"), Int32(status_end_element_mismatch))
|
||||
.Const(_SC("AppendInvalidRoot"), Int32(status_append_invalid_root))
|
||||
.Const(_SC("NoDocumentElement"), Int32(status_no_document_element))
|
||||
);
|
||||
|
||||
ConstTable(vm).Enum(_SC("SqXmlXpathValueType"), Enumeration(vm)
|
||||
.Const(_SC("None"), Int32(xpath_type_none))
|
||||
.Const(_SC("NodeSet"), Int32(xpath_type_node_set))
|
||||
.Const(_SC("Number"), Int32(xpath_type_number))
|
||||
.Const(_SC("String"), Int32(xpath_type_string))
|
||||
.Const(_SC("Boolean"), Int32(xpath_type_boolean))
|
||||
);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void OutputMessageImpl(const char * msg, va_list args)
|
||||
{
|
||||
#if defined(WIN32) || defined(_WIN32)
|
||||
HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
CONSOLE_SCREEN_BUFFER_INFO csb_before;
|
||||
GetConsoleScreenBufferInfo( hstdout, &csb_before);
|
||||
SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN);
|
||||
printf("[SQMOD] ");
|
||||
|
||||
SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
|
||||
vprintf(msg, args);
|
||||
puts("");
|
||||
|
||||
SetConsoleTextAttribute(hstdout, csb_before.wAttributes);
|
||||
#else
|
||||
printf("%c[0;32m[SQMOD]%c[0;37m", 27, 27, msg);
|
||||
vprintf(msg, args);
|
||||
puts("");
|
||||
#endif
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void OutputErrorImpl(const char * msg, va_list args)
|
||||
{
|
||||
#if defined(WIN32) || defined(_WIN32)
|
||||
HANDLE hstdout = GetStdHandle(STD_OUTPUT_HANDLE);
|
||||
|
||||
CONSOLE_SCREEN_BUFFER_INFO csb_before;
|
||||
GetConsoleScreenBufferInfo( hstdout, &csb_before);
|
||||
SetConsoleTextAttribute(hstdout, FOREGROUND_RED | FOREGROUND_INTENSITY);
|
||||
printf("[SQMOD] ");
|
||||
|
||||
SetConsoleTextAttribute(hstdout, FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_RED | FOREGROUND_INTENSITY);
|
||||
vprintf(msg, args);
|
||||
puts("");
|
||||
|
||||
SetConsoleTextAttribute(hstdout, csb_before.wAttributes);
|
||||
#else
|
||||
printf("%c[0;32m[SQMOD]%c[0;37m", 27, 27, msg);
|
||||
vprintf(msg, args);
|
||||
puts("");
|
||||
#endif
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void OutputDebug(const char * msg, ...)
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
// Initialize the arguments list
|
||||
va_list args;
|
||||
va_start(args, msg);
|
||||
// Call the output function
|
||||
OutputMessageImpl(msg, args);
|
||||
// Finalize the arguments list
|
||||
va_end(args);
|
||||
#else
|
||||
SQMOD_UNUSED_VAR(msg);
|
||||
#endif
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void OutputMessage(const char * msg, ...)
|
||||
{
|
||||
// Initialize the arguments list
|
||||
va_list args;
|
||||
va_start(args, msg);
|
||||
// Call the output function
|
||||
OutputMessageImpl(msg, args);
|
||||
// Finalize the arguments list
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
void OutputError(const char * msg, ...)
|
||||
{
|
||||
// Initialize the arguments list
|
||||
va_list args;
|
||||
va_start(args, msg);
|
||||
// Call the output function
|
||||
OutputErrorImpl(msg, args);
|
||||
// Finalize the arguments list
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs* functions, PluginCallbacks* callbacks, PluginInfo* info)
|
||||
{
|
||||
using namespace SqMod;
|
||||
// Output plugin header
|
||||
puts("");
|
||||
OutputMessage("--------------------------------------------------------------------");
|
||||
OutputMessage("Plugin: %s", SQXML_NAME);
|
||||
OutputMessage("Author: %s", SQXML_AUTHOR);
|
||||
OutputMessage("Legal: %s", SQXML_COPYRIGHT);
|
||||
OutputMessage("--------------------------------------------------------------------");
|
||||
puts("");
|
||||
// Attempt to find the host plugin ID
|
||||
int host_plugin_id = functions->FindPlugin((char *)(SQMOD_HOST_NAME));
|
||||
// See if our plugin was loaded after the host plugin
|
||||
if (host_plugin_id < 0)
|
||||
{
|
||||
OutputError("%s could find the host plugin", SQXML_NAME);
|
||||
// Don't load!
|
||||
return SQMOD_FAILURE;
|
||||
}
|
||||
// Should never reach this point but just in case
|
||||
else if (host_plugin_id > (info->nPluginId))
|
||||
{
|
||||
OutputError("%s loaded after the host plugin", SQXML_NAME);
|
||||
// Don't load!
|
||||
return SQMOD_FAILURE;
|
||||
}
|
||||
// Store server proxies
|
||||
_Func = functions;
|
||||
_Clbk = callbacks;
|
||||
_Info = info;
|
||||
// Assign plugin information
|
||||
_Info->uPluginVer = SQXML_VERSION;
|
||||
strcpy(_Info->szName, SQXML_HOST_NAME);
|
||||
// Bind callbacks
|
||||
BindCallbacks();
|
||||
// Notify that the plugin was successfully loaded
|
||||
OutputMessage("Successfully loaded %s", SQXML_NAME);
|
||||
// Dummy spacing
|
||||
puts("");
|
||||
// Done!
|
||||
return SQMOD_SUCCESS;
|
||||
}
|
||||
41
modules/xml/Module.hpp
Normal file
41
modules/xml/Module.hpp
Normal file
@ -0,0 +1,41 @@
|
||||
#ifndef _XML_MODULE_HPP_
|
||||
#define _XML_MODULE_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "SqMod.h"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Proxies to comunicate with the server.
|
||||
*/
|
||||
extern PluginFuncs* _Func;
|
||||
extern PluginCallbacks* _Clbk;
|
||||
extern PluginInfo* _Info;
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Proxies to comunicate with the Squirrel plugin.
|
||||
*/
|
||||
extern HSQAPI _SqAPI;
|
||||
extern HSQEXPORTS _SqMod;
|
||||
extern HSQUIRRELVM _SqVM;
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Output a message only if the _DEBUG was defined.
|
||||
*/
|
||||
void OutputDebug(const char * msg, ...);
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Output a formatted user message to the console.
|
||||
*/
|
||||
void OutputMessage(const char * msg, ...);
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* Output a formatted error message to the console.
|
||||
*/
|
||||
void OutputError(const char * msg, ...);
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_MODULE_HPP_
|
||||
118
modules/xml/Node.cpp
Normal file
118
modules/xml/Node.cpp
Normal file
@ -0,0 +1,118 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Node.hpp"
|
||||
#include "Attribute.hpp"
|
||||
#include "Text.hpp"
|
||||
#include "Module.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Node::Validate() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return true;
|
||||
// Invalid document reference
|
||||
_SqMod->SqThrow("Invalid XML document reference");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Node::SetName(CSStr name)
|
||||
{
|
||||
if (!m_Node.set_name(name))
|
||||
_SqMod->SqThrow("Unable to set XML node name");
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Node::SetValue(CSStr name)
|
||||
{
|
||||
if (!m_Node.set_value(name))
|
||||
_SqMod->SqThrow("Unable to set XML node value");
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::GetFirstAttr() const
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.first_attribute());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::GetLastAttr() const
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.last_attribute());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Text Node::GetText() const
|
||||
{
|
||||
return Text(m_Doc, m_Node.text());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::GetAttribute(CSStr name) const
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.attribute(name));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::AttributeFrom(CSStr name, Attribute & attr) const
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.attribute(name, attr.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::AppendAttr(CSStr name)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.append_attribute(name));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::PrependAttr(CSStr name)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.prepend_attribute(name));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::InsertAttrAfter(CSStr name, const Attribute & attr)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.insert_attribute_after(name, attr.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::InsertAttrBefore(CSStr name, const Attribute & attr)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.insert_attribute_before(name, attr.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::AppendAttrCopy(const Attribute & proto)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.append_copy(proto.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::PrependAttrCopy(const Attribute & proto)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.prepend_copy(proto.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::InsertAttrCopyAfter(const Attribute & proto, const Attribute & attr)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.insert_copy_after(proto.m_Attr, attr.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Attribute Node::InsertAttrCopyBefore(const Attribute & proto, const Attribute & attr)
|
||||
{
|
||||
return Attribute(m_Doc, m_Node.insert_copy_before(proto.m_Attr, attr.m_Attr));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Node::RemoveAttrInst(const Attribute & attr)
|
||||
{
|
||||
return m_Node.remove_attribute(attr.m_Attr);
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
580
modules/xml/Node.hpp
Normal file
580
modules/xml/Node.hpp
Normal file
@ -0,0 +1,580 @@
|
||||
#ifndef _XML_NODE_HPP_
|
||||
#define _XML_NODE_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Common.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* A light-weight handle for manipulating nodes in DOM tree.
|
||||
*/
|
||||
class Node
|
||||
{
|
||||
// --------------------------------------------------------------------------------------------
|
||||
friend class Document;
|
||||
friend class Text;
|
||||
|
||||
protected:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_node Type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Explicit constructor.
|
||||
*/
|
||||
Node(const DocumentRef doc, const Type & node)
|
||||
: m_Doc(doc), m_Node(node)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the document reference and throw an error if invalid.
|
||||
*/
|
||||
bool Validate() const;
|
||||
|
||||
private:
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
DocumentRef m_Doc; /* The main xml document instance. */
|
||||
Type m_Node; /* The managed document node. */
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
Node()
|
||||
: m_Doc(), m_Node()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor. (disabled)
|
||||
*/
|
||||
Node(const Node & o)
|
||||
: m_Doc(o.m_Doc), m_Node(o.m_Node)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~Node()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator. (disabled)
|
||||
*/
|
||||
Node & operator = (const Node & o)
|
||||
{
|
||||
m_Doc = o.m_Doc;
|
||||
m_Node = o.m_Node;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to compare two instances of this type.
|
||||
*/
|
||||
Int32 Cmp(const Node & o)
|
||||
{
|
||||
if (m_Node == o.m_Node)
|
||||
return 0;
|
||||
else if (m_Node > o.m_Node)
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to convert an instance of this type to a string.
|
||||
*/
|
||||
CSStr ToString() const
|
||||
{
|
||||
return m_Node.value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether this instance references a valid xml document.
|
||||
*/
|
||||
bool IsValid() const
|
||||
{
|
||||
return m_Doc;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Return the number of active references to this document instance.
|
||||
*/
|
||||
Uint32 GetRefCount() const
|
||||
{
|
||||
return m_Doc.Count();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether the node is empty.
|
||||
*/
|
||||
bool IsEmpty() const
|
||||
{
|
||||
return m_Node.empty();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get hash value (unique for handles to the same object).
|
||||
*/
|
||||
SQInteger GetHashValue() const
|
||||
{
|
||||
return (SQInteger)m_Node.hash_value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get node offset in parsed file/string (in char_t units) for debugging purposes.
|
||||
*/
|
||||
SQInteger GetOffsetDebug() const
|
||||
{
|
||||
return (SQInteger)m_Node.offset_debug();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve node type.
|
||||
*/
|
||||
Int32 GetType() const
|
||||
{
|
||||
return (Int32)m_Node.type();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve node name.
|
||||
*/
|
||||
CSStr GetName() const
|
||||
{
|
||||
return m_Node.name();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve node name.
|
||||
*/
|
||||
void SetName(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the node name.
|
||||
*/
|
||||
bool ApplyName(CSStr name)
|
||||
{
|
||||
return m_Node.set_name(name);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve node value.
|
||||
*/
|
||||
CSStr GetValue() const
|
||||
{
|
||||
return m_Node.value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve node value.
|
||||
*/
|
||||
void SetValue(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the node value.
|
||||
*/
|
||||
bool ApplyValue(CSStr value)
|
||||
{
|
||||
return m_Node.set_value(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Parses buffer as an XML document fragment and appends all nodes as children of this node.
|
||||
*/
|
||||
ParseResult AppendBuffer(CSStr source)
|
||||
{
|
||||
if (source)
|
||||
return ParseResult(m_Doc, m_Node.append_buffer(source,
|
||||
std::char_traits< SQChar >::length(source) * sizeof(SQChar)));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Parses buffer as an XML document fragment and appends all nodes as children of this node.
|
||||
*/
|
||||
ParseResult AppendBuffer(CSStr source, Uint32 options)
|
||||
{
|
||||
if (source)
|
||||
return ParseResult(m_Doc, m_Node.append_buffer(source,
|
||||
std::char_traits< SQChar >::length(source) * sizeof(SQChar), options));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Parses buffer as an XML document fragment and appends all nodes as children of this node.
|
||||
*/
|
||||
ParseResult AppendBuffer(CSStr source, Uint32 options, Int32 encoding)
|
||||
{
|
||||
if (source)
|
||||
return ParseResult(m_Doc, m_Node.append_buffer(source,
|
||||
std::char_traits< SQChar >::length(source) * sizeof(SQChar)
|
||||
, options, (xml_encoding)encoding));
|
||||
return ParseResult();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the first child attribute.
|
||||
*/
|
||||
Attribute GetFirstAttr() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the last child attribute.
|
||||
*/
|
||||
Attribute GetLastAttr() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the first child node.
|
||||
*/
|
||||
Node GetFirstChild() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.first_child());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the last child node.
|
||||
*/
|
||||
Node GetLastChild() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.last_child());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get next sibling in the children list of the parent node.
|
||||
*/
|
||||
Node GetNextSibling() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.next_sibling());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get previous sibling in the children list of the parent node
|
||||
*/
|
||||
Node GetPrevSibling() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.previous_sibling());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the parent node.
|
||||
*/
|
||||
Node GetParent() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.parent());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the root node.
|
||||
*/
|
||||
Node GetRoot() const
|
||||
{
|
||||
return Node(m_Doc, m_Node.root());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the text object for the current node.
|
||||
*/
|
||||
Text GetText() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve child node with the specified name.
|
||||
*/
|
||||
Node Child(CSStr name) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.child(name));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve child attribute with the specified name.
|
||||
*/
|
||||
Attribute GetAttribute(CSStr name) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve next sibling with the specified name.
|
||||
*/
|
||||
Node NextSibling(CSStr name) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.next_sibling(name));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve previous sibling with the specified name.
|
||||
*/
|
||||
Node PrevSibling(CSStr name) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.previous_sibling(name));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve child attribute, starting the search from a hint.
|
||||
*/
|
||||
Attribute AttributeFrom(CSStr name, Attribute & attr) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Get child value of current node; that is, value of the first child node of type PCDATA/CDATA.
|
||||
*/
|
||||
CSStr GetChildValue() const
|
||||
{
|
||||
return m_Node.child_value();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve child value of child with specified name.
|
||||
*/
|
||||
CSStr ChildValue(CSStr name) const
|
||||
{
|
||||
return m_Node.child_value(name);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a child attribute with the specified name.
|
||||
*/
|
||||
Attribute AppendAttr(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a child attribute with the specified name.
|
||||
*/
|
||||
Attribute PrependAttr(CSStr name);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a child attribute with the specified name, after the specified node.
|
||||
*/
|
||||
Attribute InsertAttrAfter(CSStr name, const Attribute & attr);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a child attribute with the specified name, before the specified node.
|
||||
*/
|
||||
Attribute InsertAttrBefore(CSStr name, const Attribute & attr);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a copy of the specified attribute as a child.
|
||||
*/
|
||||
Attribute AppendAttrCopy(const Attribute & proto);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a copy of the specified attribute as a child.
|
||||
*/
|
||||
Attribute PrependAttrCopy(const Attribute & proto);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a copy of the specified attribute as a child after the specified attribute.
|
||||
*/
|
||||
Attribute InsertAttrCopyAfter(const Attribute & proto, const Attribute & attr);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a copy of the specified attribute as a child before the specified attribute.
|
||||
*/
|
||||
Attribute InsertAttrCopyBefore(const Attribute & proto, const Attribute & attr);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a basic child node with the specified name.
|
||||
*/
|
||||
Node AppendChild(CSStr name)
|
||||
{
|
||||
return Node(m_Doc, m_Node.append_child(name));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a basic child node with the specified name.
|
||||
*/
|
||||
Node PrependChild(CSStr name)
|
||||
{
|
||||
return Node(m_Doc, m_Node.prepend_child(name));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a basic child node.
|
||||
*/
|
||||
Node AppendChildNode()
|
||||
{
|
||||
return Node(m_Doc, m_Node.append_child());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a basic child node.
|
||||
*/
|
||||
Node PrependChildNode()
|
||||
{
|
||||
return Node(m_Doc, m_Node.prepend_child());
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a basic child node with the specified type.
|
||||
*/
|
||||
Node AppendChildType(Int32 type)
|
||||
{
|
||||
return Node(m_Doc, m_Node.append_child((xml_node_type)type));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a basic child node with the specified type.
|
||||
*/
|
||||
Node PrependChildType(Int32 type)
|
||||
{
|
||||
return Node(m_Doc, m_Node.prepend_child((xml_node_type)type));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a basic child node with the specified name, after the specified node.
|
||||
*/
|
||||
Node InsertChildAfter(CSStr name, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_child_after(name, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a basic child node with the specified name, before the specified node.
|
||||
*/
|
||||
Node InsertChildBefore(CSStr name, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_child_before(name, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a basic child node with the specified type, after the specified node.
|
||||
*/
|
||||
Node InsertChildTypeAfter(Int32 type, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_child_after((xml_node_type)type, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a basic child node with the specified type, before the specified node.
|
||||
*/
|
||||
Node InsertChildTypeBefore(Int32 type, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_child_before((xml_node_type)type, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append a copy of the specified node as a child.
|
||||
*/
|
||||
Node AppendCopy(const Node & proto)
|
||||
{
|
||||
return Node(m_Doc, m_Node.append_copy(proto.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend a copy of the specified node as a child.
|
||||
*/
|
||||
Node PrependCopy(const Node & proto)
|
||||
{
|
||||
return Node(m_Doc, m_Node.prepend_copy(proto.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a copy of the specified node as a child after the specified node.
|
||||
*/
|
||||
Node InsertCopyAfter(const Node & proto, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_copy_after(proto.m_Node, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert a copy of the specified node as a child before the specified node.
|
||||
*/
|
||||
Node InsertCopyBefore(const Node & proto, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_copy_before(proto.m_Node, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Append the specified node as a child and take ownersip of it.
|
||||
*/
|
||||
Node AppendMove(const Node & proto)
|
||||
{
|
||||
return Node(m_Doc, m_Node.append_copy(proto.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Prepend the specified node as a child and take ownersip of it.
|
||||
*/
|
||||
Node PrependMove(const Node & proto)
|
||||
{
|
||||
return Node(m_Doc, m_Node.prepend_copy(proto.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert the specified node as a child after the specified node and take ownersip of it.
|
||||
*/
|
||||
Node InsertMoveAfter(const Node & proto, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_copy_after(proto.m_Node, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Insert the specified node as a child before the specified node and take ownersip of it.
|
||||
*/
|
||||
Node InsertMoveBefore(const Node & proto, const Node & node)
|
||||
{
|
||||
return Node(m_Doc, m_Node.insert_copy_before(proto.m_Node, node.m_Node));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Remove the child attribute matching the specified name.
|
||||
*/
|
||||
bool RemoveAttr(CSStr name)
|
||||
{
|
||||
return m_Node.remove_attribute(name);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Remove the specified attribute.
|
||||
*/
|
||||
bool RemoveAttrInst(const Attribute & attr);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Remove the child node matching the specified name.
|
||||
*/
|
||||
bool RemoveChild(CSStr name)
|
||||
{
|
||||
return m_Node.remove_child(name);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Remove the specified node.
|
||||
*/
|
||||
bool RemoveChildInst(const Node & node)
|
||||
{
|
||||
return m_Node.remove_child(node.m_Node);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Find child node by attribute name/value.
|
||||
*/
|
||||
Node FindChildByAttr(CSStr attr_name, CSStr attr_value) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.find_child_by_attribute(attr_name, attr_value));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Find child node by attribute name/value.
|
||||
*/
|
||||
Node FindChildByAttr(CSStr name, CSStr attr_name, CSStr attr_value) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.find_child_by_attribute(name, attr_name, attr_value));
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Search for a node by path consisting of node names and . or .. elements.
|
||||
*/
|
||||
Node FindElemByPath(CSStr path, SQChar delimiter) const
|
||||
{
|
||||
return Node(m_Doc, m_Node.first_element_by_path(path, delimiter));
|
||||
}
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_NODE_HPP_
|
||||
198
modules/xml/Text.cpp
Normal file
198
modules/xml/Text.cpp
Normal file
@ -0,0 +1,198 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Text.hpp"
|
||||
#include "Node.hpp"
|
||||
#include "Module.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include <string.h>
|
||||
#include <sqrat.h>
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Text::Validate() const
|
||||
{
|
||||
if (m_Doc)
|
||||
return true;
|
||||
// Invalid document reference
|
||||
_SqMod->SqThrow("Invalid XML document reference");
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Int32 Text::Cmp(const Text & o)
|
||||
{
|
||||
if (strcmp(m_Text.get(), o.m_Text.get()) == 0)
|
||||
return 0;
|
||||
else if (strlen(m_Text.get()) > strlen(o.m_Text.get()))
|
||||
return 1;
|
||||
else
|
||||
return -1;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Text::AsLong(Object & def) const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object >::push(_SqVM, def);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushSLongObject(_SqVM, m_Text.as_llong(longint));
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Text::AsUlong(Object & def) const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object >::push(_SqVM, def);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushULongObject(_SqVM, m_Text.as_ullong(longint));
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Text::ApplyLong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Whether the operation succeeded
|
||||
bool res = false;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
res = m_Text.set(longint);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the result
|
||||
return res;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool Text::ApplyUlong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Whether the operation succeeded
|
||||
bool res = false;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
res = m_Text.set(longint);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the result
|
||||
return res;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Text::GetLong() const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushSLongObject(_SqVM, m_Text.as_llong());
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Text::SetLong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Int64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetSLongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
m_Text = longint;
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Object Text::GetUlong() const
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push a long integer instance with the requested value on the stack
|
||||
_SqMod->PushULongObject(_SqVM, m_Text.as_ullong());
|
||||
// Obtain the object from the stack
|
||||
Var< Object > inst(_SqVM, -1);
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
// Return the long integer instance
|
||||
return inst.value;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void Text::SetUlong(Object & value)
|
||||
{
|
||||
// Obtain the initial stack size
|
||||
const Int32 top = sq_gettop(_SqVM);
|
||||
// Push the specified object onto the stack
|
||||
Var< Object & >::push(_SqVM, value);
|
||||
// The resulted long integer value
|
||||
Uint64 longint = 0;
|
||||
// Attempt to get the numeric value inside the specified object
|
||||
if (SQ_FAILED(_SqMod->GetULongValue(_SqVM, -1, &longint)))
|
||||
_SqMod->SqThrow("Invalid long integer specified");
|
||||
// Assign the obtained value
|
||||
else
|
||||
m_Text = longint;
|
||||
// Remove an pushed values (if any) to restore the stack
|
||||
sq_pop(_SqVM, sq_gettop(_SqVM) - top);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
Node Text::GetData() const
|
||||
{
|
||||
return Node(m_Doc, m_Text.data());
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
365
modules/xml/Text.hpp
Normal file
365
modules/xml/Text.hpp
Normal file
@ -0,0 +1,365 @@
|
||||
#ifndef _XML_TEXT_HPP_
|
||||
#define _XML_TEXT_HPP_
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Common.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
/* ------------------------------------------------------------------------------------------------
|
||||
* A helper for working with text inside PCDATA nodes.
|
||||
*/
|
||||
class Text
|
||||
{
|
||||
// --------------------------------------------------------------------------------------------
|
||||
friend class Node;
|
||||
|
||||
protected:
|
||||
|
||||
// --------------------------------------------------------------------------------------------
|
||||
typedef xml_text Type;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Explicit constructor.
|
||||
*/
|
||||
Text(const DocumentRef doc, const Type & text)
|
||||
: m_Doc(doc), m_Text(text)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Validate the document reference and throw an error if invalid.
|
||||
*/
|
||||
bool Validate() const;
|
||||
|
||||
private:
|
||||
|
||||
// ---------------------------------------------------------------------------------------------
|
||||
DocumentRef m_Doc; /* The main xml document instance. */
|
||||
Type m_Text; /* The managed document node. */
|
||||
|
||||
public:
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Default constructor.
|
||||
*/
|
||||
Text()
|
||||
: m_Doc(), m_Text()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy constructor. (disabled)
|
||||
*/
|
||||
Text(const Text & o)
|
||||
: m_Doc(o.m_Doc), m_Text(o.m_Text)
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Destructor.
|
||||
*/
|
||||
~Text()
|
||||
{
|
||||
/* ... */
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Copy assignment operator. (disabled)
|
||||
*/
|
||||
Text & operator = (const Text & o)
|
||||
{
|
||||
m_Doc = o.m_Doc;
|
||||
m_Text = o.m_Text;
|
||||
return *this;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to compare two instances of this type.
|
||||
*/
|
||||
Int32 Cmp(const Text & o);
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Used by the script engine to convert an instance of this type to a string.
|
||||
*/
|
||||
CSStr ToString() const
|
||||
{
|
||||
return m_Text.get();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether this instance references a valid xml document.
|
||||
*/
|
||||
bool IsValid() const
|
||||
{
|
||||
return m_Doc;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Return the number of active references to this document instance.
|
||||
*/
|
||||
Uint32 GetRefCount() const
|
||||
{
|
||||
return m_Doc.Count();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* See whether the text is empty.
|
||||
*/
|
||||
bool IsEmpty() const
|
||||
{
|
||||
return m_Text.empty();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the text value.
|
||||
*/
|
||||
CSStr GetValue() const
|
||||
{
|
||||
return m_Text.get();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a string or the specified default value if empty.
|
||||
*/
|
||||
CSStr AsString(CSStr def) const
|
||||
{
|
||||
return m_Text.as_string(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a integer or the specified default value if empty.
|
||||
*/
|
||||
Int32 AsInt(Int32 def) const
|
||||
{
|
||||
return m_Text.as_int(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned integer or the specified default value if empty.
|
||||
*/
|
||||
Uint32 AsUint(Uint32 def) const
|
||||
{
|
||||
return m_Text.as_uint(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a floating point or the specified default value if empty.
|
||||
*/
|
||||
SQFloat AsFloat(SQFloat def) const
|
||||
{
|
||||
return (SQFloat)m_Text.as_float(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a double floating point or the specified default value if empty.
|
||||
*/
|
||||
SQFloat AsDouble(SQFloat def) const
|
||||
{
|
||||
return (SQFloat)m_Text.as_double(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a long integer or the specified default value if empty.
|
||||
*/
|
||||
Object AsLong(Object & def) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned long integer or the specified default value if empty.
|
||||
*/
|
||||
Object AsUlong(Object & def) const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a boolean or the specified default value if empty.
|
||||
*/
|
||||
bool AsBool(bool def) const
|
||||
{
|
||||
return m_Text.as_bool(def);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a string.
|
||||
*/
|
||||
bool ApplyString(CSStr value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a integer.
|
||||
*/
|
||||
bool ApplyInt(Int32 value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned integer.
|
||||
*/
|
||||
bool ApplyUint(Uint32 value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a floating point.
|
||||
*/
|
||||
bool ApplyFloat(SQFloat value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a double floating point.
|
||||
*/
|
||||
bool ApplyDouble(SQFloat value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a long integer.
|
||||
*/
|
||||
bool ApplyLong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned long integer.
|
||||
*/
|
||||
bool ApplyUlong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a boolean.
|
||||
*/
|
||||
bool ApplyBool(bool value)
|
||||
{
|
||||
return m_Text.set(value);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a string.
|
||||
*/
|
||||
CSStr GetString() const
|
||||
{
|
||||
return m_Text.as_string();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a string.
|
||||
*/
|
||||
void SetString(CSStr value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a integer.
|
||||
*/
|
||||
Int32 GetInt() const
|
||||
{
|
||||
return m_Text.as_int();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a integer.
|
||||
*/
|
||||
void SetInt(Int32 value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned integer.
|
||||
*/
|
||||
Uint32 GetUint() const
|
||||
{
|
||||
return m_Text.as_uint();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned integer.
|
||||
*/
|
||||
void SetUint(Uint32 value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a floating point.
|
||||
*/
|
||||
SQFloat GetFloat() const
|
||||
{
|
||||
return (SQFloat)m_Text.as_float();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a floating point.
|
||||
*/
|
||||
void SetFloat(SQFloat value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a double floating point.
|
||||
*/
|
||||
SQFloat GetDouble() const
|
||||
{
|
||||
return (SQFloat)m_Text.as_double();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a double floating point.
|
||||
*/
|
||||
void SetDouble(SQFloat value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a long integer.
|
||||
*/
|
||||
Object GetLong() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a long integer.
|
||||
*/
|
||||
void SetLong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a unsigned long integer.
|
||||
*/
|
||||
Object GetUlong() const;
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a unsigned long integer.
|
||||
*/
|
||||
void SetUlong(Object & value);
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the value as a boolean.
|
||||
*/
|
||||
bool GetBool() const
|
||||
{
|
||||
return m_Text.as_bool();
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Modify the value as a boolean.
|
||||
*/
|
||||
void SetBool(bool value)
|
||||
{
|
||||
m_Text = value;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------------------------
|
||||
* Retrieve the data node (node_pcdata or node_cdata) for this object.
|
||||
*/
|
||||
Node GetData() const;
|
||||
};
|
||||
|
||||
} // Namespace:: SqMod
|
||||
|
||||
#endif // _XML_TEXT_HPP_
|
||||
Reference in New Issue
Block a user