source: uKadecot/trunk/tools/EcnlControllerUI/EcnlCtrlUI/js/mscorlib.js@ 108

Last change on this file since 108 was 108, checked in by coas-nagasima, 9 years ago

MIMEプロパティの変更
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
  • Property svn:mime-type set to text/javascript
File size: 105.9 KB
Line 
1// SaltarelleCompiler Runtime (http://www.saltarelle-compiler.com)
2// Modified version of Script# Core Runtime (http://projects.nikhilk.net/ScriptSharp)
3
4if (typeof(global) === "undefined") {
5 if (typeof(window) !== "undefined")
6 global = window;
7 else if (typeof(self) !== "undefined")
8 global = self;
9}
10(function(global) {
11"use strict";
12
13var ss = { __assemblies: {} };
14
15ss.initAssembly = function assembly(obj, name, res) {
16 res = res || {};
17 obj.name = name;
18 obj.toString = function() { return this.name; };
19 obj.__types = {};
20 obj.getResourceNames = function() { return Object.keys(res); };
21 obj.getResourceDataBase64 = function(name) { return res[name] || null; };
22 obj.getResourceData = function(name) { var r = res[name]; return r ? ss.dec64(r) : null; };
23 ss.__assemblies[name] = obj;
24};
25ss.initAssembly(ss, 'mscorlib');
26
27ss.load = function ss$load(name) {
28 return ss.__assemblies[name] || require(name);
29};
30
31var enc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', dec;
32ss.enc64 = function(a, b) {
33 var s = '', i;
34 for (i = 0; i < a.length; i += 3) {
35 var c1 = a[i], c2 = a[i+1], c3 = a[i+2];
36 s += (b && i && !(i%57) ? '\n' : '') + enc[c1 >> 2] + enc[((c1 & 3) << 4) | (c2 >> 4)] + (i < a.length - 1 ? enc[((c2 & 15) << 2) | (c3 >> 6)] : '=') + (i < a.length - 2 ? enc[c3 & 63] : '=');
37 }
38 return s;
39};
40
41ss.dec64 = function(s) {
42 s = s.replace(/\s/g, '');
43 dec = dec || (function() { var o = {'=':-1}; for (var i = 0; i < 64; i++) o[enc[i]] = i; return o; })();
44 var a = Array(Math.max(s.length * 3 / 4 - 2, 0)), i;
45 for (i = 0; i < s.length; i += 4) {
46 var j = i * 3 / 4, c1 = dec[s[i]], c2 = dec[s[i+1]], c3 = dec[s[i+2]], c4 = dec[s[i+3]];
47 a[j] = (c1 << 2) | (c2 >> 4);
48 if (c3 >= 0) a[j+1] = ((c2 & 15) << 4) | (c3 >> 2);
49 if (c4 >= 0) a[j+2] = ((c3 & 3) << 6) | c4;
50 }
51 return a;
52};
53
54ss.getAssemblies = function ss$getAssemblies() {
55 return Object.keys(ss.__assemblies).map(function(n) { return ss.__assemblies[n]; });
56};
57
58ss.isNullOrUndefined = function ss$isNullOrUndefined(o) {
59 return (o === null) || (o === undefined);
60};
61
62ss.isValue = function ss$isValue(o) {
63 return (o !== null) && (o !== undefined);
64};
65
66ss.referenceEquals = function ss$referenceEquals(a, b) {
67 return ss.isValue(a) ? a === b : !ss.isValue(b);
68};
69
70ss.mkdict = function ss$mkdict() {
71 var a = (arguments.length != 1 ? arguments : arguments[0]);
72 var r = {};
73 for (var i = 0; i < a.length; i += 2) {
74 r[a[i]] = a[i + 1];
75 }
76 return r;
77};
78
79ss.clone = function ss$clone(t, o) {
80 return o ? t.$clone(o) : o;
81}
82
83ss.coalesce = function ss$coalesce(a, b) {
84 return ss.isValue(a) ? a : b;
85};
86
87ss.isDate = function ss$isDate(obj) {
88 return Object.prototype.toString.call(obj) === '[object Date]';
89};
90
91ss.isArray = function ss$isArray(obj) {
92 return Object.prototype.toString.call(obj) === '[object Array]';
93};
94
95ss.isTypedArrayType = function ss$isTypedArrayType(type) {
96 return ['Float32Array', 'Float64Array', 'Int8Array', 'Int16Array', 'Int32Array', 'Uint8Array', 'Uint16Array', 'Uint32Array', 'Uint8ClampedArray'].indexOf(ss.getTypeFullName(type)) >= 0;
97};
98
99ss.isArrayOrTypedArray = function ss$isArray(obj) {
100 return ss.isArray(obj) || ss.isTypedArrayType(ss.getInstanceType(obj));
101};
102
103ss.getHashCode = function ss$getHashCode(obj) {
104 if (!ss.isValue(obj))
105 throw new ss_NullReferenceException('Cannot get hash code of null');
106 else if (typeof(obj.getHashCode) === 'function')
107 return obj.getHashCode();
108 else if (typeof(obj) === 'boolean') {
109 return obj ? 1 : 0;
110 }
111 else if (typeof(obj) === 'number') {
112 var s = obj.toExponential();
113 s = s.substr(0, s.indexOf('e'));
114 return parseInt(s.replace('.', ''), 10) & 0xffffffff;
115 }
116 else if (typeof(obj) === 'string') {
117 var res = 0;
118 for (var i = 0; i < obj.length; i++)
119 res = (res * 31 + obj.charCodeAt(i)) & 0xffffffff;
120 return res;
121 }
122 else if (ss.isDate(obj)) {
123 return obj.valueOf() & 0xffffffff;
124 }
125 else {
126 return ss.defaultHashCode(obj);
127 }
128};
129
130ss.defaultHashCode = function ss$defaultHashCode(obj) {
131 return obj.$__hashCode__ || (obj.$__hashCode__ = (Math.random() * 0x100000000) | 0);
132};
133
134ss.equals = function ss$equals(a, b) {
135 if (!ss.isValue(a))
136 throw new ss_NullReferenceException('Object is null');
137 else if (a !== ss && typeof(a.equals) === 'function')
138 return a.equals(b);
139 if (ss.isDate(a) && ss.isDate(b))
140 return a.valueOf() === b.valueOf();
141 else if (typeof(a) === 'function' && typeof(b) === 'function')
142 return ss.delegateEquals(a, b);
143 else if (ss.isNullOrUndefined(a) && ss.isNullOrUndefined(b))
144 return true;
145 else
146 return a === b;
147};
148
149ss.compare = function ss$compare(a, b) {
150 if (!ss.isValue(a))
151 throw new ss_NullReferenceException('Object is null');
152 else if (typeof(a) === 'number' || typeof(a) === 'string' || typeof(a) === 'boolean')
153 return a < b ? -1 : (a > b ? 1 : 0);
154 else if (ss.isDate(a))
155 return ss.compare(a.valueOf(), b.valueOf());
156 else
157 return a.compareTo(b);
158};
159
160ss.equalsT = function ss$equalsT(a, b) {
161 if (!ss.isValue(a))
162 throw new ss_NullReferenceException('Object is null');
163 else if (typeof(a) === 'number' || typeof(a) === 'string' || typeof(a) === 'boolean')
164 return a === b;
165 else if (ss.isDate(a))
166 return a.valueOf() === b.valueOf();
167 else
168 return a.equalsT(b);
169};
170
171ss.staticEquals = function ss$staticEquals(a, b) {
172 if (!ss.isValue(a))
173 return !ss.isValue(b);
174 else
175 return ss.isValue(b) ? ss.equals(a, b) : false;
176};
177
178ss.shallowCopy = function ss$shallowCopy(source, target) {
179 var keys = Object.keys(source);
180 for (var i = 0, l = keys.length; i < l; i++) {
181 var k = keys[i];
182 target[k] = source[k];
183 }
184};
185
186ss.isLower = function ss$isLower(c) {
187 var s = String.fromCharCode(c);
188 return s === s.toLowerCase() && s !== s.toUpperCase();
189};
190
191ss.isUpper = function ss$isUpper(c) {
192 var s = String.fromCharCode(c);
193 return s !== s.toLowerCase() && s === s.toUpperCase();
194};
195
196if (typeof(window) == 'object') {
197 // Browser-specific stuff that could go into the Web assembly, but that assembly does not have an associated JS file.
198 if (!window.Element) {
199 // IE does not have an Element constructor. This implementation should make casting to elements work.
200 window.Element = function() {};
201 window.Element.isInstanceOfType = function(instance) { return instance && typeof instance.constructor === 'undefined' && typeof instance.tagName === 'string'; };
202 }
203 window.Element.__typeName = 'Element';
204
205 if (!window.XMLHttpRequest) {
206 window.XMLHttpRequest = function() {
207 var progIDs = [ 'Msxml2.XMLHTTP', 'Microsoft.XMLHTTP' ];
208
209 for (var i = 0; i < progIDs.length; i++) {
210 try {
211 var xmlHttp = new ActiveXObject(progIDs[i]);
212 return xmlHttp;
213 }
214 catch (ex) {
215 }
216 }
217
218 return null;
219 };
220 }
221
222 ss.parseXml = function(markup) {
223 try {
224 if (DOMParser) {
225 var domParser = new DOMParser();
226 return domParser.parseFromString(markup, 'text/xml');
227 }
228 else {
229 var progIDs = [ 'Msxml2.DOMDocument.3.0', 'Msxml2.DOMDocument' ];
230
231 for (var i = 0; i < progIDs.length; i++) {
232 var xmlDOM = new ActiveXObject(progIDs[i]);
233 xmlDOM.async = false;
234 xmlDOM.loadXML(markup);
235 xmlDOM.setProperty('SelectionLanguage', 'XPath');
236 return xmlDOM;
237 }
238 }
239 }
240 catch (ex) {
241 }
242
243 return null;
244 };
245}
246
247///////////////////////////////////////////////////////////////////////////////
248// Object Extensions
249
250ss.clearKeys = function ss$clearKeys(d) {
251 for (var n in d) {
252 if (d.hasOwnProperty(n))
253 delete d[n];
254 }
255};
256
257ss.keyExists = function ss$keyExists(d, key) {
258 return d[key] !== undefined;
259};
260
261if (!Object.keys) {
262 Object.keys = (function() {
263 'use strict';
264 var hasOwnProperty = Object.prototype.hasOwnProperty,
265 hasDontEnumBug = !({toString: null}).propertyIsEnumerable('toString'),
266 dontEnums = ['toString','toLocaleString','valueOf','hasOwnProperty','isPrototypeOf','propertyIsEnumerable','constructor'],
267 dontEnumsLength = dontEnums.length;
268
269 return function (obj) {
270 if (typeof obj !== 'object' && (typeof obj !== 'function' || obj === null)) {
271 throw new TypeError('Object.keys called on non-object');
272 }
273
274 var result = [], prop, i;
275
276 for (prop in obj) {
277 if (hasOwnProperty.call(obj, prop)) {
278 result.push(prop);
279 }
280 }
281
282 if (hasDontEnumBug) {
283 for (i = 0; i < dontEnumsLength; i++) {
284 if (hasOwnProperty.call(obj, dontEnums[i])) {
285 result.push(dontEnums[i]);
286 }
287 }
288 }
289 return result;
290 };
291 }());
292}
293
294ss.getKeyCount = function ss$getKeyCount(d) {
295 return Object.keys(d).length;
296};
297
298///////////////////////////////////////////////////////////////////////////////
299// Type System Implementation
300
301ss.__genericCache = {};
302
303ss._makeGenericTypeName = function ss$_makeGenericTypeName(genericType, typeArguments) {
304 var result = genericType.__typeName;
305 for (var i = 0; i < typeArguments.length; i++)
306 result += (i === 0 ? '[' : ',') + '[' + ss.getTypeQName(typeArguments[i]) + ']';
307 result += ']';
308 return result;
309};
310
311ss.makeGenericType = function ss$makeGenericType(genericType, typeArguments) {
312 var name = ss._makeGenericTypeName(genericType, typeArguments);
313 return ss.__genericCache[name] || genericType.apply(null, typeArguments);
314};
315
316ss.registerGenericClassInstance = function ss$registerGenericClassInstance(instance, genericType, typeArguments, members, baseType, interfaceTypes) {
317 var name = ss._makeGenericTypeName(genericType, typeArguments);
318 ss.__genericCache[name] = instance;
319 instance.__typeName = name;
320 instance.__genericTypeDefinition = genericType;
321 instance.__typeArguments = typeArguments;
322 ss.initClass(instance, genericType.__assembly, members, baseType(), interfaceTypes());
323};
324
325ss.registerGenericInterfaceInstance = function ss$registerGenericInterfaceInstance(instance, genericType, typeArguments, members, baseInterfaces) {
326 var name = ss._makeGenericTypeName(genericType, typeArguments);
327 ss.__genericCache[name] = instance;
328 instance.__typeName = name;
329 instance.__genericTypeDefinition = genericType;
330 instance.__typeArguments = typeArguments;
331 ss.initInterface(instance, genericType.__assembly, members, baseInterfaces());
332};
333
334ss.isGenericTypeDefinition = function ss$isGenericTypeDefinition(type) {
335 return type.__isGenericTypeDefinition || false;
336};
337
338ss.getGenericTypeDefinition = function ss$getGenericTypeDefinition(type) {
339 return type.__genericTypeDefinition || null;
340};
341
342ss.getGenericParameterCount = function ss$getGenericParameterCount(type) {
343 return type.__typeArgumentCount || 0;
344};
345
346ss.getGenericArguments = function ss$getGenericArguments(type) {
347 return type.__typeArguments || null;
348};
349
350ss.setMetadata = function ss$_setMetadata(type, metadata) {
351 if (metadata.members) {
352 for (var i = 0; i < metadata.members.length; i++) {
353 var m = metadata.members[i];
354 m.typeDef = type;
355 if (m.adder) m.adder.typeDef = type;
356 if (m.remover) m.remover.typeDef = type;
357 if (m.getter) m.getter.typeDef = type;
358 if (m.setter) m.setter.typeDef = type;
359 }
360 }
361 type.__metadata = metadata;
362 if (metadata.variance) {
363 type.isAssignableFrom = function(source) {
364 var check = function(target, type) {
365 if (type.__genericTypeDefinition === target.__genericTypeDefinition && type.__typeArguments.length == target.__typeArguments.length) {
366 for (var i = 0; i < target.__typeArguments.length; i++) {
367 var v = target.__metadata.variance[i], t = target.__typeArguments[i], s = type.__typeArguments[i];
368 switch (v) {
369 case 1: if (!ss.isAssignableFrom(t, s)) return false; break;
370 case 2: if (!ss.isAssignableFrom(s, t)) return false; break;
371 default: if (s !== t) return false;
372 }
373 }
374 return true;
375 }
376 return false;
377 };
378
379 if (source.__interface && check(this, source))
380 return true;
381 var ifs = ss.getInterfaces(source);
382 for (var i = 0; i < ifs.length; i++) {
383 if (ifs[i] === this || check(this, ifs[i]))
384 return true;
385 }
386 return false;
387 };
388 }
389}
390
391ss.initClass = function ss$initClass(ctor, asm, members, baseType, interfaces) {
392 ctor.__class = true;
393 ctor.__assembly = asm;
394 if (!ctor.__typeArguments)
395 asm.__types[ctor.__typeName] = ctor;
396 if (baseType && baseType !== Object) {
397 var f = function(){};
398 f.prototype = baseType.prototype;
399 ctor.prototype = new f();
400 ctor.prototype.constructor = ctor;
401 }
402 ss.shallowCopy(members, ctor.prototype);
403 if (interfaces)
404 ctor.__interfaces = interfaces;
405};
406
407ss.initGenericClass = function ss$initGenericClass(ctor, asm, typeArgumentCount) {
408 ctor.__class = true;
409 ctor.__assembly = asm;
410 asm.__types[ctor.__typeName] = ctor;
411 ctor.__typeArgumentCount = typeArgumentCount;
412 ctor.__isGenericTypeDefinition = true;
413};
414
415ss.initInterface = function ss$initInterface(ctor, asm, members, baseInterfaces) {
416 ctor.__interface = true;
417 ctor.__assembly = asm;
418 if (!ctor.__typeArguments)
419 asm.__types[ctor.__typeName] = ctor;
420 if (baseInterfaces)
421 ctor.__interfaces = baseInterfaces;
422 ss.shallowCopy(members, ctor.prototype);
423 ctor.isAssignableFrom = function(type) { return ss.contains(ss.getInterfaces(type), this); };
424};
425
426ss.initGenericInterface = function ss$initGenericClass(ctor, asm, typeArgumentCount) {
427 ctor.__interface = true;
428 ctor.__assembly = asm;
429 asm.__types[ctor.__typeName] = ctor;
430 ctor.__typeArgumentCount = typeArgumentCount;
431 ctor.__isGenericTypeDefinition = true;
432};
433
434ss.initEnum = function ss$initEnum(ctor, asm, members, namedValues) {
435 ctor.__enum = true;
436 ctor.__assembly = asm;
437 asm.__types[ctor.__typeName] = ctor;
438 ss.shallowCopy(members, ctor.prototype);
439 ctor.getDefaultValue = ctor.createInstance = function() { return namedValues ? null : 0; };
440 ctor.isInstanceOfType = function(instance) { return typeof(instance) == (namedValues ? 'string' : 'number'); };
441};
442
443ss.getBaseType = function ss$getBaseType(type) {
444 if (type === Object || type.__interface) {
445 return null;
446 }
447 else if (Object.getPrototypeOf) {
448 return Object.getPrototypeOf(type.prototype).constructor;
449 }
450 else {
451 var p = type.prototype;
452 if (Object.prototype.hasOwnProperty.call(p, 'constructor')) {
453 try {
454 var ownValue = p.constructor;
455 delete p.constructor;
456 return p.constructor;
457 }
458 finally {
459 p.constructor = ownValue;
460 }
461 }
462 return p.constructor;
463 }
464};
465
466ss.getTypeFullName = function ss$getTypeFullName(type) {
467 return type.__typeName || type.name || (type.toString().match(/^\s*function\s*([^\s(]+)/) || [])[1] || 'Object';
468};
469
470ss.getTypeQName = function ss$getTypeFullName(type) {
471 return ss.getTypeFullName(type) + (type.__assembly ? ', ' + type.__assembly.name : '');
472};
473
474ss.getTypeName = function ss$getTypeName(type) {
475 var fullName = ss.getTypeFullName(type);
476 var bIndex = fullName.indexOf('[');
477 var nsIndex = fullName.lastIndexOf('.', bIndex >= 0 ? bIndex : fullName.length);
478 return nsIndex > 0 ? fullName.substr(nsIndex + 1) : fullName;
479};
480
481ss.getTypeNamespace = function ss$getTypeNamespace(type) {
482 var fullName = ss.getTypeFullName(type);
483 var bIndex = fullName.indexOf('[');
484 var nsIndex = fullName.lastIndexOf('.', bIndex >= 0 ? bIndex : fullName.length);
485 return nsIndex > 0 ? fullName.substr(0, nsIndex) : '';
486};
487
488ss.getTypeAssembly = function ss$getTypeAssembly(type) {
489 if (ss.contains([Date, Number, Boolean, String, Function, Array], type))
490 return ss;
491 else
492 return type.__assembly || null;
493};
494
495ss._getAssemblyType = function ss$_getAssemblyType(asm, name) {
496 var result = [];
497 if (asm.__types) {
498 return asm.__types[name] || null;
499 }
500 else {
501 var a = name.split('.');
502 for (var i = 0; i < a.length; i++) {
503 asm = asm[a[i]];
504 if (!ss.isValue(asm))
505 return null;
506 }
507 if (typeof asm !== 'function')
508 return null;
509 return asm;
510 }
511};
512
513ss.getAssemblyTypes = function ss$getAssemblyTypes(asm) {
514 var result = [];
515 if (asm.__types) {
516 for (var t in asm.__types) {
517 if (asm.__types.hasOwnProperty(t))
518 result.push(asm.__types[t]);
519 }
520 }
521 else {
522 var traverse = function(s, n) {
523 for (var c in s) {
524 if (s.hasOwnProperty(c))
525 traverse(s[c], c);
526 }
527 if (typeof(s) === 'function' && ss.isUpper(n.charCodeAt(0)))
528 result.push(s);
529 };
530 traverse(asm, '');
531 }
532 return result;
533};
534
535ss.createAssemblyInstance = function ss$createAssemblyInstance(asm, typeName) {
536 var t = ss.getType(typeName, asm);
537 return t ? ss.createInstance(t) : null;
538};
539
540ss.getInterfaces = function ss$getInterfaces(type) {
541 if (type.__interfaces)
542 return type.__interfaces;
543 else if (type === Date || type === Number)
544 return [ ss_IEquatable, ss_IComparable, ss_IFormattable ];
545 else if (type === Boolean || type === String)
546 return [ ss_IEquatable, ss_IComparable ];
547 else if (type === Array || ss.isTypedArrayType(type))
548 return [ ss_IEnumerable, ss_ICollection, ss_IList ];
549 else
550 return [];
551};
552
553ss.isInstanceOfType = function ss$isInstanceOfType(instance, type) {
554 if (ss.isNullOrUndefined(instance))
555 return false;
556
557 if (typeof(type.isInstanceOfType) === 'function')
558 return type.isInstanceOfType(instance);
559
560 return ss.isAssignableFrom(type, ss.getInstanceType(instance));
561};
562
563ss.isAssignableFrom = function ss$isAssignableFrom(target, type) {
564 return target === type || (typeof(target.isAssignableFrom) === 'function' && target.isAssignableFrom(type)) || type.prototype instanceof target;
565};
566
567ss.isClass = function Type$isClass(type) {
568 return (type.__class == true || type === Array || type === Function || type === RegExp || type === String || type === Error || type === Object);
569};
570
571ss.isEnum = function Type$isEnum(type) {
572 return !!type.__enum;
573};
574
575ss.isFlags = function Type$isFlags(type) {
576 return type.__metadata && type.__metadata.enumFlags || false;
577};
578
579ss.isInterface = function Type$isInterface(type) {
580 return !!type.__interface;
581};
582
583ss.safeCast = function ss$safeCast(instance, type) {
584 if (type === true)
585 return instance;
586 else if (type === false)
587 return null;
588 else
589 return ss.isInstanceOfType(instance, type) ? instance : null;
590};
591
592ss.cast = function ss$cast(instance, type) {
593 if (instance === null || typeof(instance) === 'undefined')
594 return instance;
595 else if (type === true || (type !== false && ss.isInstanceOfType(instance, type)))
596 return instance;
597 throw new ss_InvalidCastException('Cannot cast object to type ' + ss.getTypeFullName(type));
598};
599
600ss.getInstanceType = function ss$getInstanceType(instance) {
601 if (!ss.isValue(instance))
602 throw new ss_NullReferenceException('Cannot get type of null');
603
604 // NOTE: We have to catch exceptions because the constructor
605 // cannot be looked up on native COM objects
606 try {
607 return instance.constructor;
608 }
609 catch (ex) {
610 return Object;
611 }
612};
613
614ss._getType = function (typeName, asm, re) {
615 var outer = !re;
616 re = re || /[[,\]]/g;
617 var last = re.lastIndex, m = re.exec(typeName), tname, targs = [];
618 if (m) {
619 tname = typeName.substring(last, m.index);
620 switch (m[0]) {
621 case '[':
622 if (typeName[m.index + 1] != '[')
623 return null;
624 for (;;) {
625 re.exec(typeName);
626 var t = ss._getType(typeName, global, re);
627 if (!t)
628 return null;
629 targs.push(t);
630 m = re.exec(typeName);
631 if (m[0] === ']')
632 break;
633 else if (m[0] !== ',')
634 return null;
635 }
636 m = re.exec(typeName);
637 if (m && m[0] === ',') {
638 re.exec(typeName);
639 if (!(asm = ss.__assemblies[(re.lastIndex > 0 ? typeName.substring(m.index + 1, re.lastIndex - 1) : typeName.substring(m.index + 1)).trim()]))
640 return null;
641 }
642 break;
643
644 case ']':
645 break;
646
647 case ',':
648 re.exec(typeName);
649 if (!(asm = ss.__assemblies[(re.lastIndex > 0 ? typeName.substring(m.index + 1, re.lastIndex - 1) : typeName.substring(m.index + 1)).trim()]))
650 return null;
651 break;
652 }
653 }
654 else {
655 tname = typeName.substring(last);
656 }
657
658 if (outer && re.lastIndex)
659 return null;
660
661 var t = ss._getAssemblyType(asm, tname.trim());
662 return targs.length ? ss.makeGenericType(t, targs) : t;
663}
664
665ss.getType = function ss$getType(typeName, asm) {
666 return typeName ? ss._getType(typeName, asm || global) : null;
667};
668
669ss.getDefaultValue = function ss$getDefaultValue(type) {
670 if (typeof(type.getDefaultValue) === 'function')
671 return type.getDefaultValue();
672 else if (type === Boolean)
673 return false;
674 else if (type === Date)
675 return new Date(0);
676 else if (type === Number)
677 return 0;
678 return null;
679};
680
681ss.createInstance = function ss$createInstance(type) {
682 if (typeof(type.createInstance) === 'function')
683 return type.createInstance();
684 else if (type === Boolean)
685 return false;
686 else if (type === Date)
687 return new Date(0);
688 else if (type === Number)
689 return 0;
690 else if (type === String)
691 return '';
692 else
693 return new type();
694};
695
696ss.applyConstructor = function ss$applyConstructor(constructor, args) {
697 var f = function() {
698 constructor.apply(this, args);
699 };
700 f.prototype = constructor.prototype;
701 return new f();
702};
703
704ss.getAttributes = function ss$getAttributes(type, attrType, inherit) {
705 var result = [];
706 if (inherit) {
707 var b = ss.getBaseType(type);
708 if (b) {
709 var a = ss.getAttributes(b, attrType, true);
710 for (var i = 0; i < a.length; i++) {
711 var t = ss.getInstanceType(a[i]);
712 if (!t.__metadata || !t.__metadata.attrNoInherit)
713 result.push(a[i]);
714 }
715 }
716 }
717 if (type.__metadata && type.__metadata.attr) {
718 for (var i = 0; i < type.__metadata.attr.length; i++) {
719 var a = type.__metadata.attr[i];
720 if (attrType == null || ss.isInstanceOfType(a, attrType)) {
721 var t = ss.getInstanceType(a);
722 if (!t.__metadata || !t.__metadata.attrAllowMultiple) {
723 for (var j = result.length - 1; j >= 0; j--) {
724 if (ss.isInstanceOfType(result[j], t))
725 result.splice(j, 1);
726 }
727 }
728 result.push(a);
729 }
730 }
731 }
732 return result;
733};
734
735ss.getMembers = function ss$getMembers(type, memberTypes, bindingAttr, name, params) {
736 var result = [];
737 if ((bindingAttr & 72) == 72 || (bindingAttr & 6) == 4) {
738 var b = ss.getBaseType(type);
739 if (b)
740 result = ss.getMembers(b, memberTypes & ~1, bindingAttr & (bindingAttr & 64 ? 255 : 247) & (bindingAttr & 2 ? 251 : 255), name, params);
741 }
742
743 var f = function(m) {
744 if ((memberTypes & m.type) && (((bindingAttr & 4) && !m.isStatic) || ((bindingAttr & 8) && m.isStatic)) && (!name || m.name === name)) {
745 if (params) {
746 if ((m.params || []).length !== params.length)
747 return;
748 for (var i = 0; i < params.length; i++) {
749 if (params[i] !== m.params[i])
750 return;
751 }
752 }
753 result.push(m);
754 }
755 };
756
757 if (type.__metadata && type.__metadata.members) {
758 for (var i = 0; i < type.__metadata.members.length; i++) {
759 var m = type.__metadata.members[i];
760 f(m);
761 for (var j = 0; j < 4; j++) {
762 var a = ['getter','setter','adder','remover'][j];
763 if (m[a])
764 f(m[a]);
765 }
766 }
767 }
768
769 if (bindingAttr & 256) {
770 while (type) {
771 var r = [];
772 for (var i = 0; i < result.length; i++) {
773 if (result[i].typeDef === type)
774 r.push(result[i]);
775 }
776 if (r.length > 1)
777 throw new ss_AmbiguousMatchException('Ambiguous match');
778 else if (r.length === 1)
779 return r[0];
780 type = ss.getBaseType(type);
781 }
782 return null;
783 }
784
785 return result;
786};
787
788ss.midel = function ss$midel(mi, target, typeArguments) {
789 if (mi.isStatic && !!target)
790 throw new ss_ArgumentException('Cannot specify target for static method');
791 else if (!mi.isStatic && !target)
792 throw new ss_ArgumentException('Must specify target for instance method');
793
794 var method;
795 if (mi.fget) {
796 method = function() { return (mi.isStatic ? mi.typeDef : this)[mi.fget]; };
797 }
798 else if (mi.fset) {
799 method = function(v) { (mi.isStatic ? mi.typeDef : this)[mi.fset] = v; };
800 }
801 else {
802 method = mi.def || (mi.isStatic || mi.sm ? mi.typeDef[mi.sname] : target[mi.sname]);
803
804 if (mi.tpcount) {
805 if (!typeArguments || typeArguments.length !== mi.tpcount)
806 throw new ss_ArgumentException('Wrong number of type arguments');
807 method = method.apply(null, typeArguments);
808 }
809 else {
810 if (typeArguments && typeArguments.length)
811 throw new ss_ArgumentException('Cannot specify type arguments for non-generic method');
812 }
813 if (mi.exp) {
814 var _m1 = method;
815 method = function () { return _m1.apply(this, Array.prototype.slice.call(arguments, 0, arguments.length - 1).concat(arguments[arguments.length - 1])); };
816 }
817 if (mi.sm) {
818 var _m2 = method;
819 method = function() { return _m2.apply(null, [this].concat(Array.prototype.slice.call(arguments))); };
820 }
821 }
822 return ss.mkdel(target, method);
823};
824
825ss.invokeCI = function ss$invokeCI(ci, args) {
826 if (ci.exp)
827 args = args.slice(0, args.length - 1).concat(args[args.length - 1]);
828
829 if (ci.def)
830 return ci.def.apply(null, args);
831 else if (ci.sm)
832 return ci.typeDef[ci.sname].apply(null, args);
833 else
834 return ss.applyConstructor(ci.sname ? ci.typeDef[ci.sname] : ci.typeDef, args);
835};
836
837ss.fieldAccess = function ss$fieldAccess(fi, obj) {
838 if (fi.isStatic && !!obj)
839 throw new ss_ArgumentException('Cannot specify target for static field');
840 else if (!fi.isStatic && !obj)
841 throw new ss_ArgumentException('Must specify target for instance field');
842 obj = fi.isStatic ? fi.typeDef : obj;
843 if (arguments.length === 3)
844 obj[fi.sname] = arguments[2];
845 else
846 return obj[fi.sname];
847};
848
849///////////////////////////////////////////////////////////////////////////////
850// IFormattable
851
852var ss_IFormattable = function IFormattable$() { };
853
854ss_IFormattable.__typeName = 'ss.IFormattable';
855ss.IFormattable = ss_IFormattable;
856ss.initInterface(ss_IFormattable, ss, { format: null });
857
858ss.format = function ss$format(obj, fmt) {
859 if (typeof(obj) === 'number')
860 return ss.formatNumber(obj, fmt);
861 else if (ss.isDate(obj))
862 return ss.formatDate(obj, fmt);
863 else
864 return obj.format(fmt);
865};
866
867///////////////////////////////////////////////////////////////////////////////
868// IComparable
869
870var ss_IComparable = function IComparable$() { };
871
872ss_IComparable.__typeName = 'ss.IComparable';
873ss.IComparable = ss_IComparable;
874ss.initInterface(ss_IComparable, ss, { compareTo: null });
875
876///////////////////////////////////////////////////////////////////////////////
877// IEquatable
878
879var ss_IEquatable = function IEquatable$() { };
880
881ss_IEquatable.__typeName = 'ss.IEquatable';
882ss.IEquatable = ss_IEquatable;
883ss.initInterface(ss_IEquatable, ss, { equalsT: null });
884
885///////////////////////////////////////////////////////////////////////////////
886// Number Extensions
887
888ss.formatNumber = function ss$formatNumber(num, format) {
889 if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
890 return num.toString();
891 }
892 return ss.netFormatNumber(num, format, ss_CultureInfo.invariantCulture.numberFormat);
893};
894
895ss.localeFormatNumber = function ss$localeFormatNumber(num, format) {
896 if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
897 return num.toLocaleString();
898 }
899 return ss.netFormatNumber(num, format, ss_CultureInfo.currentCulture.numberFormat);
900};
901
902ss._commaFormatNumber = function ss$_commaFormat(number, groups, decimal, comma) {
903 var decimalPart = null;
904 var decimalIndex = number.indexOf(decimal);
905 if (decimalIndex > 0) {
906 decimalPart = number.substr(decimalIndex);
907 number = number.substr(0, decimalIndex);
908 }
909
910 var negative = ss.startsWithString(number, '-');
911 if (negative) {
912 number = number.substr(1);
913 }
914
915 var groupIndex = 0;
916 var groupSize = groups[groupIndex];
917 if (number.length < groupSize) {
918 return (negative ? '-' : '') + (decimalPart ? number + decimalPart : number);
919 }
920
921 var index = number.length;
922 var s = '';
923 var done = false;
924 while (!done) {
925 var length = groupSize;
926 var startIndex = index - length;
927 if (startIndex < 0) {
928 groupSize += startIndex;
929 length += startIndex;
930 startIndex = 0;
931 done = true;
932 }
933 if (!length) {
934 break;
935 }
936
937 var part = number.substr(startIndex, length);
938 if (s.length) {
939 s = part + comma + s;
940 }
941 else {
942 s = part;
943 }
944 index -= length;
945
946 if (groupIndex < groups.length - 1) {
947 groupIndex++;
948 groupSize = groups[groupIndex];
949 }
950 }
951
952 if (negative) {
953 s = '-' + s;
954 }
955 return decimalPart ? s + decimalPart : s;
956};
957
958ss.netFormatNumber = function ss$netFormatNumber(num, format, numberFormat) {
959 var nf = (numberFormat && numberFormat.getFormat(ss_NumberFormatInfo)) || ss_CultureInfo.currentCulture.numberFormat;
960
961 var s = '';
962 var precision = -1;
963
964 if (format.length > 1) {
965 precision = parseInt(format.substr(1), 10);
966 }
967
968 var fs = format.charAt(0);
969 switch (fs) {
970 case 'd': case 'D':
971 s = parseInt(Math.abs(num)).toString();
972 if (precision != -1) {
973 s = ss.padLeftString(s, precision, 0x30);
974 }
975 if (num < 0) {
976 s = '-' + s;
977 }
978 break;
979 case 'x': case 'X':
980 s = parseInt(Math.abs(num)).toString(16);
981 if (fs == 'X') {
982 s = s.toUpperCase();
983 }
984 if (precision != -1) {
985 s = ss.padLeftString(s, precision, 0x30);
986 }
987 break;
988 case 'e': case 'E':
989 if (precision == -1) {
990 s = num.toExponential();
991 }
992 else {
993 s = num.toExponential(precision);
994 }
995 if (fs == 'E') {
996 s = s.toUpperCase();
997 }
998 break;
999 case 'f': case 'F':
1000 case 'n': case 'N':
1001 if (precision == -1) {
1002 precision = nf.numberDecimalDigits;
1003 }
1004 s = num.toFixed(precision).toString();
1005 if (precision && (nf.numberDecimalSeparator != '.')) {
1006 var index = s.indexOf('.');
1007 s = s.substr(0, index) + nf.numberDecimalSeparator + s.substr(index + 1);
1008 }
1009 if ((fs == 'n') || (fs == 'N')) {
1010 s = ss._commaFormatNumber(s, nf.numberGroupSizes, nf.numberDecimalSeparator, nf.numberGroupSeparator);
1011 }
1012 break;
1013 case 'c': case 'C':
1014 if (precision == -1) {
1015 precision = nf.currencyDecimalDigits;
1016 }
1017 s = Math.abs(num).toFixed(precision).toString();
1018 if (precision && (nf.currencyDecimalSeparator != '.')) {
1019 var index = s.indexOf('.');
1020 s = s.substr(0, index) + nf.currencyDecimalSeparator + s.substr(index + 1);
1021 }
1022 s = ss._commaFormatNumber(s, nf.currencyGroupSizes, nf.currencyDecimalSeparator, nf.currencyGroupSeparator);
1023 if (num < 0) {
1024 s = ss.formatString(nf.currencyNegativePattern, s);
1025 }
1026 else {
1027 s = ss.formatString(nf.currencyPositivePattern, s);
1028 }
1029 break;
1030 case 'p': case 'P':
1031 if (precision == -1) {
1032 precision = nf.percentDecimalDigits;
1033 }
1034 s = (Math.abs(num) * 100.0).toFixed(precision).toString();
1035 if (precision && (nf.percentDecimalSeparator != '.')) {
1036 var index = s.indexOf('.');
1037 s = s.substr(0, index) + nf.percentDecimalSeparator + s.substr(index + 1);
1038 }
1039 s = ss._commaFormatNumber(s, nf.percentGroupSizes, nf.percentDecimalSeparator, nf.percentGroupSeparator);
1040 if (num < 0) {
1041 s = ss.formatString(nf.percentNegativePattern, s);
1042 }
1043 else {
1044 s = ss.formatString(nf.percentPositivePattern, s);
1045 }
1046 break;
1047 }
1048
1049 return s;
1050};
1051
1052///////////////////////////////////////////////////////////////////////////////
1053// String Extensions
1054ss.netSplit = function ss$netSplit(s, strings, limit, options) {
1055 var re = new RegExp(strings.map(ss.regexpEscape).join('|'), 'g'), res = [], m, i;
1056 for (i = 0;; i = re.lastIndex) {
1057 if (m = re.exec(s)) {
1058 if (options !== 1 || m.index > i) {
1059 if (res.length === limit - 1) {
1060 res.push(s.substr(i));
1061 return res;
1062 }
1063 else
1064 res.push(s.substring(i, m.index));
1065 }
1066 }
1067 else {
1068 if (options !== 1 || i !== s.length)
1069 res.push(s.substr(i));
1070 return res;
1071 }
1072 }
1073};
1074
1075ss.compareStrings = function ss$compareStrings(s1, s2, ignoreCase) {
1076 if (ignoreCase) {
1077 if (s1) {
1078 s1 = s1.toUpperCase();
1079 }
1080 if (s2) {
1081 s2 = s2.toUpperCase();
1082 }
1083 }
1084 s1 = s1 || '';
1085 s2 = s2 || '';
1086
1087 if (s1 == s2) {
1088 return 0;
1089 }
1090 if (s1 < s2) {
1091 return -1;
1092 }
1093 return 1;
1094};
1095
1096ss.endsWithString = function ss$endsWithString(s, suffix) {
1097 if (!suffix.length) {
1098 return true;
1099 }
1100 if (suffix.length > s.length) {
1101 return false;
1102 }
1103 return (s.substr(s.length - suffix.length) == suffix);
1104};
1105
1106ss._formatString = function ss$_formatString(format, values, useLocale) {
1107 if (!ss._formatRE) {
1108 ss._formatRE = /\{\{|\}\}|\{[^\}\{]+\}/g;
1109 }
1110
1111 return format.replace(ss._formatRE,
1112 function(m) {
1113 if (m === '{{' || m === '}}')
1114 return m.charAt(0);
1115 var index = parseInt(m.substr(1), 10);
1116 var value = values[index + 1];
1117 if (ss.isNullOrUndefined(value)) {
1118 return '';
1119 }
1120 if (ss.isInstanceOfType(value, ss_IFormattable)) {
1121 var formatSpec = null;
1122 var formatIndex = m.indexOf(':');
1123 if (formatIndex > 0) {
1124 formatSpec = m.substring(formatIndex + 1, m.length - 1);
1125 }
1126 return ss.format(value, formatSpec);
1127 }
1128 else {
1129 return useLocale ? value.toLocaleString() : value.toString();
1130 }
1131 });
1132};
1133
1134ss.formatString = function String$format(format) {
1135 return ss._formatString(format, arguments, /* useLocale */ false);
1136};
1137
1138ss.stringFromChar = function ss$stringFromChar(ch, count) {
1139 var s = ch;
1140 for (var i = 1; i < count; i++) {
1141 s += ch;
1142 }
1143 return s;
1144};
1145
1146ss.htmlDecode = function ss$htmlDecode(s) {
1147 return s.replace(/&([^;]+);/g, function(_, e) {
1148 if (e[0] === '#')
1149 return String.fromCharCode(parseInt(e.substr(1), 10));
1150 switch (e) {
1151 case 'quot': return '"';
1152 case 'apos': return "'";
1153 case 'amp': return '&';
1154 case 'lt': return '<';
1155 case 'gt': return '>';
1156 default : return '&' + e + ';';
1157 }
1158 });
1159};
1160
1161ss.htmlEncode = function ss$htmlEncode(s) {
1162 return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
1163};
1164
1165ss.jsEncode = function ss$jsEncode(s, q) {
1166 s = s.replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/"/g, '\\"');
1167 return q ? '"' + s + '"' : s;
1168};
1169
1170ss.indexOfAnyString = function ss$indexOfAnyString(s, chars, startIndex, count) {
1171 var length = s.length;
1172 if (!length) {
1173 return -1;
1174 }
1175
1176 chars = String.fromCharCode.apply(null, chars);
1177 startIndex = startIndex || 0;
1178 count = count || length;
1179
1180 var endIndex = startIndex + count - 1;
1181 if (endIndex >= length) {
1182 endIndex = length - 1;
1183 }
1184
1185 for (var i = startIndex; i <= endIndex; i++) {
1186 if (chars.indexOf(s.charAt(i)) >= 0) {
1187 return i;
1188 }
1189 }
1190 return -1;
1191};
1192
1193ss.insertString = function ss$insertString(s, index, value) {
1194 if (!value) {
1195 return s;
1196 }
1197 if (!index) {
1198 return value + s;
1199 }
1200 var s1 = s.substr(0, index);
1201 var s2 = s.substr(index);
1202 return s1 + value + s2;
1203};
1204
1205ss.isNullOrEmptyString = function ss$isNullOrEmptyString(s) {
1206 return !s || !s.length;
1207};
1208
1209ss.lastIndexOfAnyString = function ss$lastIndexOfAnyString(s, chars, startIndex, count) {
1210 var length = s.length;
1211 if (!length) {
1212 return -1;
1213 }
1214
1215 chars = String.fromCharCode.apply(null, chars);
1216 startIndex = startIndex || length - 1;
1217 count = count || length;
1218
1219 var endIndex = startIndex - count + 1;
1220 if (endIndex < 0) {
1221 endIndex = 0;
1222 }
1223
1224 for (var i = startIndex; i >= endIndex; i--) {
1225 if (chars.indexOf(s.charAt(i)) >= 0) {
1226 return i;
1227 }
1228 }
1229 return -1;
1230};
1231
1232ss.localeFormatString = function ss$localeFormatString(format) {
1233 return ss._formatString(format, arguments, /* useLocale */ true);
1234};
1235
1236ss.padLeftString = function ss$padLeftString(s, totalWidth, ch) {
1237 if (s.length < totalWidth) {
1238 ch = String.fromCharCode(ch || 0x20);
1239 return ss.stringFromChar(ch, totalWidth - s.length) + s;
1240 }
1241 return s;
1242};
1243
1244ss.padRightString = function ss$padRightString(s, totalWidth, ch) {
1245 if (s.length < totalWidth) {
1246 ch = String.fromCharCode(ch || 0x20);
1247 return s + ss.stringFromChar(ch, totalWidth - s.length);
1248 }
1249 return s;
1250};
1251
1252ss.removeString = function ss$removeString(s, index, count) {
1253 if (!count || ((index + count) > this.length)) {
1254 return s.substr(0, index);
1255 }
1256 return s.substr(0, index) + s.substr(index + count);
1257};
1258
1259ss.replaceAllString = function ss$replaceAllString(s, oldValue, newValue) {
1260 newValue = newValue || '';
1261 return s.split(oldValue).join(newValue);
1262};
1263
1264ss.startsWithString = function ss$startsWithString(s, prefix) {
1265 if (!prefix.length) {
1266 return true;
1267 }
1268 if (prefix.length > s.length) {
1269 return false;
1270 }
1271 return (s.substr(0, prefix.length) == prefix);
1272};
1273
1274if (!String.prototype.trim) {
1275 String.prototype.trim = function String$trim() {
1276 return ss.trimStartString(ss.trimEndString(this));
1277 };
1278}
1279
1280ss.trimEndString = function ss$trimEndString(s, chars) {
1281 return s.replace(chars ? new RegExp('[' + String.fromCharCode.apply(null, chars) + ']+$') : /\s*$/, '');
1282};
1283
1284ss.trimStartString = function ss$trimStartString(s, chars) {
1285 return s.replace(chars ? new RegExp('^[' + String.fromCharCode.apply(null, chars) + ']+') : /^\s*/, '');
1286};
1287
1288ss.trimString = function ss$trimString(s, chars) {
1289 return ss.trimStartString(ss.trimEndString(s, chars), chars);
1290};
1291
1292ss.lastIndexOfString = function ss$lastIndexOfString(s, search, startIndex, count) {
1293 var index = s.lastIndexOf(search, startIndex);
1294 return (index < (startIndex - count + 1)) ? -1 : index;
1295};
1296
1297ss.indexOfString = function ss$indexOfString(s, search, startIndex, count) {
1298 var index = s.indexOf(search, startIndex);
1299 return ((index + search.length) <= (startIndex + count)) ? index : -1;
1300};
1301
1302///////////////////////////////////////////////////////////////////////////////
1303// Math Extensions
1304
1305ss.divRem = function ss$divRem(a, b, result) {
1306 var remainder = a % b;
1307 result.$ = remainder;
1308 return (a - remainder) / b;
1309};
1310
1311ss.round = function ss$round(n, d, rounding) {
1312 var m = Math.pow(10, d || 0);
1313 n *= m;
1314 var sign = (n > 0) | -(n < 0);
1315 if (n % 1 === 0.5 * sign) {
1316 var f = Math.floor(n);
1317 return (f + (rounding ? (sign > 0) : (f % 2 * sign))) / m;
1318 }
1319
1320 return Math.round(n) / m;
1321};
1322
1323///////////////////////////////////////////////////////////////////////////////
1324// IFormatProvider
1325
1326var ss_IFormatProvider = function IFormatProvider$() { };
1327
1328ss_IFormatProvider.__typeName = 'ss.IFormatProvider';
1329ss.IFormatProvider = ss_IFormatProvider;
1330ss.initInterface(ss_IFormatProvider, ss, { getFormat: null });
1331
1332///////////////////////////////////////////////////////////////////////////////
1333// NumberFormatInfo
1334
1335var ss_NumberFormatInfo = function NumberFormatInfo$() {
1336};
1337
1338ss_NumberFormatInfo.__typeName = 'ss.NumberFormatInfo';
1339ss.NumberFormatInfo = ss_NumberFormatInfo;
1340ss.initClass(ss_NumberFormatInfo, ss, {
1341 getFormat: function NumberFormatInfo$getFormat(type) {
1342 return (type === ss_NumberFormatInfo) ? this : null;
1343 }
1344}, null, [ss_IFormatProvider]);
1345
1346ss_NumberFormatInfo.invariantInfo = new ss_NumberFormatInfo();
1347ss.shallowCopy({
1348 naNSymbol: 'NaN',
1349 negativeSign: '-',
1350 positiveSign: '+',
1351 negativeInfinitySymbol: '-Infinity',
1352 positiveInfinitySymbol: 'Infinity',
1353
1354 percentSymbol: '%',
1355 percentGroupSizes: [3],
1356 percentDecimalDigits: 2,
1357 percentDecimalSeparator: '.',
1358 percentGroupSeparator: ',',
1359 percentPositivePattern: 0,
1360 percentNegativePattern: 0,
1361
1362 currencySymbol: '$',
1363 currencyGroupSizes: [3],
1364 currencyDecimalDigits: 2,
1365 currencyDecimalSeparator: '.',
1366 currencyGroupSeparator: ',',
1367 currencyNegativePattern: 0,
1368 currencyPositivePattern: 0,
1369
1370 numberGroupSizes: [3],
1371 numberDecimalDigits: 2,
1372 numberDecimalSeparator: '.',
1373 numberGroupSeparator: ','
1374}, ss_NumberFormatInfo.invariantInfo);
1375
1376///////////////////////////////////////////////////////////////////////////////
1377// DateTimeFormatInfo
1378
1379var ss_DateTimeFormatInfo = function DateTimeFormatInfo$() {
1380};
1381
1382ss_DateTimeFormatInfo.__typeName = 'ss.DateTimeFormatInfo';
1383ss.DateTimeFormatInfo = ss_DateTimeFormatInfo;
1384ss.initClass(ss_DateTimeFormatInfo, ss, {
1385 getFormat: function DateTimeFormatInfo$getFormat(type) {
1386 return type === ss_DateTimeFormatInfo ? this : null;
1387 }
1388}, null, [ss_IFormatProvider]);
1389
1390ss_DateTimeFormatInfo.invariantInfo = new ss_DateTimeFormatInfo();
1391ss.shallowCopy({
1392 amDesignator: 'AM',
1393 pmDesignator: 'PM',
1394
1395 dateSeparator: '/',
1396 timeSeparator: ':',
1397
1398 gmtDateTimePattern: 'ddd, dd MMM yyyy HH:mm:ss \'GMT\'',
1399 universalDateTimePattern: 'yyyy-MM-dd HH:mm:ssZ',
1400 sortableDateTimePattern: 'yyyy-MM-ddTHH:mm:ss',
1401 dateTimePattern: 'dddd, MMMM dd, yyyy h:mm:ss tt',
1402
1403 longDatePattern: 'dddd, MMMM dd, yyyy',
1404 shortDatePattern: 'M/d/yyyy',
1405
1406 longTimePattern: 'h:mm:ss tt',
1407 shortTimePattern: 'h:mm tt',
1408
1409 firstDayOfWeek: 0,
1410 dayNames: ['Sunday','Monday','Tuesday','Wednesday','Thursday','Friday','Saturday'],
1411 shortDayNames: ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'],
1412 minimizedDayNames: ['Su','Mo','Tu','We','Th','Fr','Sa'],
1413
1414 monthNames: ['January','February','March','April','May','June','July','August','September','October','November','December',''],
1415 shortMonthNames: ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec','']
1416}, ss_DateTimeFormatInfo.invariantInfo);
1417
1418///////////////////////////////////////////////////////////////////////////////
1419// Stopwatch
1420
1421var ss_Stopwatch = function Stopwatch$() {
1422 this._stopTime = 0;
1423 this._startTime = 0;
1424 this.isRunning = false;
1425};
1426
1427ss_Stopwatch.startNew = function Stopwatch$startNew() {
1428 var s = new ss_Stopwatch();
1429 s.start();
1430 return s;
1431};
1432
1433if (typeof(window) !== 'undefined' && window.performance && window.performance.now) {
1434 ss_Stopwatch.frequency = 1e6;
1435 ss_Stopwatch.isHighResolution = true;
1436 ss_Stopwatch.getTimestamp = function() { return Math.round(window.performance.now() * 1000); };
1437}
1438else if (typeof(process) !== 'undefined' && process.hrtime) {
1439 ss_Stopwatch.frequency = 1e9;
1440 ss_Stopwatch.isHighResolution = true;
1441 ss_Stopwatch.getTimestamp = function() { var hr = process.hrtime(); return hr[0] * 1e9 + hr[1]; };
1442}
1443else {
1444 ss_Stopwatch.frequency = 1e3;
1445 ss_Stopwatch.isHighResolution = false;
1446 ss_Stopwatch.getTimestamp = function() { return new Date().valueOf(); };
1447}
1448
1449ss_Stopwatch.__typeName = 'ss.Stopwatch';
1450ss.Stopwatch = ss_Stopwatch;
1451ss.initClass(ss_Stopwatch, ss, {
1452 reset: function Stopwatch$reset() {
1453 this._stopTime = this._startTime = ss_Stopwatch.getTimestamp();
1454 this.isRunning = false;
1455 },
1456
1457 ticks: function Stopwatch$ticks() {
1458 return (this.isRunning ? ss_Stopwatch.getTimestamp() : this._stopTime) - this._startTime;
1459 },
1460
1461 milliseconds: function Stopwatch$milliseconds() {
1462 return Math.round(this.ticks() / ss_Stopwatch.frequency * 1000);
1463 },
1464
1465 timeSpan: function Stopwatch$timeSpan() {
1466 return new ss_TimeSpan(this.milliseconds() * 10000);
1467 },
1468
1469 start: function Stopwatch$start() {
1470 if (this.isRunning)
1471 return;
1472 this._startTime = ss_Stopwatch.getTimestamp();
1473 this.isRunning = true;
1474 },
1475
1476 stop: function Stopwatch$stop() {
1477 if (!this.isRunning)
1478 return;
1479 this._stopTime = ss_Stopwatch.getTimestamp();
1480 this.isRunning = false;
1481 },
1482
1483 restart: function Stopwatch$restart() {
1484 this.isRunning = false;
1485 this.start();
1486 }
1487});
1488
1489///////////////////////////////////////////////////////////////////////////////
1490// Array Extensions
1491
1492ss._flatIndex = function ss$_flatIndex(arr, indices) {
1493 if (indices.length != (arr._sizes ? arr._sizes.length : 1))
1494 throw new ss_ArgumentException('Invalid number of indices');
1495
1496 if (indices[0] < 0 || indices[0] >= (arr._sizes ? arr._sizes[0] : arr.length))
1497 throw new ss_ArgumentException('Index 0 out of range');
1498
1499 var idx = indices[0];
1500 if (arr._sizes) {
1501 for (var i = 1; i < arr._sizes.length; i++) {
1502 if (indices[i] < 0 || indices[i] >= arr._sizes[i])
1503 throw new ss_ArgumentException('Index ' + i + ' out of range');
1504 idx = idx * arr._sizes[i] + indices[i];
1505 }
1506 }
1507 return idx;
1508};
1509
1510ss.arrayGet2 = function ss$arrayGet2(arr, indices) {
1511 var idx = ss._flatIndex(arr, indices);
1512 var r = arr[idx];
1513 return typeof r !== 'undefined' ? r : arr._defvalue;
1514};
1515
1516ss.arrayGet = function ss$arrayGet(arr) {
1517 return ss.arrayGet2(arr, Array.prototype.slice.call(arguments, 1));
1518}
1519
1520ss.arraySet2 = function ss$arraySet2(arr, value, indices) {
1521 var idx = ss._flatIndex(arr, indices);
1522 arr[idx] = value;
1523};
1524
1525ss.arraySet = function ss$arraySet() {
1526 return ss.arraySet2(arguments[0], arguments[arguments.length - 1], Array.prototype.slice.call(arguments, 1, arguments.length - 1));
1527};
1528
1529ss.arrayRank = function ss$arrayRank(arr) {
1530 return arr._sizes ? arr._sizes.length : 1;
1531};
1532
1533ss.arrayLength = function ss$arrayLength(arr, dimension) {
1534 if (dimension >= (arr._sizes ? arr._sizes.length : 1))
1535 throw new ss_ArgumentException('Invalid dimension');
1536 return arr._sizes ? arr._sizes[dimension] : arr.length;
1537};
1538
1539ss.arrayExtract = function ss$arrayExtract(arr, start, count) {
1540 if (!ss.isValue(count)) {
1541 return arr.slice(start);
1542 }
1543 return arr.slice(start, start + count);
1544};
1545
1546ss.arrayAddRange = function ss$arrayAddRange(arr, items) {
1547 if (items instanceof Array) {
1548 arr.push.apply(arr, items);
1549 }
1550 else {
1551 var e = ss.getEnumerator(items);
1552 try {
1553 while (e.moveNext()) {
1554 ss.add(arr, e.current());
1555 }
1556 }
1557 finally {
1558 if (ss.isInstanceOfType(e, ss_IDisposable)) {
1559 ss.cast(e, ss_IDisposable).dispose();
1560 }
1561 }
1562 }
1563};
1564
1565ss.arrayClone = function ss$arrayClone(arr) {
1566 if (arr.length === 1) {
1567 return [arr[0]];
1568 }
1569 else {
1570 return Array.apply(null, arr);
1571 }
1572};
1573
1574ss.arrayPeekFront = function ss$arrayPeekFront(arr) {
1575 if (arr.length)
1576 return arr[0];
1577 throw new ss_InvalidOperationException('Array is empty');
1578};
1579
1580ss.arrayPeekBack = function ss$arrayPeekBack(arr) {
1581 if (arr.length)
1582 return arr[arr.length - 1];
1583 throw new ss_InvalidOperationException('Array is empty');
1584};
1585
1586ss.indexOfArray = function ss$indexOfArray(arr, item, startIndex) {
1587 startIndex = startIndex || 0;
1588 for (var i = startIndex; i < arr.length; i++) {
1589 if (ss.staticEquals(arr[i], item)) {
1590 return i;
1591 }
1592 }
1593 return -1;
1594}
1595
1596ss.arrayInsertRange = function ss$arrayInsertRange(arr, index, items) {
1597 if (items instanceof Array) {
1598 if (index === 0) {
1599 arr.unshift.apply(arr, items);
1600 }
1601 else {
1602 for (var i = 0; i < items.length; i++) {
1603 arr.splice(index + i, 0, items[i]);
1604 }
1605 }
1606 }
1607 else {
1608 var e = ss.getEnumerator(items);
1609 try {
1610 while (e.moveNext()) {
1611 arr.insert(index, e.current());
1612 index++;
1613 }
1614 }
1615 finally {
1616 if (ss.isInstanceOfType(e, ss_IDisposable)) {
1617 ss.cast(e, ss_IDisposable).dispose();
1618 }
1619 }
1620 }
1621};
1622
1623if (!Array.prototype.map) {
1624 Array.prototype.map = function Array$map(callback, instance) {
1625 var length = this.length;
1626 var mapped = new Array(length);
1627 for (var i = 0; i < length; i++) {
1628 if (i in this) {
1629 mapped[i] = callback.call(instance, this[i], i, this);
1630 }
1631 }
1632 return mapped;
1633 };
1634}
1635
1636ss.arrayRemoveRange = function ss$arrayRemoveRange(arr, index, count) {
1637 arr.splice(index, count);
1638};
1639
1640if (!Array.prototype.some) {
1641 Array.prototype.some = function Array$some(callback, instance) {
1642 var length = this.length;
1643 for (var i = 0; i < length; i++) {
1644 if (i in this && callback.call(instance, this[i], i, this)) {
1645 return true;
1646 }
1647 }
1648 return false;
1649 };
1650}
1651
1652ss.arrayFromEnumerable = function ss$arrayFromEnumerable(enm) {
1653 if (!ss.isValue(enm))
1654 return null;
1655
1656 var e = ss.getEnumerator(enm), r = [];
1657 try {
1658 while (e.moveNext())
1659 r.push(e.current());
1660 }
1661 finally {
1662 e.dispose();
1663 }
1664 return r;
1665};
1666
1667ss.multidimArray = function ss$multidimArray(defvalue, sizes) {
1668 var arr = [];
1669 arr._defvalue = defvalue;
1670 arr._sizes = [arguments[1]];
1671 var length = arguments[1];
1672 for (var i = 2; i < arguments.length; i++) {
1673 length *= arguments[i];
1674 arr._sizes[i - 1] = arguments[i];
1675 }
1676 arr.length = length;
1677 return arr;
1678};
1679
1680ss.repeat = function ss$repeat(value, count) {
1681 var result = [];
1682 for (var i = 0; i < count; i++)
1683 result.push(value);
1684 return result;
1685};
1686
1687///////////////////////////////////////////////////////////////////////////////
1688// Date Extensions
1689
1690ss.utcNow = function ss$utcNow() {
1691 var d = new Date();
1692 return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
1693};
1694
1695ss.toUTC = function ss$toUniversalTime(d) {
1696 return new Date(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate(), d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds());
1697};
1698
1699ss.fromUTC = function ss$toLocalTime(d) {
1700 return new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate(), d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds()));
1701};
1702
1703ss.today = function ss$today() {
1704 var d = new Date();
1705 return new Date(d.getFullYear(), d.getMonth(), d.getDate());
1706}
1707
1708ss.formatDate = function ss$formatDate(date, format) {
1709 if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
1710 return date.toString();
1711 }
1712 if (format == 'id') {
1713 return date.toDateString();
1714 }
1715 if (format == 'it') {
1716 return date.toTimeString();
1717 }
1718
1719 return ss._netFormatDate(date, format, false);
1720};
1721
1722ss.localeFormatDate = function ss$localeFormatDate(date, format) {
1723 if (ss.isNullOrUndefined(format) || (format.length == 0) || (format == 'i')) {
1724 return date.toLocaleString();
1725 }
1726 if (format == 'id') {
1727 return date.toLocaleDateString();
1728 }
1729 if (format == 'it') {
1730 return date.toLocaleTimeString();
1731 }
1732
1733 return ss._netFormatDate(date, format, true);
1734};
1735
1736ss._netFormatDate = function ss$_netFormatDate(dt, format, useLocale) {
1737 var dtf = useLocale ? ss_CultureInfo.currentCulture.dateTimeFormat : ss_CultureInfo.invariantCulture.dateTimeFormat;
1738
1739 if (format.length == 1) {
1740 switch (format) {
1741 case 'f': format = dtf.longDatePattern + ' ' + dtf.shortTimePattern; break;
1742 case 'F': format = dtf.dateTimePattern; break;
1743
1744 case 'd': format = dtf.shortDatePattern; break;
1745 case 'D': format = dtf.longDatePattern; break;
1746
1747 case 't': format = dtf.shortTimePattern; break;
1748 case 'T': format = dtf.longTimePattern; break;
1749
1750 case 'g': format = dtf.shortDatePattern + ' ' + dtf.shortTimePattern; break;
1751 case 'G': format = dtf.shortDatePattern + ' ' + dtf.longTimePattern; break;
1752
1753 case 'R': case 'r':
1754 dtf = ss_CultureInfo.InvariantCulture.dateTimeFormat;
1755 format = dtf.gmtDateTimePattern;
1756 break;
1757 case 'u': format = dtf.universalDateTimePattern; break;
1758 case 'U':
1759 format = dtf.dateTimePattern;
1760 dt = new Date(dt.getUTCFullYear(), dt.getUTCMonth(), dt.getUTCDate(),
1761 dt.getUTCHours(), dt.getUTCMinutes(), dt.getUTCSeconds(), dt.getUTCMilliseconds());
1762 break;
1763
1764 case 's': format = dtf.sortableDateTimePattern; break;
1765 }
1766 }
1767
1768 if (format.charAt(0) == '%') {
1769 format = format.substr(1);
1770 }
1771
1772 if (!Date._formatRE) {
1773 Date._formatRE = /'.*?[^\\]'|dddd|ddd|dd|d|MMMM|MMM|MM|M|yyyy|yy|y|hh|h|HH|H|mm|m|ss|s|tt|t|fff|ff|f|zzz|zz|z/g;
1774 }
1775
1776 var re = Date._formatRE;
1777 var sb = new ss_StringBuilder();
1778
1779 re.lastIndex = 0;
1780 while (true) {
1781 var index = re.lastIndex;
1782 var match = re.exec(format);
1783
1784 sb.append(format.slice(index, match ? match.index : format.length));
1785 if (!match) {
1786 break;
1787 }
1788
1789 var fs = match[0];
1790 var part = fs;
1791 switch (fs) {
1792 case 'dddd':
1793 part = dtf.dayNames[dt.getDay()];
1794 break;
1795 case 'ddd':
1796 part = dtf.shortDayNames[dt.getDay()];
1797 break;
1798 case 'dd':
1799 part = ss.padLeftString(dt.getDate().toString(), 2, 0x30);
1800 break;
1801 case 'd':
1802 part = dt.getDate();
1803 break;
1804 case 'MMMM':
1805 part = dtf.monthNames[dt.getMonth()];
1806 break;
1807 case 'MMM':
1808 part = dtf.shortMonthNames[dt.getMonth()];
1809 break;
1810 case 'MM':
1811 part = ss.padLeftString((dt.getMonth() + 1).toString(), 2, 0x30);
1812 break;
1813 case 'M':
1814 part = (dt.getMonth() + 1);
1815 break;
1816 case 'yyyy':
1817 part = dt.getFullYear();
1818 break;
1819 case 'yy':
1820 part = ss.padLeftString((dt.getFullYear() % 100).toString(), 2, 0x30);
1821 break;
1822 case 'y':
1823 part = (dt.getFullYear() % 100);
1824 break;
1825 case 'h': case 'hh':
1826 part = dt.getHours() % 12;
1827 if (!part) {
1828 part = '12';
1829 }
1830 else if (fs == 'hh') {
1831 part = ss.padLeftString(part.toString(), 2, 0x30);
1832 }
1833 break;
1834 case 'HH':
1835 part = ss.padLeftString(dt.getHours().toString(), 2, 0x30);
1836 break;
1837 case 'H':
1838 part = dt.getHours();
1839 break;
1840 case 'mm':
1841 part = ss.padLeftString(dt.getMinutes().toString(), 2, 0x30);
1842 break;
1843 case 'm':
1844 part = dt.getMinutes();
1845 break;
1846 case 'ss':
1847 part = ss.padLeftString(dt.getSeconds().toString(), 2, 0x30);
1848 break;
1849 case 's':
1850 part = dt.getSeconds();
1851 break;
1852 case 't': case 'tt':
1853 part = (dt.getHours() < 12) ? dtf.amDesignator : dtf.pmDesignator;
1854 if (fs == 't') {
1855 part = part.charAt(0);
1856 }
1857 break;
1858 case 'fff':
1859 part = ss.padLeftString(dt.getMilliseconds().toString(), 3, 0x30);
1860 break;
1861 case 'ff':
1862 part = ss.padLeftString(dt.getMilliseconds().toString(), 3).substr(0, 2);
1863 break;
1864 case 'f':
1865 part = ss.padLeftString(dt.getMilliseconds().toString(), 3).charAt(0);
1866 break;
1867 case 'z':
1868 part = dt.getTimezoneOffset() / 60;
1869 part = ((part >= 0) ? '-' : '+') + Math.floor(Math.abs(part));
1870 break;
1871 case 'zz': case 'zzz':
1872 part = dt.getTimezoneOffset() / 60;
1873 part = ((part >= 0) ? '-' : '+') + Math.floor(ss.padLeftString(Math.abs(part)).toString(), 2, 0x30);
1874 if (fs == 'zzz') {
1875 part += dtf.timeSeparator + Math.abs(ss.padLeftString(dt.getTimezoneOffset() % 60).toString(), 2, 0x30);
1876 }
1877 break;
1878 default:
1879 if (part.charAt(0) == '\'') {
1880 part = part.substr(1, part.length - 2).replace(/\\'/g, '\'');
1881 }
1882 break;
1883 }
1884 sb.append(part);
1885 }
1886
1887 return sb.toString();
1888};
1889
1890ss._parseExactDate = function ss$_parseExactDate(val, format, provider, utc) {
1891 provider = (provider && provider.getFormat(ss_DateTimeFormatInfo)) || ss_CultureInfo.currentCulture.dateTimeFormat;
1892 var AM = provider.amDesignator, PM = provider.pmDesignator;
1893
1894 var _isInteger = function(val) {
1895 var digits="1234567890";
1896 for (var i=0; i < val.length; i++) {
1897 if (digits.indexOf(val.charAt(i))==-1) {
1898 return false;
1899 }
1900 }
1901 return true;
1902 };
1903
1904 var _getInt = function(str,i,minlength,maxlength) {
1905 for (var x=maxlength; x>=minlength; x--) {
1906 var token=str.substring(i,i+x);
1907 if (token.length < minlength) {
1908 return null;
1909 }
1910 if (_isInteger(token)) {
1911 return token;
1912 }
1913 }
1914 return null;
1915 };
1916
1917 val = val + "";
1918 format = format + "";
1919 var i_val = 0;
1920 var i_format = 0;
1921 var c = "";
1922 var token = "";
1923
1924 var year = 0, month = 1, date = 1, hh = 0, mm = 0, _ss = 0, ampm = "";
1925
1926 while (i_format < format.length) {
1927 // Get next token from format string
1928 c = format.charAt(i_format);
1929 token = "";
1930 while ((format.charAt(i_format) == c) && (i_format < format.length)) {
1931 token += format.charAt(i_format++);
1932 }
1933 // Extract contents of value based on format token
1934 if (token=="yyyy" || token=="yy" || token=="y") {
1935 if (token == "yyyy")
1936 year = _getInt(val, i_val, 4, 4);
1937 if (token == "yy")
1938 year = _getInt(val, i_val, 2, 2);
1939 if (token == "y")
1940 year = _getInt(val, i_val, 2, 4);
1941
1942 if (year == null)
1943 return null;
1944
1945 i_val += year.length;
1946 if (year.length == 2) {
1947 if (year > 30) {
1948 year = 1900 + (year-0);
1949 }
1950 else {
1951 year = 2000 + (year-0);
1952 }
1953 }
1954 }
1955 else if (token == "MM" || token == "M") {
1956 month = _getInt(val, i_val, token.length, 2);
1957 if (month == null || (month < 1) || (month > 12))
1958 return null;
1959 i_val += month.length;
1960 }
1961 else if (token=="dd"||token=="d") {
1962 date = _getInt(val, i_val, token.length, 2);
1963 if (date == null || (date < 1) || (date > 31))
1964 return null;
1965 i_val += date.length;
1966 }
1967 else if (token=="hh"||token=="h") {
1968 hh = _getInt(val, i_val, token.length, 2);
1969 if (hh == null || (hh < 1) || (hh > 12))
1970 return null;
1971 i_val += hh.length;
1972 }
1973 else if (token=="HH"||token=="H") {
1974 hh = _getInt(val, i_val, token.length, 2);
1975 if (hh == null || (hh < 0) || (hh > 23))
1976 return null;
1977 i_val += hh.length;
1978 }
1979 else if (token == "mm" || token == "m") {
1980 mm = _getInt(val, i_val, token.length, 2);
1981 if (mm == null || (mm < 0) || (mm > 59))
1982 return null;
1983 i_val += mm.length;
1984 }
1985 else if (token == "ss" || token == "s") {
1986 _ss = _getInt(val, i_val, token.length, 2);
1987 if (_ss == null || (_ss < 0) || (_ss > 59))
1988 return null;
1989 i_val += _ss.length;
1990 }
1991 else if (token == "t") {
1992 if (val.substring(i_val, i_val + 1).toLowerCase() == AM.charAt(0).toLowerCase())
1993 ampm = AM;
1994 else if (val.substring(i_val, i_val + 1).toLowerCase() == PM.charAt(0).toLowerCase())
1995 ampm = PM;
1996 else
1997 return null;
1998 i_val += 1;
1999 }
2000 else if (token == "tt") {
2001 if (val.substring(i_val, i_val + 2).toLowerCase() == AM.toLowerCase())
2002 ampm = AM;
2003 else if (val.substring(i_val,i_val+2).toLowerCase() == PM.toLowerCase())
2004 ampm = PM;
2005 else
2006 return null;
2007 i_val += 2;
2008 }
2009 else {
2010 if (val.substring(i_val, i_val + token.length) != token)
2011 return null;
2012 else
2013 i_val += token.length;
2014 }
2015 }
2016 // If there are any trailing characters left in the value, it doesn't match
2017 if (i_val != val.length)
2018 return null;
2019
2020 // Is date valid for month?
2021 if (month == 2) {
2022 // Check for leap year
2023 if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) { // leap year
2024 if (date > 29)
2025 return null;
2026 }
2027 else if (date > 28)
2028 return null;
2029 }
2030 if ((month == 4) || (month == 6) || (month == 9) || (month == 11)) {
2031 if (date > 30) {
2032 return null;
2033 }
2034 }
2035 // Correct hours value
2036 if (hh < 12 && ampm == PM) {
2037 hh = hh - 0 + 12;
2038 }
2039 else if (hh > 11 && ampm == AM) {
2040 hh -= 12;
2041 }
2042
2043 if (utc)
2044 return new Date(Date.UTC(year, month - 1, date, hh, mm, _ss));
2045 else
2046 return new Date(year, month - 1, date, hh, mm, _ss);
2047};
2048
2049ss.parseExactDate = function ss$parseExactDate(val, format, provider) {
2050 return ss._parseExactDate(val, format, provider, false);
2051};
2052
2053ss.parseExactDateUTC = function ss$parseExactDateUTC(val, format, provider) {
2054 return ss._parseExactDate(val, format, provider, true);
2055};
2056
2057///////////////////////////////////////////////////////////////////////////////
2058// Function Extensions
2059
2060ss._delegateContains = function ss$_delegateContains(targets, object, method) {
2061 for (var i = 0; i < targets.length; i += 2) {
2062 if (targets[i] === object && targets[i + 1] === method) {
2063 return true;
2064 }
2065 }
2066 return false;
2067};
2068
2069ss._mkdel = function ss$_mkdel(targets) {
2070 var delegate = function() {
2071 if (targets.length == 2) {
2072 return targets[1].apply(targets[0], arguments);
2073 }
2074 else {
2075 var clone = ss.arrayClone(targets);
2076 for (var i = 0; i < clone.length; i += 2) {
2077 if (ss._delegateContains(targets, clone[i], clone[i + 1])) {
2078 clone[i + 1].apply(clone[i], arguments);
2079 }
2080 }
2081 return null;
2082 }
2083 };
2084 delegate._targets = targets;
2085
2086 return delegate;
2087};
2088
2089ss.mkdel = function ss$mkdel(object, method) {
2090 if (!object) {
2091 return method;
2092 }
2093 return ss._mkdel([object, method]);
2094};
2095
2096ss.delegateCombine = function ss$delegateCombine(delegate1, delegate2) {
2097 if (!delegate1) {
2098 if (!delegate2._targets) {
2099 return ss.mkdel(null, delegate2);
2100 }
2101 return delegate2;
2102 }
2103 if (!delegate2) {
2104 if (!delegate1._targets) {
2105 return ss.mkdel(null, delegate1);
2106 }
2107 return delegate1;
2108 }
2109
2110 var targets1 = delegate1._targets ? delegate1._targets : [null, delegate1];
2111 var targets2 = delegate2._targets ? delegate2._targets : [null, delegate2];
2112
2113 return ss._mkdel(targets1.concat(targets2));
2114};
2115
2116ss.delegateRemove = function ss$delegateRemove(delegate1, delegate2) {
2117 if (!delegate1 || (delegate1 === delegate2)) {
2118 return null;
2119 }
2120 if (!delegate2) {
2121 return delegate1;
2122 }
2123
2124 var targets = delegate1._targets;
2125 var object = null;
2126 var method;
2127 if (delegate2._targets) {
2128 object = delegate2._targets[0];
2129 method = delegate2._targets[1];
2130 }
2131 else {
2132 method = delegate2;
2133 }
2134
2135 for (var i = 0; i < targets.length; i += 2) {
2136 if ((targets[i] === object) && (targets[i + 1] === method)) {
2137 if (targets.length == 2) {
2138 return null;
2139 }
2140 var t = ss.arrayClone(targets);
2141 t.splice(i, 2);
2142 return ss._mkdel(t);
2143 }
2144 }
2145
2146 return delegate1;
2147};
2148
2149ss.delegateEquals = function ss$delegateEquals(a, b) {
2150 if (a === b)
2151 return true;
2152 if (!a._targets && !b._targets)
2153 return false;
2154 var ta = a._targets || [null, a], tb = b._targets || [null, b];
2155 if (ta.length != tb.length)
2156 return false;
2157 for (var i = 0; i < ta.length; i++) {
2158 if (ta[i] !== tb[i])
2159 return false;
2160 }
2161 return true;
2162};
2163
2164ss.delegateClone = function ss$delegateClone(source) {
2165 return source._targets ? ss._mkdel(source._targets) : function() { return source.apply(this, arguments); };
2166};
2167
2168ss.thisFix = function ss$thisFix(source) {
2169 return function() {
2170 var x = [this];
2171 for(var i = 0; i < arguments.length; i++)
2172 x.push(arguments[i]);
2173 return source.apply(source, x);
2174 };
2175};
2176
2177ss.getInvocationList = function ss$getInvocationList(delegate) {
2178 if (!delegate._targets)
2179 return [delegate];
2180 var result = [];
2181 for (var i = 0; i < delegate._targets.length; i += 2)
2182 result.push(ss.mkdel(delegate._targets[i], delegate._targets[i + 1]));
2183 return result;
2184};
2185
2186///////////////////////////////////////////////////////////////////////////////
2187// RegExp Extensions
2188ss.regexpEscape = function ss$regexpEscape(s) {
2189 return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
2190};
2191
2192///////////////////////////////////////////////////////////////////////////////
2193// Debug Extensions
2194
2195ss.Debug = global.Debug || function() {};
2196ss.Debug.__typeName = 'Debug';
2197
2198if (!ss.Debug.writeln) {
2199 ss.Debug.writeln = function Debug$writeln(text) {
2200 if (global.console) {
2201 if (global.console.debug) {
2202 global.console.debug(text);
2203 return;
2204 }
2205 else if (global.console.log) {
2206 global.console.log(text);
2207 return;
2208 }
2209 }
2210 else if (global.opera &&
2211 global.opera.postError) {
2212 global.opera.postError(text);
2213 return;
2214 }
2215 }
2216};
2217
2218ss.Debug._fail = function Debug$_fail(message) {
2219 ss.Debug.writeln(message);
2220 debugger;
2221};
2222
2223ss.Debug.assert = function Debug$assert(condition, message) {
2224 if (!condition) {
2225 message = 'Assert failed: ' + message;
2226 if (confirm(message + '\r\n\r\nBreak into debugger?')) {
2227 ss.Debug._fail(message);
2228 }
2229 }
2230};
2231
2232ss.Debug.fail = function Debug$fail(message) {
2233 ss.Debug._fail(message);
2234};
2235
2236///////////////////////////////////////////////////////////////////////////////
2237// Enum
2238
2239var ss_Enum = function Enum$() {
2240};
2241ss_Enum.__typeName = 'ss.Enum';
2242ss.Enum = ss_Enum;
2243ss.initClass(ss_Enum, ss, {});
2244
2245ss_Enum.parse = function Enum$parse(enumType, s) {
2246 var values = enumType.prototype;
2247 if (!ss.isFlags(enumType)) {
2248 for (var f in values) {
2249 if (f === s) {
2250 return values[f];
2251 }
2252 }
2253 }
2254 else {
2255 var parts = s.split('|');
2256 var value = 0;
2257 var parsed = true;
2258
2259 for (var i = parts.length - 1; i >= 0; i--) {
2260 var part = parts[i].trim();
2261 var found = false;
2262
2263 for (var f in values) {
2264 if (f === part) {
2265 value |= values[f];
2266 found = true;
2267 break;
2268 }
2269 }
2270 if (!found) {
2271 parsed = false;
2272 break;
2273 }
2274 }
2275
2276 if (parsed) {
2277 return value;
2278 }
2279 }
2280 throw new ss_ArgumentException('Invalid Enumeration Value');
2281};
2282
2283ss_Enum.toString = function Enum$toString(enumType, value) {
2284 var values = enumType.prototype;
2285 if (!ss.isFlags(enumType) || (value === 0)) {
2286 for (var i in values) {
2287 if (values[i] === value) {
2288 return i;
2289 }
2290 }
2291 throw new ss_ArgumentException('Invalid Enumeration Value');
2292 }
2293 else {
2294 var parts = [];
2295 for (var i in values) {
2296 if (values[i] & value) {
2297 ss.add(parts, i);
2298 }
2299 }
2300 if (!parts.length) {
2301 throw new ss_ArgumentException('Invalid Enumeration Value');
2302 }
2303 return parts.join(' | ');
2304 }
2305};
2306
2307ss_Enum.getValues = function Enum$getValues(enumType) {
2308 var parts = [];
2309 var values = enumType.prototype;
2310 for (var i in values) {
2311 if (values.hasOwnProperty(i))
2312 parts.push(values[i]);
2313 }
2314 return parts;
2315};
2316
2317///////////////////////////////////////////////////////////////////////////////
2318// CultureInfo
2319
2320var ss_CultureInfo = function CultureInfo$(name, numberFormat, dateTimeFormat) {
2321 this.name = name;
2322 this.numberFormat = numberFormat;
2323 this.dateTimeFormat = dateTimeFormat;
2324};
2325
2326ss_CultureInfo.__typeName = 'ss.CultureInfo';
2327ss.CultureInfo = ss_CultureInfo;
2328ss.initClass(ss_CultureInfo, ss, {
2329 getFormat: function CultureInfo$getFormat(type) {
2330 switch (type) {
2331 case ss_NumberFormatInfo: return this.numberFormat;
2332 case ss_DateTimeFormatInfo: return this.dateTimeFormat;
2333 default: return null;
2334 }
2335 }
2336}, null, [ss_IFormatProvider]);
2337
2338ss_CultureInfo.invariantCulture = new ss_CultureInfo('en-US', ss_NumberFormatInfo.invariantInfo, ss_DateTimeFormatInfo.invariantInfo);
2339ss_CultureInfo.currentCulture = ss_CultureInfo.invariantCulture;
2340
2341///////////////////////////////////////////////////////////////////////////////
2342// IEnumerator
2343
2344var ss_IEnumerator = function IEnumerator$() { };
2345
2346ss_IEnumerator.__typeName = 'ss.IEnumerator';
2347ss.IEnumerator = ss_IEnumerator;
2348ss.initInterface(ss_IEnumerator, ss, { current: null, moveNext: null, reset: null }, [ss_IDisposable]);
2349
2350///////////////////////////////////////////////////////////////////////////////
2351// IEnumerable
2352
2353var ss_IEnumerable = function IEnumerable$() { };
2354
2355ss_IEnumerable.__typeName = 'ss.IEnumerable';
2356ss.IEnumerable = ss_IEnumerable;
2357ss.initInterface(ss_IEnumerable, ss, { getEnumerator: null });
2358ss.getEnumerator = function ss$getEnumerator(obj) {
2359 return obj.getEnumerator ? obj.getEnumerator() : new ss_ArrayEnumerator(obj);
2360};
2361
2362///////////////////////////////////////////////////////////////////////////////
2363// ICollection
2364
2365var ss_ICollection = function ICollection$() { };
2366
2367ss_ICollection.__typeName = 'ss.ICollection';
2368ss.ICollection = ss_ICollection;
2369ss.initInterface(ss_ICollection, ss, { get_count: null, add: null, clear: null, contains: null, remove: null });
2370
2371ss.count = function ss$count(obj) {
2372 return obj.get_count ? obj.get_count() : obj.length;
2373};
2374
2375ss.add = function ss$add(obj, item) {
2376 if (obj.add)
2377 obj.add(item);
2378 else if (ss.isArray(obj))
2379 obj.push(item);
2380 else
2381 throw new ss_NotSupportedException();
2382};
2383
2384ss.clear = function ss$clear(obj) {
2385 if (obj.clear)
2386 obj.clear();
2387 else if (ss.isArray(obj))
2388 obj.length = 0;
2389 else
2390 throw new ss_NotSupportedException();
2391};
2392
2393ss.remove = function ss$remove(obj, item) {
2394 if (obj.remove)
2395 return obj.remove(item);
2396 else if (ss.isArray(obj)) {
2397 var index = ss.indexOf(obj, item);
2398 if (index >= 0) {
2399 obj.splice(index, 1);
2400 return true;
2401 }
2402 return false;
2403 }
2404 else
2405 throw new ss_NotSupportedException();
2406};
2407
2408ss.contains = function ss$contains(obj, item) {
2409 if (obj.contains)
2410 return obj.contains(item);
2411 else
2412 return ss.indexOf(obj, item) >= 0;
2413};
2414
2415///////////////////////////////////////////////////////////////////////////////
2416// TimeSpan
2417
2418var ss_TimeSpan = function TimeSpan$(ticks) {
2419 this.ticks = ticks || 0;
2420};
2421
2422ss_TimeSpan.getDefaultValue = ss_TimeSpan.createInstance = function TimeSpan$default() {
2423 return new ss_TimeSpan(0);
2424};
2425
2426ss_TimeSpan.__typeName = 'ss.TimeSpan';
2427ss.TimeSpan = ss_TimeSpan;
2428ss.initClass(ss_TimeSpan, ss, {
2429 compareTo: function TimeSpan$compareTo(other) {
2430 return this.ticks < other.ticks ? -1 : (this.ticks > other.ticks ? 1 : 0);
2431 },
2432 equals: function TimeSpan$equals(other) {
2433 return ss.isInstanceOfType(other, ss_TimeSpan) && other.ticks === this.ticks;
2434 },
2435 equalsT: function TimeSpan$equalsT(other) {
2436 return other.ticks === this.ticks;
2437 },
2438 toString: function TimeSpan$toString() {
2439 var d = function(s, n) { return ss.padLeftString(s + '', n || 2, 48); };
2440
2441 var ticks = this.ticks;
2442 var result = '';
2443 if (Math.abs(ticks) >= 864000000000) {
2444 result += d((ticks / 864000000000) | 0) + '.';
2445 ticks %= 864000000000;
2446 }
2447 result += d(ticks / 36000000000 | 0) + ':';
2448 ticks %= 36000000000;
2449 result += d(ticks / 600000000 | 0) + ':';
2450 ticks %= 600000000;
2451 result += d(ticks / 10000000 | 0);
2452 ticks %= 10000000;
2453 if (ticks > 0)
2454 result += '.' + d(ticks, 7);
2455 return result;
2456 }
2457}, null, [ss_IComparable, ss_IEquatable]);
2458ss_TimeSpan.__class = false;
2459
2460///////////////////////////////////////////////////////////////////////////////
2461// IEqualityComparer
2462
2463var ss_IEqualityComparer = function IEqualityComparer$() { };
2464
2465ss_IEqualityComparer.__typeName = 'ss.IEqualityComparer';
2466ss.IEqualityComparer = ss_IEqualityComparer;
2467ss.initInterface(ss_IEqualityComparer, ss, { areEqual: null, getObjectHashCode: null });
2468
2469///////////////////////////////////////////////////////////////////////////////
2470// IComparer
2471
2472var ss_IComparer = function IComparer$() { };
2473
2474ss_IComparer.__typeName = 'ss.IComparer';
2475ss.IComparer = ss_IComparer;
2476ss.initInterface(ss_IComparer, ss, { compare: null });
2477
2478///////////////////////////////////////////////////////////////////////////////
2479// Nullable
2480
2481ss.unbox = function ss$unbox(instance) {
2482 if (!ss.isValue(instance))
2483 throw new ss_InvalidOperationException('Nullable object must have a value.');
2484 return instance;
2485};
2486
2487var ss_Nullable$1 = function Nullable$1$(T) {
2488 var $type = function() {
2489 };
2490 $type.isInstanceOfType = function(instance) {
2491 return ss.isInstanceOfType(instance, T);
2492 };
2493 ss.registerGenericClassInstance($type, ss_Nullable$1, [T], {}, function() { return null; }, function() { return []; });
2494 return $type;
2495};
2496
2497ss_Nullable$1.__typeName = 'ss.Nullable$1';
2498ss.Nullable$1 = ss_Nullable$1;
2499ss.initGenericClass(ss_Nullable$1, ss, 1);
2500
2501ss_Nullable$1.eq = function Nullable$eq(a, b) {
2502 return !ss.isValue(a) ? !ss.isValue(b) : (a === b);
2503};
2504
2505ss_Nullable$1.ne = function Nullable$eq(a, b) {
2506 return !ss.isValue(a) ? ss.isValue(b) : (a !== b);
2507};
2508
2509ss_Nullable$1.le = function Nullable$le(a, b) {
2510 return ss.isValue(a) && ss.isValue(b) && a <= b;
2511};
2512
2513ss_Nullable$1.ge = function Nullable$ge(a, b) {
2514 return ss.isValue(a) && ss.isValue(b) && a >= b;
2515};
2516
2517ss_Nullable$1.lt = function Nullable$lt(a, b) {
2518 return ss.isValue(a) && ss.isValue(b) && a < b;
2519};
2520
2521ss_Nullable$1.gt = function Nullable$gt(a, b) {
2522 return ss.isValue(a) && ss.isValue(b) && a > b;
2523};
2524
2525ss_Nullable$1.sub = function Nullable$sub(a, b) {
2526 return ss.isValue(a) && ss.isValue(b) ? a - b : null;
2527};
2528
2529ss_Nullable$1.add = function Nullable$add(a, b) {
2530 return ss.isValue(a) && ss.isValue(b) ? a + b : null;
2531};
2532
2533ss_Nullable$1.mod = function Nullable$mod(a, b) {
2534 return ss.isValue(a) && ss.isValue(b) ? a % b : null;
2535};
2536
2537ss_Nullable$1.div = function Nullable$divf(a, b) {
2538 return ss.isValue(a) && ss.isValue(b) ? a / b : null;
2539};
2540
2541ss_Nullable$1.mul = function Nullable$mul(a, b) {
2542 return ss.isValue(a) && ss.isValue(b) ? a * b : null;
2543};
2544
2545ss_Nullable$1.band = function Nullable$band(a, b) {
2546 return ss.isValue(a) && ss.isValue(b) ? a & b : null;
2547};
2548
2549ss_Nullable$1.bor = function Nullable$bor(a, b) {
2550 return ss.isValue(a) && ss.isValue(b) ? a | b : null;
2551};
2552
2553ss_Nullable$1.xor = function Nullable$xor(a, b) {
2554 return ss.isValue(a) && ss.isValue(b) ? a ^ b : null;
2555};
2556
2557ss_Nullable$1.shl = function Nullable$shl(a, b) {
2558 return ss.isValue(a) && ss.isValue(b) ? a << b : null;
2559};
2560
2561ss_Nullable$1.srs = function Nullable$srs(a, b) {
2562 return ss.isValue(a) && ss.isValue(b) ? a >> b : null;
2563};
2564
2565ss_Nullable$1.sru = function Nullable$sru(a, b) {
2566 return ss.isValue(a) && ss.isValue(b) ? a >>> b : null;
2567};
2568
2569ss_Nullable$1.and = function Nullable$and(a, b) {
2570 if (a === true && b === true)
2571 return true;
2572 else if (a === false || b === false)
2573 return false;
2574 else
2575 return null;
2576};
2577
2578ss_Nullable$1.or = function Nullable$or(a, b) {
2579 if (a === true || b === true)
2580 return true;
2581 else if (a === false && b === false)
2582 return false;
2583 else
2584 return null;
2585};
2586
2587ss_Nullable$1.not = function Nullable$not(a) {
2588 return ss.isValue(a) ? !a : null;
2589};
2590
2591ss_Nullable$1.neg = function Nullable$neg(a) {
2592 return ss.isValue(a) ? -a : null;
2593};
2594
2595ss_Nullable$1.pos = function Nullable$pos(a) {
2596 return ss.isValue(a) ? +a : null;
2597};
2598
2599ss_Nullable$1.cpl = function Nullable$cpl(a) {
2600 return ss.isValue(a) ? ~a : null;
2601};
2602
2603ss_Nullable$1.lift = function Nullable$lift() {
2604 for (var i = 0; i < arguments.length; i++) {
2605 if (!ss.isValue(arguments[i]))
2606 return null;
2607 }
2608 return arguments[0].apply(null, Array.prototype.slice.call(arguments, 1));
2609};
2610
2611///////////////////////////////////////////////////////////////////////////////
2612// IList
2613
2614var ss_IList = function IList$() { };
2615
2616ss_IList.__typeName = 'ss.IList';
2617ss.IList = ss_IList;
2618ss.initInterface(ss_IList, ss, { get_item: null, set_item: null, indexOf: null, insert: null, removeAt: null }, [ss_ICollection, ss_IEnumerable]);
2619
2620ss.getItem = function ss$getItem(obj, index) {
2621 return obj.get_item ? obj.get_item(index) : obj[index];
2622}
2623
2624ss.setItem = function ss$setItem(obj, index, value) {
2625 obj.set_item ? obj.set_item(index, value) : (obj[index] = value);
2626}
2627
2628ss.indexOf = function ss$indexOf(obj, item) {
2629 if (ss.isArrayOrTypedArray(obj)) {
2630 for (var i = 0; i < obj.length; i++) {
2631 if (ss.staticEquals(obj[i], item)) {
2632 return i;
2633 }
2634 }
2635 return -1;
2636 }
2637 else
2638 return obj.indexOf(item);
2639};
2640
2641ss.insert = function ss$insert(obj, index, item) {
2642 if (obj.insert)
2643 obj.insert(index, item);
2644 else if (ss.isArray(obj))
2645 obj.splice(index, 0, item);
2646 else
2647 throw new ss_NotSupportedException();
2648};
2649
2650ss.removeAt = function ss$removeAt(obj, index) {
2651 if (obj.removeAt)
2652 obj.removeAt(index);
2653 else if (ss.isArray(obj))
2654 obj.splice(index, 1);
2655 else
2656 throw new ss_NotSupportedException();
2657};
2658
2659///////////////////////////////////////////////////////////////////////////////
2660// IDictionary
2661
2662var ss_IDictionary = function IDictionary$() { };
2663
2664ss_IDictionary.__typeName = 'ss.IDictionary';
2665ss.IDictionary = ss_IDictionary;
2666ss.initInterface(ss_IDictionary, ss, { get_item: null, set_item: null, get_keys: null, get_values: null, containsKey: null, add: null, remove: null, tryGetValue: null }, [ss_IEnumerable]);
2667
2668///////////////////////////////////////////////////////////////////////////////
2669// Int32
2670
2671var ss_Int32 = function Int32$() { };
2672
2673ss_Int32.__typeName = 'ss.Int32';
2674ss.Int32 = ss_Int32;
2675ss.initClass(ss_Int32, ss, {}, Object, [ ss_IEquatable, ss_IComparable, ss_IFormattable ]);
2676ss_Int32.__class = false;
2677
2678ss_Int32.isInstanceOfType = function Int32$isInstanceOfType(instance) {
2679 return typeof(instance) === 'number' && isFinite(instance) && Math.round(instance, 0) == instance;
2680};
2681
2682ss_Int32.getDefaultValue = ss_Int32.createInstance = function Int32$getDefaultValue() {
2683 return 0;
2684};
2685
2686ss_Int32.div = function Int32$div(a, b) {
2687 if (!ss.isValue(a) || !ss.isValue(b)) return null;
2688 if (b === 0) throw new ss_DivideByZeroException();
2689 return ss_Int32.trunc(a / b);
2690};
2691
2692ss_Int32.trunc = function Int32$trunc(n) {
2693 return ss.isValue(n) ? (n > 0 ? Math.floor(n) : Math.ceil(n)) : null;
2694};
2695
2696ss_Int32.tryParse = function Int32$tryParse(s, result, min, max) {
2697 result.$ = 0;
2698 if (!/^[+-]?[0-9]+$/.test(s))
2699 return 0;
2700 var n = parseInt(s, 10);
2701 if (n < min || n > max)
2702 return false;
2703 result.$ = n;
2704 return true;
2705};
2706
2707///////////////////////////////////////////////////////////////////////////////
2708// MutableDateTime
2709
2710var ss_JsDate = function JsDate$() { };
2711
2712ss_JsDate.__typeName = 'ss.JsDate';
2713ss.JsDate = ss_JsDate;
2714ss.initClass(ss_JsDate, ss, {}, Object, [ ss_IEquatable, ss_IComparable ]);
2715
2716ss_JsDate.createInstance = function JsDate$createInstance() {
2717 return new Date();
2718};
2719
2720ss_JsDate.isInstanceOfType = function JsDate$isInstanceOfType(instance) {
2721 return instance instanceof Date;
2722};
2723
2724///////////////////////////////////////////////////////////////////////////////
2725// ArrayEnumerator
2726
2727var ss_ArrayEnumerator = function ArrayEnumerator$(array) {
2728 this._array = array;
2729 this._index = -1;
2730};
2731ss_ArrayEnumerator.__typeName = 'ss.ArrayEnumerator';
2732ss.ArrayEnumerator = ss_ArrayEnumerator;
2733ss.initClass(ss_ArrayEnumerator, ss, {
2734 moveNext: function ArrayEnumerator$moveNext() {
2735 this._index++;
2736 return (this._index < this._array.length);
2737 },
2738 reset: function ArrayEnumerator$reset() {
2739 this._index = -1;
2740 },
2741 current: function ArrayEnumerator$current() {
2742 if (this._index < 0 || this._index >= this._array.length)
2743 throw 'Invalid operation';
2744 return this._array[this._index];
2745 },
2746 dispose: function ArrayEnumerator$dispose() {
2747 }
2748}, null, [ss_IEnumerator, ss_IDisposable]);
2749
2750///////////////////////////////////////////////////////////////////////////////
2751// ObjectEnumerator
2752
2753var ss_ObjectEnumerator = function ObjectEnumerator$(o) {
2754 this._keys = Object.keys(o);
2755 this._index = -1;
2756 this._object = o;
2757};
2758
2759ss_ObjectEnumerator.__typeName = 'ss.ObjectEnumerator';
2760ss.ObjectEnumerator = ss_ObjectEnumerator;
2761ss.initClass(ss_ObjectEnumerator, ss, {
2762 moveNext: function ObjectEnumerator$moveNext() {
2763 this._index++;
2764 return (this._index < this._keys.length);
2765 },
2766 reset: function ObjectEnumerator$reset() {
2767 this._index = -1;
2768 },
2769 current: function ObjectEnumerator$current() {
2770 if (this._index < 0 || this._index >= this._keys.length)
2771 throw new ss_InvalidOperationException('Invalid operation');
2772 var k = this._keys[this._index];
2773 return { key: k, value: this._object[k] };
2774 },
2775 dispose: function ObjectEnumerator$dispose() {
2776 }
2777}, null, [ss_IEnumerator, ss_IDisposable]);
2778
2779///////////////////////////////////////////////////////////////////////////////
2780// EqualityComparer
2781
2782var ss_EqualityComparer = function EqualityComparer$() {
2783};
2784ss_EqualityComparer.__typeName = 'ss.EqualityComparer';
2785ss.EqualityComparer = ss_EqualityComparer;
2786ss.initClass(ss_EqualityComparer, ss, {
2787 areEqual: function EqualityComparer$areEqual(x, y) {
2788 return ss.staticEquals(x, y);
2789 },
2790 getObjectHashCode: function EqualityComparer$getObjectHashCode(obj) {
2791 return ss.isValue(obj) ? ss.getHashCode(obj) : 0;
2792 }
2793}, null, [ss_IEqualityComparer]);
2794ss_EqualityComparer.def = new ss_EqualityComparer();
2795
2796///////////////////////////////////////////////////////////////////////////////
2797// Comparer
2798
2799var ss_Comparer = function Comparer$(f) {
2800 this.f = f;
2801};
2802
2803ss_Comparer.__typeName = 'ss.Comparer';
2804ss.Comparer = ss_Comparer;
2805ss.initClass(ss_Comparer, ss, {
2806 compare: function Comparer$compare(x, y) {
2807 return this.f(x, y);
2808 }
2809}, null, [ss_IComparer]);
2810ss_Comparer.def = new ss_Comparer(function Comparer$defaultCompare(a, b) {
2811 if (!ss.isValue(a))
2812 return !ss.isValue(b)? 0 : -1;
2813 else if (!ss.isValue(b))
2814 return 1;
2815 else
2816 return ss.compare(a, b);
2817});
2818
2819///////////////////////////////////////////////////////////////////////////////
2820// Dictionary
2821var ss_$DictionaryCollection = function $DictionaryCollection$(dict, isKeys) {
2822 this._dict = dict;
2823 this._isKeys = isKeys;
2824};
2825
2826var ss_Dictionary$2 = function Dictionary$2$(TKey, TValue) {
2827 var $type = function(o, cmp) {
2828 this.countField = 0;
2829 this.buckets = {};
2830
2831 this.comparer = cmp || ss_EqualityComparer.def;
2832
2833 if (ss.isInstanceOfType(o, ss_IDictionary)) {
2834 var e = ss.getEnumerator(o);
2835 try {
2836 while (e.moveNext()) {
2837 var c = e.current();
2838 this.add(c.key, c.value);
2839 }
2840 }
2841 finally {
2842 if (ss.isInstanceOfType(e, ss_IDisposable)) {
2843 ss.cast(e, ss_IDisposable).dispose();
2844 }
2845 }
2846 }
2847 else if (o) {
2848 var keys = Object.keys(o);
2849 for (var i = 0; i < keys.length; i++) {
2850 this.add(keys[i], o[keys[i]]);
2851 }
2852 }
2853 };
2854
2855 ss.registerGenericClassInstance($type, ss_Dictionary$2, [TKey, TValue], {
2856 _setOrAdd: function(key, value, add) {
2857 var hash = this.comparer.getObjectHashCode(key);
2858 var entry = { key: key, value: value };
2859 if (this.buckets.hasOwnProperty(hash)) {
2860 var array = this.buckets[hash];
2861 for (var i = 0; i < array.length; i++) {
2862 if (this.comparer.areEqual(array[i].key, key)) {
2863 if (add)
2864 throw new ss_ArgumentException('Key ' + key + ' already exists.');
2865 array[i] = entry;
2866 return;
2867 }
2868 }
2869 array.push(entry);
2870 } else {
2871 this.buckets[hash] = [entry];
2872 }
2873 this.countField++;
2874 },
2875
2876 add: function(key, value) {
2877 this._setOrAdd(key, value, true);
2878 },
2879
2880 set_item: function(key, value) {
2881 this._setOrAdd(key, value, false);
2882 },
2883
2884 _get: function(key) {
2885 var hash = this.comparer.getObjectHashCode(key);
2886 if (this.buckets.hasOwnProperty(hash)) {
2887 var array = this.buckets[hash];
2888 for (var i = 0; i < array.length; i++) {
2889 var entry = array[i];
2890 if (this.comparer.areEqual(entry.key, key))
2891 return entry.value !== undefined ? entry.value : null;
2892 }
2893 }
2894 return undefined;
2895 },
2896
2897 get_item: function(key) {
2898 var v = this._get(key);
2899 if (v === undefined)
2900 throw new ss_KeyNotFoundException('Key ' + key + ' does not exist.');
2901 return v;
2902 },
2903
2904 tryGetValue: function(key, value) {
2905 var v = this._get(key);
2906 if (v !== undefined) {
2907 value.$ = v;
2908 return true;
2909 }
2910 else {
2911 value.$ = ss.getDefaultValue(TValue);
2912 return false;
2913 }
2914 },
2915
2916 containsKey: function(key) {
2917 var hash = this.comparer.getObjectHashCode(key);
2918 if (!this.buckets.hasOwnProperty(hash))
2919 return false;
2920
2921 var array = this.buckets[hash];
2922 for (var i = 0; i < array.length; i++) {
2923 if (this.comparer.areEqual(array[i].key, key))
2924 return true;
2925 }
2926 return false;
2927 },
2928
2929 clear: function() {
2930 this.countField = 0;
2931 this.buckets = {};
2932 },
2933
2934 remove: function(key) {
2935 var hash = this.comparer.getObjectHashCode(key);
2936 if (!this.buckets.hasOwnProperty(hash))
2937 return false;
2938
2939 var array = this.buckets[hash];
2940 for (var i = 0; i < array.length; i++) {
2941 if (this.comparer.areEqual(array[i].key, key)) {
2942 array.splice(i, 1);
2943 if (array.length == 0) delete this.buckets[hash];
2944 this.countField--;
2945 return true;
2946 }
2947 }
2948 return false;
2949 },
2950
2951 get_count: function() {
2952 return this.countField;
2953 },
2954
2955 _getEnumerator: function(projector) {
2956 var bucketKeys = Object.keys(this.buckets), bucketIndex = -1, arrayIndex;
2957 return new ss_IteratorBlockEnumerator(function() {
2958 if (bucketIndex < 0 || arrayIndex >= (this.buckets[bucketKeys[bucketIndex]].length - 1)) {
2959 arrayIndex = -1;
2960 bucketIndex++;
2961 }
2962 if (bucketIndex >= bucketKeys.length)
2963 return false;
2964 arrayIndex++;
2965 return true;
2966 }, function() { return projector(this.buckets[bucketKeys[bucketIndex]][arrayIndex]); }, null, this);
2967 },
2968
2969 get_keys: function() {
2970 return new ss_$DictionaryCollection(this, true);
2971 },
2972
2973 get_values: function() {
2974 return new ss_$DictionaryCollection(this, false);
2975 },
2976
2977 getEnumerator: function() {
2978 return this._getEnumerator(function(e) { return e; });
2979 }
2980 }, function() { return null; }, function() { return [ ss_IDictionary, ss_IEnumerable ]; });
2981 return $type;
2982};
2983
2984ss_Dictionary$2.__typeName = 'ss.Dictionary$2';
2985ss.Dictionary$2 = ss_Dictionary$2;
2986ss.initGenericClass(ss_Dictionary$2, ss, 2);
2987ss_$DictionaryCollection.__typeName = 'ss.$DictionaryCollection';
2988ss.$DictionaryCollection = ss_$DictionaryCollection;
2989ss.initClass(ss_$DictionaryCollection, ss, {
2990 get_count: function $DictionaryCollection$get_count() {
2991 return this._dict.get_count();
2992 },
2993 contains: function $DictionaryCollection$contains(v) {
2994 if (this._isKeys) {
2995 return this._dict.containsKey(v);
2996 }
2997 else {
2998 for (var e in this._dict.buckets) {
2999 if (this._dict.buckets.hasOwnProperty(e)) {
3000 var bucket = this._dict.buckets[e];
3001 for (var i = 0; i < bucket.length; i++) {
3002 if (this._dict.comparer.areEqual(bucket[i].value, v))
3003 return true;
3004 }
3005 }
3006 }
3007 return false;
3008 }
3009 },
3010 getEnumerator: function $DictionaryCollection$getEnumerator(v) {
3011 return this._dict._getEnumerator(this._isKeys ? function(e) { return e.key; } : function(e) { return e.value; });
3012 },
3013 add: function $DictionaryCollection$add(v) {
3014 throw new ss_InvalidOperationException('Collection is read-only');
3015 },
3016 clear: function $DictionaryCollection$clear() {
3017 throw new ss_InvalidOperationException('Collection is read-only');
3018 },
3019 remove: function $DictionaryCollection$remove() {
3020 throw new ss_InvalidOperationException('Collection is read-only');
3021 }
3022}, null, [ss_IEnumerable, ss_ICollection]);
3023
3024///////////////////////////////////////////////////////////////////////////////
3025// IDisposable
3026
3027var ss_IDisposable = function IDisposable$() { };
3028ss_IDisposable.__typeName = 'ss.IDisposable';
3029ss.IDisposable = ss_IDisposable;
3030ss.initInterface(ss_IDisposable, ss, { dispose: null });
3031
3032///////////////////////////////////////////////////////////////////////////////
3033// StringBuilder
3034
3035var ss_StringBuilder = function StringBuilder$(s) {
3036 this._parts = (ss.isValue(s) && s != '') ? [s] : [];
3037 this.length = ss.isValue(s) ? s.length : 0;
3038}
3039
3040ss_StringBuilder.__typeName = 'ss.StringBuilder';
3041ss.StringBuilder = ss_StringBuilder;
3042ss.initClass(ss_StringBuilder, ss, {
3043 append: function StringBuilder$append(o) {
3044 if (ss.isValue(o)) {
3045 var s = o.toString();
3046 ss.add(this._parts, s);
3047 this.length += s.length;
3048 }
3049 return this;
3050 },
3051
3052 appendChar: function StringBuilder$appendChar(c) {
3053 return this.append(String.fromCharCode(c));
3054 },
3055
3056 appendLine: function StringBuilder$appendLine(s) {
3057 this.append(s);
3058 this.append('\r\n');
3059 return this;
3060 },
3061
3062 appendLineChar: function StringBuilder$appendLineChar(c) {
3063 return this.appendLine(String.fromCharCode(c));
3064 },
3065
3066 clear: function StringBuilder$clear() {
3067 this._parts = [];
3068 this.length = 0;
3069 },
3070
3071 toString: function StringBuilder$toString() {
3072 return this._parts.join('');
3073 }
3074});
3075
3076///////////////////////////////////////////////////////////////////////////////
3077// Random
3078
3079var ss_Random = function Random$(seed) {
3080 var _seed = (seed === undefined) ? parseInt(Date.now() % 2147483648) : parseInt(Math.abs(seed));
3081 this.inext = 0;
3082 this.inextp = 21;
3083 this.seedArray = new Array(56);
3084 for(var i = 0; i < 56; i++)
3085 this.seedArray[i] = 0;
3086
3087 _seed = 161803398 - _seed;
3088 if (_seed < 0)
3089 _seed += 2147483648;
3090 this.seedArray[55] = _seed;
3091 var mk = 1;
3092 for (var i = 1; i < 55; i++) {
3093 var ii = (21 * i) % 55;
3094 this.seedArray[ii] = mk;
3095 mk = _seed - mk;
3096 if (mk < 0)
3097 mk += 2147483648;
3098
3099 _seed = this.seedArray[ii];
3100 }
3101 for (var j = 1; j < 5; j++) {
3102 for (var k = 1; k < 56; k++) {
3103 this.seedArray[k] -= this.seedArray[1 + (k + 30) % 55];
3104 if (this.seedArray[k] < 0)
3105 this.seedArray[k] += 2147483648;
3106 }
3107 }
3108};
3109
3110ss_Random.__typeName = 'ss.Random';
3111ss.Random = ss_Random;
3112ss.initClass(ss_Random, ss, {
3113 next: function Random$next() {
3114 return this.sample() * 2147483648 | 0;
3115 },
3116 nextMax: function Random$nextMax(max) {
3117 return this.sample() * max | 0;
3118 },
3119 nextMinMax: function Random$nextMinMax(min, max) {
3120 return (this.sample() * (max - min) + min) | 0;
3121 },
3122 nextBytes: function Random$nextBytes(bytes) {
3123 for (var i = 0; i < bytes.length; i++)
3124 bytes[i] = (this.sample() * 256) | 0;
3125 },
3126 nextDouble: function Random$nextDouble() {
3127 return this.sample();
3128 },
3129 sample: function Random$sample() {
3130 if (++this.inext >= 56)
3131 this.inext = 1;
3132 if (++this.inextp >= 56)
3133 this.inextp = 1;
3134
3135 var retVal = this.seedArray[this.inext] - this.seedArray[this.inextp];
3136
3137 if (retVal < 0)
3138 retVal += 2147483648;
3139
3140 this.seedArray[this.inext] = retVal;
3141
3142 return retVal * (1.0 / 2147483648);
3143 }
3144});
3145
3146///////////////////////////////////////////////////////////////////////////////
3147// EventArgs
3148
3149var ss_EventArgs = function EventArgs$() {
3150}
3151ss_EventArgs.__typeName = 'ss.EventArgs';
3152ss.EventArgs = ss_EventArgs;
3153ss.initClass(ss_EventArgs, ss, {});
3154
3155ss_EventArgs.Empty = new ss_EventArgs();
3156
3157///////////////////////////////////////////////////////////////////////////////
3158// Exception
3159
3160var ss_Exception = function Exception$(message, innerException) {
3161 this._message = message || 'An error occurred.';
3162 this._innerException = innerException || null;
3163 this._error = new Error();
3164}
3165
3166ss_Exception.__typeName = 'ss.Exception';
3167ss.Exception = ss_Exception;
3168ss.initClass(ss_Exception, ss, {
3169 get_message: function Exception$get_message() {
3170 return this._message;
3171 },
3172 get_innerException: function Exception$get_innerException() {
3173 return this._innerException;
3174 },
3175 get_stack: function Exception$get_stack() {
3176 return this._error.stack;
3177 }
3178});
3179
3180ss_Exception.wrap = function Exception$wrap(o) {
3181 if (ss.isInstanceOfType(o, ss_Exception)) {
3182 return o;
3183 }
3184 else if (o instanceof TypeError) {
3185 // TypeError can either be 'cannot read property blah of null/undefined' (proper NullReferenceException), or it can be eg. accessing a non-existent method of an object.
3186 // As long as all code is compiled, they should with a very high probability indicate the use of a null reference.
3187 return new ss_NullReferenceException(o.message, new ss_JsErrorException(o));
3188 }
3189 else if (o instanceof RangeError) {
3190 return new ss_ArgumentOutOfRangeException(null, o.message, new ss_JsErrorException(o));
3191 }
3192 else if (o instanceof Error) {
3193 return new ss_JsErrorException(o);
3194 }
3195 else {
3196 return new ss_Exception(o.toString());
3197 }
3198};
3199
3200////////////////////////////////////////////////////////////////////////////////
3201// NotImplementedException
3202
3203var ss_NotImplementedException = function NotImplementedException$(message, innerException) {
3204 ss_Exception.call(this, message || 'The method or operation is not implemented.', innerException);
3205};
3206ss_NotImplementedException.__typeName = 'ss.NotImplementedException';
3207ss.NotImplementedException = ss_NotImplementedException;
3208ss.initClass(ss_NotImplementedException, ss, {}, ss_Exception);
3209
3210////////////////////////////////////////////////////////////////////////////////
3211// NotSupportedException
3212
3213var ss_NotSupportedException = function NotSupportedException$(message, innerException) {
3214 ss_Exception.call(this, message || 'Specified method is not supported.', innerException);
3215};
3216ss_NotSupportedException.__typeName = 'ss.NotSupportedException';
3217ss.NotSupportedException = ss_NotSupportedException;
3218ss.initClass(ss_NotSupportedException, ss, {}, ss_Exception);
3219
3220////////////////////////////////////////////////////////////////////////////////
3221// AggregateException
3222
3223var ss_AggregateException = function AggregateException$(message, innerExceptions) {
3224 this.innerExceptions = ss.isValue(innerExceptions) ? ss.arrayFromEnumerable(innerExceptions) : [];
3225 ss_Exception.call(this, message || 'One or more errors occurred.', this.innerExceptions.length ? this.innerExceptions[0] : null);
3226};
3227
3228ss_AggregateException.__typeName = 'ss.AggregateException';
3229ss.AggregateException = ss_AggregateException;
3230ss.initClass(ss_AggregateException, ss, {
3231 flatten: function AggregateException$flatten() {
3232 var inner = [];
3233 for (var i = 0; i < this.innerExceptions.length; i++) {
3234 var e = this.innerExceptions[i];
3235 if (ss.isInstanceOfType(e, ss_AggregateException)) {
3236 inner.push.apply(inner, e.flatten().innerExceptions);
3237 }
3238 else {
3239 inner.push(e);
3240 }
3241 }
3242 return new ss_AggregateException(this._message, inner);
3243 }
3244}, ss_Exception);
3245
3246////////////////////////////////////////////////////////////////////////////////
3247// PromiseException
3248
3249var ss_PromiseException = function PromiseException(args, message, innerException) {
3250 ss_Exception.call(this, message || (args.length && args[0] ? args[0].toString() : 'An error occurred'), innerException);
3251 this.arguments = ss.arrayClone(args);
3252};
3253
3254ss_PromiseException.__typeName = 'ss.PromiseException';
3255ss.PromiseException = ss_PromiseException;
3256ss.initClass(ss_PromiseException, ss, {
3257 get_arguments: function PromiseException$get_arguments() {
3258 return this._arguments;
3259 }
3260}, ss_Exception);
3261
3262////////////////////////////////////////////////////////////////////////////////
3263// JsErrorException
3264
3265var ss_JsErrorException = function JsErrorException$(error, message, innerException) {
3266 ss_Exception.call(this, message || error.message, innerException);
3267 this.error = error;
3268};
3269ss_JsErrorException.__typeName = 'ss.JsErrorException';
3270ss.JsErrorException = ss_JsErrorException;
3271ss.initClass(ss_JsErrorException, ss, {
3272 get_stack: function Exception$get_stack() {
3273 return this.error.stack;
3274 }
3275}, ss_Exception);
3276
3277////////////////////////////////////////////////////////////////////////////////
3278// ArgumentException
3279
3280var ss_ArgumentException = function ArgumentException$(message, paramName, innerException) {
3281 ss_Exception.call(this, message || 'Value does not fall within the expected range.', innerException);
3282 this.paramName = paramName || null;
3283};
3284
3285ss_ArgumentException.__typeName = 'ss.ArgumentException';
3286ss.ArgumentException = ss_ArgumentException;
3287ss.initClass(ss_ArgumentException, ss, {}, ss_Exception);
3288
3289////////////////////////////////////////////////////////////////////////////////
3290// ArgumentNullException
3291
3292var ss_ArgumentNullException = function ArgumentNullException$(paramName, message, innerException) {
3293 if (!message) {
3294 message = 'Value cannot be null.';
3295 if (paramName)
3296 message += '\nParameter name: ' + paramName;
3297 }
3298
3299 ss_ArgumentException.call(this, message, paramName, innerException);
3300};
3301
3302ss_ArgumentNullException.__typeName = 'ss.ArgumentNullException';
3303ss.ArgumentNullException = ss_ArgumentNullException;
3304ss.initClass(ss_ArgumentNullException, ss, {}, ss_ArgumentException);
3305
3306////////////////////////////////////////////////////////////////////////////////
3307// ArgumentNullException
3308
3309var ss_ArgumentOutOfRangeException = function ArgumentOutOfRangeException$(paramName, message, innerException, actualValue) {
3310 if (!message) {
3311 message = 'Value is out of range.';
3312 if (paramName)
3313 message += '\nParameter name: ' + paramName;
3314 }
3315
3316 ss_ArgumentException.call(this, message, paramName, innerException);
3317 this.actualValue = actualValue || null;
3318};
3319
3320ss_ArgumentOutOfRangeException.__typeName = 'ss.ArgumentOutOfRangeException';
3321ss.ArgumentOutOfRangeException = ss_ArgumentOutOfRangeException;
3322ss.initClass(ss_ArgumentOutOfRangeException, ss, {}, ss_ArgumentException);
3323
3324////////////////////////////////////////////////////////////////////////////////
3325// FormatException
3326
3327var ss_FormatException = function FormatException$(message, innerException) {
3328 ss_Exception.call(this, message || 'Invalid format.', innerException);
3329};
3330ss_FormatException.__typeName = 'ss.FormatException';
3331ss.FormatException = ss_FormatException;
3332ss.initClass(ss_FormatException, ss, {}, ss_Exception);
3333
3334////////////////////////////////////////////////////////////////////////////////
3335// DivideByZeroException
3336
3337var ss_DivideByZeroException = function DivideByZeroException$(message, innerException) {
3338 ss_Exception.call(this, message || 'Division by 0.', innerException);
3339};
3340ss_DivideByZeroException.__typeName = 'ss.DivideByZeroException';
3341ss.DivideByZeroException = ss_DivideByZeroException;
3342ss.initClass(ss_DivideByZeroException, ss, {}, ss_Exception);
3343
3344////////////////////////////////////////////////////////////////////////////////
3345// InvalidCastException
3346
3347var ss_InvalidCastException = function InvalidCastException$(message, innerException) {
3348 ss_Exception.call(this, message || 'The cast is not valid.', innerException);
3349};
3350ss_InvalidCastException.__typeName = 'ss.InvalidCastException';
3351ss.InvalidCastException = ss_InvalidCastException;
3352ss.initClass(ss_InvalidCastException, ss, {}, ss_Exception);
3353
3354////////////////////////////////////////////////////////////////////////////////
3355// InvalidOperationException
3356
3357var ss_InvalidOperationException = function InvalidOperationException$(message, innerException) {
3358 ss_Exception.call(this, message || 'Operation is not valid due to the current state of the object.', innerException);
3359};
3360ss_InvalidOperationException.__typeName = 'ss.InvalidOperationException';
3361ss.InvalidOperationException = ss_InvalidOperationException;
3362ss.initClass(ss_InvalidOperationException, ss, {}, ss_Exception);
3363
3364////////////////////////////////////////////////////////////////////////////////
3365// NullReferenceException
3366
3367var ss_NullReferenceException = function NullReferenceException$(message, innerException) {
3368 ss_Exception.call(this, message || 'Object is null.', innerException);
3369};
3370ss_NullReferenceException.__typeName = 'ss.NullReferenceException';
3371ss.NullReferenceException = ss_NullReferenceException;
3372ss.initClass(ss_NullReferenceException, ss, {}, ss_Exception);
3373
3374////////////////////////////////////////////////////////////////////////////////
3375// KeyNotFoundException
3376
3377var ss_KeyNotFoundException = function KeyNotFoundException$(message, innerException) {
3378 ss_Exception.call(this, message || 'Key not found.', innerException);
3379};
3380ss_KeyNotFoundException.__typeName = 'ss.KeyNotFoundException';
3381ss.KeyNotFoundException = ss_KeyNotFoundException;
3382ss.initClass(ss_KeyNotFoundException, ss, {}, ss_Exception);
3383
3384////////////////////////////////////////////////////////////////////////////////
3385// InvalidOperationException
3386
3387var ss_AmbiguousMatchException = function AmbiguousMatchException$(message, innerException) {
3388 ss_Exception.call(this, message || 'Ambiguous match.', innerException);
3389};
3390ss_AmbiguousMatchException.__typeName = 'ss.AmbiguousMatchException';
3391ss.AmbiguousMatchException = ss_AmbiguousMatchException;
3392ss.initClass(ss_AmbiguousMatchException, ss, {}, ss_Exception);
3393
3394///////////////////////////////////////////////////////////////////////////////
3395// IteratorBlockEnumerable
3396
3397var ss_IteratorBlockEnumerable = function IteratorBlockEnumerable$(getEnumerator, $this) {
3398 this._getEnumerator = getEnumerator;
3399 this._this = $this;
3400};
3401
3402ss_IteratorBlockEnumerable.__typeName = 'ss.IteratorBlockEnumerable';
3403ss.IteratorBlockEnumerable = ss_IteratorBlockEnumerable;
3404ss.initClass(ss_IteratorBlockEnumerable, ss, {
3405 getEnumerator: function IteratorBlockEnumerable$getEnumerator() {
3406 return this._getEnumerator.call(this._this);
3407 }
3408}, null, [ss_IEnumerable]);
3409
3410///////////////////////////////////////////////////////////////////////////////
3411// IteratorBlockEnumerator
3412
3413var ss_IteratorBlockEnumerator = function IteratorBlockEnumerator$(moveNext, getCurrent, dispose, $this) {
3414 this._moveNext = moveNext;
3415 this._getCurrent = getCurrent;
3416 this._dispose = dispose;
3417 this._this = $this;
3418};
3419
3420ss_IteratorBlockEnumerator.__typeName = 'ss.IteratorBlockEnumerator';
3421ss.IteratorBlockEnumerator = ss_IteratorBlockEnumerator;
3422ss.initClass(ss_IteratorBlockEnumerator, ss, {
3423 moveNext: function IteratorBlockEnumerator$moveNext() {
3424 try {
3425 return this._moveNext.call(this._this);
3426 }
3427 catch (ex) {
3428 if (this._dispose)
3429 this._dispose.call(this._this);
3430 throw ex;
3431 }
3432 },
3433 current: function IteratorBlockEnumerator$current() {
3434 return this._getCurrent.call(this._this);
3435 },
3436 reset: function IteratorBlockEnumerator$reset() {
3437 throw new ss_NotSupportedException('Reset is not supported.');
3438 },
3439 dispose: function IteratorBlockEnumerator$dispose() {
3440 if (this._dispose)
3441 this._dispose.call(this._this);
3442 }
3443}, null, [ss_IEnumerator, ss_IDisposable]);
3444
3445///////////////////////////////////////////////////////////////////////////////
3446// Lazy
3447
3448var ss_Lazy = function Lazy$(valueFactory) {
3449 this._valueFactory = valueFactory;
3450 this.isValueCreated = false;
3451};
3452ss_Lazy.__typeName = 'ss.Lazy';
3453ss.Lazy = ss_Lazy;
3454ss.initClass(ss_Lazy, ss, {
3455 value: function Lazy$value() {
3456 if (!this.isValueCreated) {
3457 this._value = this._valueFactory();
3458 delete this._valueFactory;
3459 this.isValueCreated = true;
3460 }
3461 return this._value;
3462 }
3463});
3464
3465///////////////////////////////////////////////////////////////////////////////
3466// Task
3467
3468var ss_Task = function Task$(action, state) {
3469 this._action = action;
3470 this._state = state;
3471 this.exception = null;
3472 this.status = 0;
3473 this._thens = [];
3474 this._result = null;
3475};
3476
3477ss_Task.delay = function Task$delay(delay) {
3478 var tcs = new ss_TaskCompletionSource();
3479 setTimeout(function() {
3480 tcs.setResult(0);
3481 }, delay);
3482 return tcs.task;
3483};
3484
3485ss_Task.fromResult = function Task$fromResult(result) {
3486 var t = new ss_Task();
3487 t.status = 5;
3488 t._result = result;
3489 return t;
3490};
3491
3492ss_Task.run = function Task$run(f) {
3493 var tcs = new ss_TaskCompletionSource();
3494 setTimeout(function() {
3495 try {
3496 tcs.setResult(f());
3497 }
3498 catch (e) {
3499 tcs.setException(ss_Exception.wrap(e));
3500 }
3501 }, 0);
3502 return tcs.task;
3503};
3504
3505ss_Task.whenAll = function Task$whenAll(tasks) {
3506 var tcs = new ss_TaskCompletionSource();
3507 if (tasks.length === 0) {
3508 tcs.setResult([]);
3509 }
3510 else {
3511 var result = new Array(tasks.length), remaining = tasks.length, cancelled = false, exceptions = [];
3512 for (var i = 0; i < tasks.length; i++) {
3513 (function(i) {
3514 tasks[i].continueWith(function(t) {
3515 switch (t.status) {
3516 case 5:
3517 result[i] = t.getResult();
3518 break;
3519 case 6:
3520 cancelled = true;
3521 break;
3522 case 7:
3523 ss.arrayAddRange(exceptions, t.exception.innerExceptions);
3524 break;
3525 default:
3526 throw new ss_InvalidOperationException('Invalid task status ' + t.status);
3527 }
3528 if (--remaining === 0) {
3529 if (exceptions.length > 0)
3530 tcs.setException(exceptions);
3531 else if (cancelled)
3532 tcs.setCanceled();
3533 else
3534 tcs.setResult(result);
3535 }
3536 });
3537 })(i);
3538 }
3539 }
3540 return tcs.task;
3541};
3542
3543ss_Task.whenAny = function Task$whenAny(tasks) {
3544 if (!tasks.length)
3545 throw new ss_ArgumentException('Must wait for at least one task', 'tasks');
3546
3547 var tcs = new ss_TaskCompletionSource();
3548 for (var i = 0; i < tasks.length; i++) {
3549 tasks[i].continueWith(function(t) {
3550 switch (t.status) {
3551 case 5:
3552 tcs.trySetResult(t);
3553 break;
3554 case 6:
3555 tcs.trySetCanceled();
3556 break;
3557 case 7:
3558 tcs.trySetException(t.exception.innerExceptions);
3559 break;
3560 default:
3561 throw new ss_InvalidOperationException('Invalid task status ' + t.status);
3562 }
3563 });
3564 }
3565 return tcs.task;
3566};
3567
3568ss_Task.fromDoneCallback = function Task$fromDoneCallback(t, i, m) {
3569 var tcs = new ss_TaskCompletionSource(), args;
3570 if (typeof(i) === 'number') {
3571 args = Array.prototype.slice.call(arguments, 3);
3572 if (i < 0)
3573 i += args.length + 1;
3574 }
3575 else {
3576 args = Array.prototype.slice.call(arguments, 2);
3577 m = i;
3578 i = args.length;
3579 }
3580
3581 var cb = function(v) {
3582 tcs.setResult(v);
3583 };
3584
3585 args = args.slice(0, i).concat(cb, args.slice(i));
3586
3587 t[m].apply(t, args);
3588 return tcs.task;
3589};
3590
3591ss_Task.fromPromise = function Task$fromPromise(p, f) {
3592 var tcs = new ss_TaskCompletionSource();
3593 if (typeof(f) === 'number')
3594 f = (function(i) { return function() { return arguments[i >= 0 ? i : (arguments.length + i)]; }; })(f);
3595 else if (typeof(f) !== 'function')
3596 f = function() { return Array.prototype.slice.call(arguments, 0); };
3597
3598 p.then(function() {
3599 tcs.setResult(typeof(f) === 'function' ? f.apply(null, arguments) : null);
3600 }, function() {
3601 tcs.setException(new ss_PromiseException(Array.prototype.slice.call(arguments, 0)));
3602 });
3603 return tcs.task;
3604};
3605
3606ss_Task.fromNode = function Task$fromNode(t, f, m) {
3607 var tcs = new ss_TaskCompletionSource(), args;
3608 if (typeof(f) === 'function') {
3609 args = Array.prototype.slice.call(arguments, 3);
3610 }
3611 else {
3612 args = Array.prototype.slice.call(arguments, 2);
3613 m = f;
3614 f = function() { return arguments[0]; };
3615 }
3616
3617 var cb = function(e) {
3618 if (e)
3619 tcs.setException(ss_Exception.wrap(e));
3620 else
3621 tcs.setResult(f.apply(null, Array.prototype.slice.call(arguments, 1)));
3622 };
3623
3624 args.push(cb);
3625
3626 t[m].apply(t, args);
3627 return tcs.task;
3628};
3629
3630ss_Task.__typeName = 'ss.Task';
3631ss.Task = ss_Task;
3632ss.initClass(ss_Task, ss, {
3633 continueWith: function Task$continueWith(continuation) {
3634 var tcs = new ss_TaskCompletionSource();
3635 var _this = this;
3636 var fn = function() {
3637 try {
3638 tcs.setResult(continuation(_this));
3639 }
3640 catch (e) {
3641 tcs.setException(ss_Exception.wrap(e));
3642 }
3643 };
3644 if (this.isCompleted()) {
3645 setTimeout(fn, 0);
3646 }
3647 else {
3648 this._thens.push(fn);
3649 }
3650 return tcs.task;
3651 },
3652 start: function Task$start() {
3653 if (this.status !== 0)
3654 throw new ss_InvalidOperationException('Task was already started.');
3655 var _this = this;
3656 this.status = 3;
3657 setTimeout(function() {
3658 try {
3659 var result = _this._action(_this._state);
3660 delete _this._action;
3661 delete _this._state;
3662 _this._complete(result);
3663 }
3664 catch (e) {
3665 _this._fail(new ss_AggregateException(null, [ss_Exception.wrap(e)]));
3666 }
3667 }, 0);
3668 },
3669 _runCallbacks: function Task$_runCallbacks() {
3670 for (var i = 0; i < this._thens.length; i++)
3671 this._thens[i](this);
3672 delete this._thens;
3673 },
3674 _complete: function Task$_complete(result) {
3675 if (this.isCompleted())
3676 return false;
3677 this._result = result;
3678 this.status = 5;
3679 this._runCallbacks();
3680 return true;
3681 },
3682 _fail: function Task$_fail(exception) {
3683 if (this.isCompleted())
3684 return false;
3685 this.exception = exception;
3686 this.status = 7;
3687 this._runCallbacks();
3688 return true;
3689 },
3690 _cancel: function Task$_cancel() {
3691 if (this.isCompleted())
3692 return false;
3693 this.status = 6;
3694 this._runCallbacks();
3695 return true;
3696 },
3697 isCanceled: function Task$isCanceled() {
3698 return this.status === 6;
3699 },
3700 isCompleted: function Task$isCompleted() {
3701 return this.status >= 5;
3702 },
3703 isFaulted: function Task$isFaulted() {
3704 return this.status === 7;
3705 },
3706 _getResult: function Task$_getResult(await) {
3707 switch (this.status) {
3708 case 5:
3709 return this._result;
3710 case 6:
3711 throw new ss_InvalidOperationException('Task was cancelled.');
3712 case 7:
3713 throw await ? this.exception.innerExceptions[0] : this.exception;
3714 default:
3715 throw new ss_InvalidOperationException('Task is not yet completed.');
3716 }
3717 },
3718 getResult: function Task$getResult() {
3719 return this._getResult(false);
3720 },
3721 getAwaitedResult: function Task$getAwaitedResult() {
3722 return this._getResult(true);
3723 },
3724 dispose: function Task$dispose() {
3725 }
3726}, null, [ss_IDisposable]);
3727
3728////////////////////////////////////////////////////////////////////////////////
3729// TaskStatus
3730var ss_TaskStatus = function() {
3731};
3732ss_TaskStatus.__typeName = 'ss.TaskStatus';
3733ss.TaskStatus = ss_TaskStatus;
3734ss.initEnum(ss_TaskStatus, ss, { created: 0, running: 3, ranToCompletion: 5, canceled: 6, faulted: 7 });
3735
3736///////////////////////////////////////////////////////////////////////////////
3737// TaskCompletionSource
3738
3739var ss_TaskCompletionSource = function TaskCompletionSource$() {
3740 this.task = new ss_Task();
3741 this.task.status = 3;
3742};
3743
3744ss_TaskCompletionSource.__typeName = 'ss.TaskCompletionSource';
3745ss.TaskCompletionSource = ss_TaskCompletionSource;
3746ss.initClass(ss_TaskCompletionSource, ss, {
3747 setCanceled: function TaskCompletionSource$setCanceled() {
3748 if (!this.task._cancel())
3749 throw new ss_InvalidOperationException('Task was already completed.');
3750 },
3751 setResult: function TaskCompletionSource$setResult(result) {
3752 if (!this.task._complete(result))
3753 throw new ss_InvalidOperationException('Task was already completed.');
3754 },
3755 setException: function TaskCompletionSource$setException(exception) {
3756 if (!this.trySetException(exception))
3757 throw new ss_InvalidOperationException('Task was already completed.');
3758 },
3759 trySetCanceled: function TaskCompletionSource$trySetCanceled() {
3760 return this.task._cancel();
3761 },
3762 trySetResult: function TaskCompletionSource$setResult(result) {
3763 return this.task._complete(result);
3764 },
3765 trySetException: function TaskCompletionSource$setException(exception) {
3766 if (ss.isInstanceOfType(exception, ss_Exception))
3767 exception = [exception];
3768 return this.task._fail(new ss_AggregateException(null, exception));
3769 }
3770});
3771
3772///////////////////////////////////////////////////////////////////////////////
3773// CancelEventArgs
3774
3775var ss_CancelEventArgs = function CancelEventArgs$() {
3776 ss_EventArgs.call(this);
3777 this.cancel = false;
3778}
3779
3780ss_CancelEventArgs.__typeName = 'ss.CancelEventArgs';
3781ss.CancelEventArgs = ss_CancelEventArgs;
3782ss.initClass(ss_CancelEventArgs, ss, {}, ss_EventArgs);
3783
3784///////////////////////////////////////////////////////////////////////////////
3785// Guid
3786
3787var ss_Guid = function Guid$() {
3788};
3789ss_Guid.$valid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/ig;
3790ss_Guid.$split = /^(.{8})(.{4})(.{4})(.{4})(.{12})$/;
3791ss_Guid.empty = '00000000-0000-0000-0000-000000000000';
3792ss_Guid.$rng = new ss_Random();
3793
3794ss_Guid.__typeName = 'ss.Guid';
3795ss.Guid = ss_Guid;
3796ss.initClass(ss_Guid, ss, {}, Object, [ ss_IEquatable, ss_IComparable ]);
3797ss_Guid.__class = false;
3798
3799ss_Guid.isInstanceOfType = function Guid$isInstanceOfType(instance) {
3800 return typeof(instance) === 'string' && instance.match(ss_Guid.$valid);
3801};
3802
3803ss_Guid.getDefaultValue = ss_Guid.createInstance = function Guid$default() {
3804 return ss_Guid.empty;
3805};
3806
3807ss_Guid.parse = function Guid$parse(uuid, format) {
3808 var r = {};
3809 if (ss_Guid.tryParse(uuid, format, r))
3810 return r.$;
3811 throw new ss_FormatException('Unable to parse UUID');
3812};
3813
3814ss_Guid.tryParse = function Guid$tryParse(uuid, format, r) {
3815 r.$ = ss_Guid.empty;
3816 if (!ss.isValue(uuid)) throw new ss_ArgumentNullException('uuid');
3817 if (!format) {
3818 var m = /^[{(]?([0-9a-f]{8})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{4})-?([0-9a-f]{12})[)}]?$/ig.exec(uuid);
3819 if (m) {
3820 r.$ = m.slice(1).join('-').toLowerCase();
3821 return true;
3822 }
3823 }
3824 else {
3825 if (format === 'N') {
3826 var m = ss_Guid.$split.exec(uuid);
3827 if (!m)
3828 return false;
3829 uuid = m.slice(1).join('-');
3830 }
3831 else if (format === 'B' || format === 'P') {
3832 var b = format === 'B';
3833 if (uuid[0] !== (b ? '{' : '(') || uuid[uuid.length - 1] !== (b ? '}' : ')'))
3834 return false;
3835 uuid = uuid.substr(1, uuid.length - 2);
3836 }
3837 if (uuid.match(ss_Guid.$valid)) {
3838 r.$ = uuid.toLowerCase();
3839 return true;
3840 }
3841 }
3842 return false;
3843};
3844
3845ss_Guid.format = function Guid$format(uuid, format) {
3846 switch (format) {
3847 case 'N': return uuid.replace(/-/g, '');
3848 case 'B': return '{' + uuid + '}';
3849 case 'P': return '(' + uuid + ')';
3850 default : return uuid;
3851 }
3852}
3853
3854ss_Guid.fromBytes = function Guid$fromBytes(b) {
3855 if (!b || b.length !== 16)
3856 throw new ss_ArgumentException('b', 'Must be 16 bytes');
3857 var s = b.map(function(x) { return ss.formatNumber(x & 0xff, 'x2'); }).join('');
3858 return ss_Guid.$split.exec(s).slice(1).join('-');
3859}
3860
3861ss_Guid.newGuid = function Guid$newGuid() {
3862 var a = Array(16);
3863 ss_Guid.$rng.nextBytes(a);
3864 a[6] = a[6] & 0x0f | 0x40;
3865 a[8] = a[8] & 0xbf | 0x80;
3866 return ss_Guid.fromBytes(a);
3867};
3868
3869ss_Guid.getBytes = function Guid$getBytes(uuid) {
3870 var a = Array(16);
3871 var s = uuid.replace(/-/g, '');
3872 for (var i = 0; i < 16; i++) {
3873 a[i] = parseInt(s.substr(i * 2, 2), 16);
3874 }
3875 return a;
3876};
3877
3878if (global.ss) {
3879 for (var n in ss) {
3880 if (ss.hasOwnProperty(n))
3881 global.ss[n] = ss[n];
3882 }
3883}
3884else {
3885 global.ss = ss;
3886}
3887})(global);
Note: See TracBrowser for help on using the repository browser.