ParsingXml.cpp

#include "ParsingXml.h"

namespace

{

namespace

parsing

{

namespace

xml

{

using

namespace

stream

;

using

namespace

collections

;

using

namespace

regex

;

/*********************************************************************** Unescaping Function Foward Declarations ***********************************************************************/

void

XmlMergeTextFragment

(

collections

List

Ptr

XmlNode

>>&

value

const

collections

List

regex

RegexToken

tokens

) {

vint

begin

;

vint

end

;

for

(

vint

value

Count

()-

;

>=-

;

--) {

(

==-

) {

(

end

!=-

)

begin

; }

else

(

value

[

Cast

XmlText

>()) {

(

end

==-

)

end

; }

else

{

(

end

!=-

)

begin

; }

(

begin

!=-

end

!=-

) {

vint

tokenBegin

value

[

begin

Cast

XmlText

>()

content

tokenIndex

;

vint

tokenEnd

value

[

end

Cast

XmlText

>()

content

tokenIndex

;

while

(

tokenBegin

) {

(

tokens

Get

(

tokenBegin

token

==(

vint

)

XmlParserTokenIndex

SPACE

tokens

Get

(

tokenBegin

token

==-

) {

tokenBegin

--; }

else

{

break

; } }

while

(

tokenEnd

tokens

Count

()-

) {

(

tokens

Get

(

tokenEnd

token

==(

vint

)

XmlParserTokenIndex

SPACE

tokens

Get

(

tokenEnd

token

==-

) {

tokenEnd

++; }

else

{

break

; } }

const

RegexToken

beginToken

tokens

Get

(

tokenBegin

);

const

RegexToken

endToken

tokens

Get

(

tokenEnd

);

const

wchar_t

textBegin

beginToken

reading

;

const

wchar_t

textEnd

endToken

reading

endToken

length

;

WString

text

(

textBegin

vint

(

textEnd

textBegin

));

ParsingTextRange

range

beginToken

, &

endToken

);

Ptr

XmlText

xmlText

new

XmlText

;

xmlText

codeRange

range

;

xmlText

content

codeRange

range

;

xmlText

content

value

XmlUnescapeValue

(

text

);

value

RemoveRange

(

begin

end

begin

);

value

Insert

(

begin

xmlText

);

begin

;

end

; } } }

void

XmlUnescapeAttributeValue

(

parsing

ParsingToken

value

const

collections

List

regex

RegexToken

tokens

) {

value

XmlUnescapeValue

(

value

Sub

(

value

Length

()-

)); }

void

XmlUnescapeCData

(

parsing

ParsingToken

value

const

collections

List

regex

RegexToken

tokens

) {

value

XmlUnescapeCData

(

value

); }

void

XmlUnescapeComment

(

parsing

ParsingToken

value

const

collections

List

regex

RegexToken

tokens

) {

value

XmlUnescapeComment

(

value

); }

/*********************************************************************** XmlPrintVisitor ***********************************************************************/

class

XmlPrintVisitor

public

Object

public

XmlNode

IVisitor

{

public

TextWriter

writer

;

XmlPrintVisitor

(

TextWriter

_writer

) :writer(

_writer

) { }

void

Visit

(

XmlText

node

) {

writer

WriteString

(

XmlEscapeValue

(

node

content

value

)); }

void

Visit

(

XmlCData

node

) {

writer

WriteString

(

XmlEscapeCData

(

node

content

value

)); }

void

Visit

(

XmlAttribute

node

) {

writer

WriteString

(

node

name

value

);

writer

WriteString

(

L"=\""

);

writer

WriteString

(

XmlEscapeValue

(

node

value

));

writer

WriteString

(

L"\""

); }

void

Visit

(

XmlComment

node

) {

writer

WriteString

(

XmlEscapeComment

(

node

content

value

)); }

void

Visit

(

XmlElement

node

) {

writer

WriteChar

(

L'<'

);

writer

WriteString

(

node

name

value

);

FOREACH(Ptr<XmlAttribute>, att, node->attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

writer

WriteChar

(

L' '

);

att

(

this

); }

(

node

subNodes

Count

()==

) {

writer

WriteString

(

L"/>"

); }

else

{

writer

WriteChar

(

L'>'

);

FOREACH(Ptr<XmlNode>, subNode, node->subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlNode

subNode

;

__foreach_iterator__

(

subNode

);)

{

subNode

(

this

); }

writer

WriteString

(

L"</"

);

writer

WriteString

(

node

name

value

);

writer

WriteChar

(

L'>'

); } }

void

Visit

(

XmlInstruction

node

) {

writer

WriteString

(

L"<?"

);

writer

WriteString

(

node

name

value

);

FOREACH(Ptr<XmlAttribute>, att, node->attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

writer

WriteChar

(

L' '

);

att

(

this

); }

writer

WriteString

(

L"?>"

); }

void

Visit

(

XmlDocument

node

) {

FOREACH(Ptr<XmlNode>, prolog, node->prologs)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

node

prologs

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlNode

prolog

;

__foreach_iterator__

(

prolog

);)

{

prolog

(

this

); }

node

rootElement

(

this

); } };

/*********************************************************************** API ***********************************************************************/

WString

XmlEscapeValue

(

const

WString

value

) {

WString

result

;

const

wchar_t

reading

value

Buffer

();

while

(

wchar_t

reading

++) {

switch

(

) {

case

L'<'

result

L"<"

;

break

;

case

L'>'

result

L">"

;

break

;

case

L'&'

result

L"&"

;

break

;

case

L'\''

result

L"'"

;

break

;

case

L'\"'

result

L"""

;

break

;

default

result

; } }

return

result

; }

WString

XmlUnescapeValue

(

const

WString

value

) {

WString

result

;

const

wchar_t

reading

value

Buffer

();

while

reading

) {

(

wcsncmp

(

reading

L"<"

)==

) {

result

L'<'

;

reading

; }

else

(

wcsncmp

(

reading

L">"

)==

) {

result

L'>'

;

reading

; }

else

(

wcsncmp

(

reading

L"&"

)==

) {

result

L'&'

;

reading

; }

else

(

wcsncmp

(

reading

L"'"

)==

) {

result

L'\''

;

reading

; }

else

(

wcsncmp

(

reading

L"""

)==

) {

result

L'\"'

;

reading

; }

else

{

result

reading

++; } }

return

result

; }

WString

XmlEscapeCData

(

const

WString

value

) {

return

L"<![CDATA["

value

L"]]>"

; }

WString

XmlUnescapeCData

(

const

WString

value

) {

return

value

Sub

(

value

Length

()-

); }

WString

XmlEscapeComment

(

const

WString

value

) {

return

L"<!--"

value

L"-->"

; }

WString

XmlUnescapeComment

(

const

WString

value

) {

return

value

Sub

(

value

Length

()-

); }

void

XmlPrint

(

Ptr

XmlNode

node

stream

TextWriter

writer

) {

XmlPrintVisitor

visitor

(

writer

);

node

visitor

); }

void

XmlPrintContent

(

Ptr

XmlElement

element

stream

TextWriter

writer

) {

XmlPrintVisitor

visitor

(

writer

);

FOREACH(Ptr<XmlNode>, node, element->subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

element

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlNode

node

;

__foreach_iterator__

(

node

);)

{

node

visitor

); } }

WString

XmlToString

(

Ptr

XmlNode

node

) {

return

GenerateToStream

([&](

StreamWriter

writer

) {

XmlPrint

(

node

writer

); }); }

/*********************************************************************** Linq To Xml ***********************************************************************/

Ptr

XmlAttribute

XmlGetAttribute

(

Ptr

XmlElement

element

const

WString

name

) {

return

XmlGetAttribute

(

element

Obj

(),

name

); }

Ptr

XmlElement

XmlGetElement

(

Ptr

XmlElement

element

const

WString

name

) {

return

XmlGetElement

(

element

Obj

(),

name

); }

collections

LazyList

Ptr

XmlElement

XmlGetElements

(

Ptr

XmlElement

element

) {

return

XmlGetElements

(

element

Obj

()); }

collections

LazyList

Ptr

XmlElement

XmlGetElements

(

Ptr

XmlElement

element

const

WString

name

) {

return

XmlGetElements

(

element

Obj

(),

name

); }

WString

XmlGetValue

(

Ptr

XmlElement

element

) {

return

XmlGetValue

(

element

Obj

()); }

Ptr

XmlAttribute

XmlGetAttribute

(

XmlElement

element

const

WString

name

) {

FOREACH(Ptr<XmlAttribute>, att, element->attributes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlAttribute

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

element

attributes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlAttribute

att

;

__foreach_iterator__

(

att

);)

{

(

att

name

value

name

) {

return

att

; } }

return

; }

Ptr

XmlElement

XmlGetElement

(

XmlElement

element

const

WString

name

) {

FOREACH(Ptr<XmlNode>, node, element->subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

element

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlNode

node

;

__foreach_iterator__

(

node

);)

{

Ptr

XmlElement

subElement

node

Cast

XmlElement

>();

(

subElement

name

value

name

) {

return

subElement

; } }

return

; }

collections

LazyList

Ptr

XmlElement

XmlGetElements

(

XmlElement

element

) {

return

From

(

element

subNodes

) .FindType<

XmlElement

>(); }

collections

LazyList

Ptr

XmlElement

XmlGetElements

(

XmlElement

element

const

WString

name

) {

return

From

(

element

subNodes

) .FindType<

XmlElement

>() .Where([name](

Ptr

XmlElement

){

return

name

value

name

;}); }

WString

XmlGetValue

(

XmlElement

element

) {

WString

result

;

FOREACH(Ptr<XmlNode>, node, element->subNodes)

(

bool

__scope_variable_flag__

true

)

for

(

const

collections

ForEachIterator

Ptr

XmlNode

>>&

__foreach_iterator__

= ::

collections

CreateForEachIterator

(

element

subNodes

);

__scope_variable_flag__

;

__scope_variable_flag__

false

)

for

(

Ptr

XmlNode

node

;

__foreach_iterator__

(

node

);)

{

(

Ptr

XmlText

text

node

Cast

XmlText

>()) {

result

text

content

value

; }

else

(

Ptr

XmlCData

text

node

Cast

XmlCData

>()) {

result

text

content

value

; } }

return

result

; }

/*********************************************************************** XmlElementWriter ***********************************************************************/

XmlElementWriter

(

Ptr

XmlElement

_element

const

XmlElementWriter

_previousWriter

) :element(

_element

) ,previousWriter(

_previousWriter

) { }

XmlElementWriter

() { }

const

XmlElementWriter

Attribute

(

const

WString

name

const

WString

value

)

const

{

Ptr

XmlAttribute

node

new

XmlAttribute

;

node

name

value

name

;

node

value

;

element

attributes

Add

(

node

);

return

this

; }

XmlElementWriter

Element

(

const

WString

name

)

const

{

Ptr

XmlElement

node

new

XmlElement

;

node

name

value

name

;

element

subNodes

Add

(

node

);

return

XmlElementWriter

(

node

this

); }

const

XmlElementWriter

End

()

const

{

return

previousWriter

; }

const

XmlElementWriter

Text

(

const

WString

value

)

const

{

Ptr

XmlText

node

new

XmlText

;

node

content

value

;

element

subNodes

Add

(

node

);

return

this

; }

const

XmlElementWriter

CData

(

const

WString

value

)

const

{

Ptr

XmlCData

node

new

XmlCData

;

node

content

value

;

element

subNodes

Add

(

node

);

return

this

; }

const

XmlElementWriter

Comment

(

const

WString

value

)

const

{

Ptr

XmlComment

node

new

XmlComment

;

node

content

value

;

element

subNodes

Add

(

node

);

return

this

; } } } }