-
Notifications
You must be signed in to change notification settings - Fork 4
/
Util.cfc
254 lines (189 loc) · 6.27 KB
/
Util.cfc
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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
component
{
/** return <code>java.util.ArrayList</code> that enables passed-by-reference in ColdFusion */
array function arrayListNew(Array array)
{
return isNull(array) ?
createObject("java","java.util.ArrayList").init() :
createObject("java","java.util.ArrayList").init(array);
}
boolean function isArrayList(obj)
{
return isNull(obj) ? false : isInstanceOf(obj, "java.util.ArrayList");
}
/** return <code>java.util.LinkedHashMap</code> that preserves order of insertion */
struct function orderedStructNew()
{
return createObject("java","java.util.LinkedHashMap").init();
}
boolean function isOrderedStruct(obj)
{
return !isNull(obj) && isInstanceOf(obj, "java.util.LinkedHashMap");
}
/** return <code>org.bson.types.ObjectId</code> */
function objectIdNew(string id)
{
return isNull(id) ?
createObject("java","org.bson.types.ObjectId").init() :
createObject("java","org.bson.types.ObjectId").init(id);
}
boolean function isObjectID(obj)
{
return isNull(obj) ? false : isInstanceOf(obj, "org.bson.types.ObjectId");
}
function dbObjectNew(required obj)
{
if (isStruct(obj))
{
var dbObject = createObject("java", "com.mongodb.BasicDBObject").init();
for (local.key in obj)
{
// convert '_id' and Modifier Operations into the correct case
if (compareNoCase(key,"_ID")==0)
key = "_id";
else if (key.startsWith("$"))
key = replaceList(lcase(key), "$addtoset,$pushall,$putall,$maxdistance", "$addToSet,$pushAll,$putAll,$maxDistance");
if (!structKeyExists(obj, key))
dbObject[key] = javacast("null","");
else
{
var value = obj[key];
if (isStruct(value) || (isArray(value) && !isBinary(value)))
value = dbObjectNew(value);
dbObject[key] = value;
}
}
return dbObject;
}
else if (isArray(obj))
{
var dbObject = createObject("java", "com.mongodb.BasicDBList").init();
for (local.item in obj)
{
if (isNull(item))
arrayAppend(dbObject, javacast("null",""));
else
{
if (isStruct(item) || (isArray(item) && !isBinary(item)))
item = dbObjectNew(item);
arrayAppend(dbObject, isNull(item) ? javacast("null","") : item);
}
}
return dbObject;
}
return obj;
}
boolean function isDBObject(obj)
{
return !isNull(obj) && isInstanceOf(obj, "com.mongodb.DBObject");
}
/** search for struct with key '$ref' and create DBRef objects for the struct */
struct function toDBRef(required struct obj, required DB db)
{
var searchResults = structFindKey(obj, "$ref", "all");
for (local.result in searchResults)
{
var dbRefStruct = result.owner;
var dbRef = createObject("java","com.mongodb.DBRef").init(db.getDB(), dbRefStruct["$ref"], dbRefStruct["$id"]);
var path = left(result.path, len(result.path) - len(".$ref")); // path of struct that contains $ref
evaluate("obj#path# = dbRef");
}
return obj;
}
/** @db passed in to resolve DBRef */
struct function toDBObject(required Struct struct, DB db)
{
javaTyped(struct);
return isNull(db) ? dbObjectNew(struct) : dbObjectNew( toDBRef(struct, db) );
}
/** convert key "_id" from string to ObjectID */
struct function boxObjectID(required struct obj)
{
if (obj.containsKey("_id") && isSimpleValue(obj["_id"]))
obj["_id"] = objectIdNew(obj["_id"]);
return obj;
}
/** convert key "_id" from ObjectID to string */
struct function unboxObjectID(required struct obj)
{
if (obj.containsKey("_id") && isObjectID(obj["_id"]))
obj["_id"] = obj["_id"].toString();
return obj;
}
Date function getTimestamp(required struct obj)
{
if (!structKeyExists(obj, "_id") || !isObjectID(obj["_id"]))
throw (message="timestamp not available from '_id'");
return createObject("java", "java.util.Date").init(obj["_id"].getTime());
}
/**
return <code>java.util.regex.Pattern</code>
@flags List or Array of 'CANON_EQ', 'CASE_INSENSITIVE', 'COMMENTS', 'DOTALL', 'LITERAL', 'MULTILINE', 'UNICODE_CASE', 'UNIX_LINES'
*/
function reCompile(required String regex, flags)
{
var pattern = createObject("java","java.util.regex.Pattern");
if (isNull(flags))
local.compiled = pattern.compile(regex);
else
{
if (isSimpleValue(flags))
flags = listToArray(flags);
var flagInt = 0;
for (local.flagName in flags)
flagInt += pattern[flagName];
local.compiled = pattern.compile(regex, javacast("int", flagInt));
}
return local.compiled;
}
/** convert ColdFusion variable type into Java's equivalent.
String -> java.lang.String (unchanged).
Numeric -> double, int or long.
Boolean -> boolean.
Date -> java.util.Date (unchanged).
Array -> convert items into Java's equivalent.
Struct -> convert items into Java's equivalent.
GUID/UUID -> java.util.UUID
UDF -> null.
*/
function javaTyped(obj)
{
if (isNull(obj) || isCustomFunction(obj))
return;
if (isSimpleValue(obj))
{
if (isNumeric(obj))
{
if (obj != int(obj))
return javacast("double", obj);
// between java.lang.Integer.MIN_VALUE and java.lang.Integer.MAX_VALUE
if (-2147483648 <= obj && obj <= 2147483647)
return javacast("int", obj);
return javacast("long", obj);
}
if (isBoolean(obj))
return javaCast("boolean", obj);
if (isValid("UUID", obj))
return createObject("java","java.util.UUID").fromString(insert('-', obj, 23));
if (isValid("GUID", obj))
return createObject("java","java.util.UUID").fromString(obj);
// isDate disabled. Too slow, and not very useful
//if (isDate(obj))
// return dateAdd("n", 0, obj);
}
if (isArray(obj) && !isBinary(obj)) // binary is an array in CF :S
{
for (var i = 1; i <= arrayLen(obj); i++)
obj[i] = arrayIsDefined(obj, i) ? javaTyped(obj[i]) : javacast("null", "");
return obj;
}
if (isStruct(obj))
{
for (local.k in obj)
obj[k] = structKeyExists(obj, k) ? javaTyped(obj[k]) : javacast("null", "");
return obj;
}
// String and other non-CF types
return obj;
}
}