als.utils/src/Convert.p at master · parser3/als.utils · GitHub

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


@CLASS
Als/Utils/Convert


@auto[]
$sClassName[Convert]


@object2str[uValue;sType]
^if(!def $sType){
	$sType[^if($uValue is "double" || $uValue is "int"){^Als/Utils/Lib:getType($uValue)}{^Als/Utils/Lib:getType[$uValue]}]
}
$result[^switch[$sType]{
	^case[string]{$uValue}
	^case[double;int]{$uValue}
	^case[date]{^self.date2str[$uValue]}
	^case[bool]{^self.bool2str($uValue)}
	^case[hash]{^self.hash2str[$uValue]}
	^case[table]{^self.table2str[$uValue]}
	^case[file]{^self.file2str[$uValue]}
	^case[xdoc]{^self.xdoc2str[$uValue]}
	^case[xnode]{^self.xnode2str[$uValue]}
	^case[DEFAULT]{^throw[$sClassName;Converting '$sType' to string not implemented.]} ^rem{ *** image, user objects *** }
}]


@str2object[sType;sValue]
^switch[$sType]{
	^case[string]{$result[$sValue]}
	^case[double]{$result(^sValue.double[])}
	^case[int]{$result(^sValue.int[])}
	^case[date]{$result[^self.str2date[$sValue]]}
	^case[bool]{$result(^self.str2bool[$sValue])}
	^case[hash]{$result[^self.str2hash[$sValue]]}
	^case[table]{$result[^self.str2table[$sValue]]}
	^case[file]{$result[^self.str2file[$sValue]]}
	^case[xdoc]{$result[^self.str2xdoc[$sValue]]}
	^case[xnode]{$result[^self.str2xnode[$sValue]]}
	^case[DEFAULT]{^throw[$sClassName;Converting string to '$sType' not implemented.]} ^rem{ *** image, user objects *** }
}


@bool2str[bValue]
$result[^if($bValue){1}{0}]


@date2str[dtValue]
$result[^dtValue.sql-string[]]


@table2str[tValue][tColumn]
$tColumn[^tValue.columns[]]
$result[^tColumn.menu{$tColumn.column^#09}^#0A^tValue.menu{^tColumn.menu{$tValue.[$tColumn.column]^#09}}[^#0A]]


@hash2str[hValue]
$result[^self.table2str[^self.hash2table[$hValue]]]


@file2str[fValue]
$result[^fValue.base64[]]


@xdoc2str[xDoc]
$result[^xDoc.string[
	$.omit-xml-declaration[yes]
	$.indent[no]
]]
$result[^result.match[<!DOCTYPE[^^>]+>\s*][i]{}]
$result[^result.trim[]]


@xnode2str[xNode]
$result[^self.xdoc2str[^self.xnode2xdoc[$xNode]]]


@str2bool[sValue]
$result(^sValue.bool[])


@str2date[sValue]
$result[^date::create[$sValue]]


@str2table[sValue]
$result[^table::create{$sValue}]


@str2hash[sValue]
$result[^self.table2hash[^self.str2table[$sValue]]]


@str2file[sValue]
$result[^file::base64[$sValue]]


@str2xdoc[sValue]
$result[^xdoc::create{<?xml version="1.0" encoding="$request:charset"?>$sValue}]


@str2xnode[sValue][xDoc]
$result[^self.xdoc2xnode[^self.str2xdoc[$sValue]]]


@hash2table[hData;sParent][sKey;uValue;sType;sValue]
$result[^table::create{parent	key	type	value}]
^hData.foreach[sKey;uValue]{
	$sType[^Als/Utils/Lib:getType[$uValue]]
	$sValue[^switch[$sType]{
		^case[hash]{}
		^case[table]{^throw[$sClassName;Not implemented yet.]^self.table2str[$uValue]}
		^case[DEFAULT]{^self.object2str[$uValue;$sType]}
	}]
	^result.append{^taint[$sParent]	^taint[$sKey]	$sType^if(def $sValue){	^taint[$sValue]}}
	^if($sType eq "hash"){
		^result.join[^self.hash2table[$uValue;$sKey]]
	}
}


@table2hash[tData;hTree;sParent][tLevel]
$result[^hash::create[]]
^if(!def $hTree){
	$hTree[^tData.hash[parent][$.distinct[tables]]]
	$sParent[]
}
^if($hTree.$sParent){
	$tLevel[$hTree.$sParent]
	^tLevel.menu{
		$result.[$tLevel.key][^switch[$tLevel.type]{
			^case[hash]{^self.table2hash[;$hTree;$tLevel.key]}
			^case[table]{^throw[$sClassName;Not implemented yet.]^self.str2table[^taint[as-is][$uValue]]}
			^case[DEFAULT]{^self.str2object[$tLevel.type;^taint[as-is][$tLevel.value]]}
		}]
	}
}


@xnode2xdoc[xNode][_tmp]
$result[^self.str2xdoc[<root/>]]
$_tmp[^result.documentElement.appendChild[^result.importNode[$xNode](1)]]


@xdoc2xnode[xDoc]
$result[$xDoc.documentElement.firstChild]