TouchDevelop/rt/records.ts

///<reference path='refs.ts'/>

module TDev {
    export module RT {

        export class RecordEntry
            extends RTValue {
            // lists the names for fields
            public keys: string[];
            public values: string[];
            public fields: string[];

            public parent: RecordSingleton;
            constructor() {
                super()
        }
            public rtType(): string { return this.parent.rtType() + "$entry"; }
            public noMagicRtType() { return true; }

            public equals(other: RecordEntry) {  // overridden for cloud things which may alias after deletion
                return this === other;
            }


            public isDeleted: boolean;
            public invalidate() {
                this.isDeleted = true;
                this.clear_fields();
                this.decorators = undefined;
            }


            public getShortStringRepresentation(): string {
                return "[" + this.parent.entryKindName + "]";
            }


            public post_to_wall(frame: IStackFrame): void {
                frame.rt.postBoxedHtml(this.parent.getTable([this], frame), frame.pc);
            }

            public to_json(s: IStackFrame): JsonObject {
                var ctx = new JsonExportCtx(s);
                ctx.push(this);
                var json = this.exportJson(ctx);
                ctx.pop(this);
                return JsonObject.wrap(json);
            }

            public from_json(jobj: JsonObject, s: IStackFrame): void {
                this.parent.logMutation(s);
                this.importJsonFields(new JsonImportCtx(s), jobj.value());
            }

            public importJsonFields(ctx: JsonImportCtx, jobj: JsonObject) {
                Util.oops("compiled code is supposed to override this method");
            }

            public jsonExportKey(ctx: JsonExportCtx) {
                return null; // overridden by table entries
            }

          //  public importJson(ctx: JsonImportCtx, jobj: JsonObject) {
         //       return this.importJsonFields(ctx, jobj);
          //  }

            public exportJson(ctx: JsonExportCtx): any {
                if (this.is_deleted())
                    return undefined;
                var keys = this.fields.map((k: string) => this[k + "_realname"]);
                var vals = this.fields.map((k: string) => this.getFieldValue(k, ctx.stackframe));
                return ctx.encodeObjectNode(this, keys, vals);
            }

            public getIndexCard(sf:IStackFrame): HTMLElement {
                var div: HTMLElement = document.createElement("div");
                div.className = "wall-record";

                var hr: HTMLElement = document.createElement("h3");
                hr.textContent = this.parent.entryKindName;
                hr.className = "wall-record";
                div.appendChild(hr);

                if (this.is_deleted()) {
                    var p: HTMLElement = document.createElement("p");
                    p.className = "wall-record";
                    p.textContent = "(deleted)";
                    div.appendChild(p);
                }
                else {
                    var ul: HTMLElement = document.createElement("ul");
                    ul.className = "wall-record";
                    this.fields.forEach((k: string) => {
                        var name = this[k + "_realname"];
                        var val = this.getFieldValue(k, sf);
                        var s = name + ": ";
                        if (val instanceof RTValue)
                            s = s + (<RTValue> val).getShortStringRepresentation();
                        else if (typeof val !== "undefined")
                            s = s + val;

                        var li: HTMLElement = document.createElement("li");
                        li.className = "wall-record";
                        li.textContent = s;
                        ul.appendChild(li);
                    });
                    div.appendChild(ul);
                }
                return div;
            }

            public debuggerDisplay(clickHandler: () => any): HTMLElement {
                var full: HTMLElement;
                try {
                    full = this.getIndexCard(null);
                } catch (e) {
                    return span(null, e.message || "").withClick(clickHandler); // can be a "user error" when record originated from stale session
                }
                var sized = div("wall-record", this.parent.entryKindName);

                var fullDisplay = false;
                var updateButton = () => {
                    full.style.display = fullDisplay ? "block" : "none";
                    sized.style.display = fullDisplay ? "none" : "block";
                };
                updateButton();

                return div(null, sized, full).withClick(() => {
                    clickHandler();
                    updateButton();
                    fullDisplay = !fullDisplay;
                });
            }

            public debuggerChildren(): any {
                if (this.is_deleted()) return undefined;

                var r = {};
                this.fields.forEach((k: string) => {
                    var val = this.getFieldValue(k, undefined);
                    r[ this[k + "_realname"] ] = val;
                });
                return r;
            }

            public getFieldValue(fieldname: string, sf:IStackFrame): any {
                return this[fieldname];
            }

            public getTableHeader(): HTMLElement {
                var tr: HTMLElement = document.createElement("tr");
                this.fields.forEach((k: string) => {
                    var th: HTMLElement = document.createElement("th");
                    th.setAttribute("scope", "col");
                    th.textContent = this[k + "_realname"];
                    tr.appendChild(th);
                });
                return tr;
            }
            public getTableRow(sf: IStackFrame): HTMLElement {
                var tr: HTMLElement = document.createElement("tr");
                this.fields.forEach((k: string) => {
                    var td: HTMLElement = document.createElement("td");
                    var val = this.getFieldValue(k, sf);
                    td.textContent = (val instanceof RTValue) ? (<RTValue> val).getShortStringRepresentation()
                    : ((typeof val === "undefined") ? "" : val);
                    tr.appendChild(td);
                });
                return tr;
            }

            //static check_invalid(ref: RecordEntry): boolean {
            //    return (!ref) ? true : ref.is_deleted();
            //}


            // overridden by persistent records
            public clear_fields(s?:IStackFrame) {
                if (s) this.parent.logMutation(s);
                this.values.forEach((k: string) => {
                    //this[k] = undefined;  does not work... masks default value in prototype
                    delete this[k];
                })
        }

            // overridden by index and table
            public is_deleted(): boolean { return false; }
            // overridden by cloud persisted things
            public confirmed(): boolean { return true; }

            public perform_get(fieldname: string, s: IStackFrame): RTValue { return Util.abstract(); }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) { return Util.abstract(); }
            public perform_confirmed(fieldname: string, s: IStackFrame): boolean { return true; } // overridden for cloud records
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) { return Util.abstract(); }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) { return Util.abstract(); }
            public perform_clear(fieldname: string, s: IStackFrame) { return Util.abstract(); }
        }

        export class TableEntry
            extends RecordEntry {
            public rownumber: number;

            public toJsonKey(): any {
                return this.rownumber;
            }

            public jsonExportKey(ctx: JsonExportCtx) {
                return this.rownumber.toString();
            }


            constructor() {
                super()
            }

            public getShortStringRepresentation(): string {
                return "[" + this.parent.entryKindName + this.rownumber + "]";
            }


            public delete_row(s:IStackFrame) {
                this.parent.logMutation(s);
                if (this.isDeleted) return;
                var idx = (<TableSingleton> this.parent)._elements.indexOf(this);
                if (idx >= 0)
                    (<TableSingleton> this.parent)._elements.splice(idx, 1);
                this.invalidate();
                (<TableSingleton> this.parent).clearCachedData();

            }

            public perform_get(fieldname: string, s: IStackFrame): RTValue {
                this.is_deleted();
                return this[fieldname];
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted) {
                    if (value == undefined) // or null
                        delete this[fieldname];
                    else
                        this[fieldname] = value;
                }
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted && value)
                    this[fieldname] += value;
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted)
                    delete this[fieldname];
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted && !this[fieldname] && value)
                    this[fieldname] = value;
            }

            public is_deleted(): boolean {
                if (this.isDeleted)
                    return true;
                var deleted = false;
                if (this.keys.length > 0) {
                    this.keys.forEach((k: string) => {
                        if (deleted)
                            return;
                        var key = this[k];
                        if (((key instanceof TableEntry) && (<TableEntry> key).is_deleted())
                            || ((key instanceof CloudTableEntry) && (<CloudTableEntry> key).is_deleted()))
                            deleted = true;
                    });
                }
                if (deleted && !this.isDeleted) {
                    this.invalidate();
                }
                return deleted;
            }

            public keyCompareTo(other: any): number {
                return this.rownumber - (<TableEntry> other).rownumber;
            }


        }

        export class CloudTableEntry
            extends RecordEntry {
            // serialized fields
            public sessionname: string;
            public uid: string;

            public toJsonKey(): any {
                return this.sessionname + this.uid;
            }

            public equals(other: RecordEntry) {
                var o = <CloudTableEntry> other;
                return this.uid === o.uid && this.sessionname === o.sessionname;
            }

            constructor() {
                super()
            }

            public getShortStringRepresentation(): string {
                return "[" + this.parent.entryKindName + ": " + this.uid + "]";
            }

            // handle
            public item: Revisions.Item;

            // link this table entry with the session item
            public hookup(item: Revisions.Item) {
                this.sessionname = item.session.servername;
                this.uid = item.uid;
                this.item = item;
                item.backlink = this;
                this.read_cloud_fields(item);
            }

            public unlink() {
                this.decorators = undefined;
                this.item = undefined;
                for (var i = 0; i < this.values.length; i++) {
                    this[this.values[i]] = undefined;
                }
            }

            public getFieldValue(fieldname: string, s:IStackFrame): any {
                this.check();
                var f = this[fieldname];
                if (f instanceof Revisions.LVal)
                    return Conv.read(this.parent.session(), <Revisions.LVal>f, s);
                else
                    return f;
            }


            public check(abort = true): boolean {
                //Util.log("check: session status: " + TDev.RT.CloudData.connection_status(true));
                if (this.sessionname !== this.parent.session().servername) {
                    if (abort)
                        Util.userError(lf("stale row: originated in a different session"));
                    else
                        return false;
                }
                if (this.item === undefined || this.item.backlink != this || this.item.session !== this.parent.session()) {
                    //console.log("check: hookup: " + this.uid);
                    var session = this.parent.session();
                    var item = session.user_get_item(this.uid);
                    if (item === undefined)
                        item = session.user_create_tombstone(this.parent.cloudtype, this.uid, this.keys.map(k => undefined), []);
                    this.hookup(item);
                }
                return true;
            }

            public confirmed(): boolean {
                this.check();
                var session = this.parent.session();
                var confirmed = this.existenceConfirmed()
                    && !this.values.some((val) => !session.user_is_datum_confirmed(this[val]));
                return confirmed;
            }

            public existenceConfirmed(): boolean {
                return this.parent.session().user_is_datum_confirmed(this.item) &&
                    !this.keys.some((key) => {
                        var r = this[key];
                        return (r && r instanceof CloudTableEntry && !(<CloudTableEntry>r).existenceConfirmed());
                    });
            }

            public jsonExportKey(ctx: JsonExportCtx) {
                this.check();
                var uid = this.uid;
                if (uid.indexOf(".") === -1) {
                    var membernumber = this.parent.session().membernumber.toString();
                    if (membernumber === "-1")
                        membernumber = "";
                    uid = membernumber + "." + uid;
                }
                return uid;
            }

            public delete_row(s?:IStackFrame) {
                if (s) this.parent.logMutation(s);
                this.check();
                this.parent.session().user_delete_item(this.item);
                (<CloudTableSingleton> this.parent).clearCachedData();
            }


            public clear_fields(s?: IStackFrame) {
                if (s) this.parent.logMutation(s);
                this.check();
                for (var i = 0; i < this.values.length; i++) {
                    var lval: Revisions.LVal = this[this.values[i]];
                    Conv.clear(this.parent.session(), lval);
                }
            }


            public perform_get(fieldname: string, s: IStackFrame): RTValue {
                this.check();
                return Conv.read(this.parent.session(), this[fieldname], s);
            }
            public perform_confirmed(fieldname: string): boolean {
                this.check();
                return this.parent.session().user_is_datum_confirmed(this[fieldname]);
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, false);
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, true);
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, true);
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], undefined, false);
            }

            public is_deleted(): boolean {
                if (!this.check())
                    return true;
                return this.parent.session().user_is_datum_deleted(this.item);
            }

            public keyCompareTo(other: any): number {
                return this.item.compareTo(other.item);
            }

            //set up keys
            public read_cloud_fields(datum: Revisions.Datum) {
                // setup keys
                var lkeycount = 0;
                var ukeycount = 0;
                Util.assert(this.parent.key_cloudtypes.length === this.keys.length);
                for (var i = 0; i < this.keys.length; i++) {
                    var keytype = this.parent.key_cloudtypes[i];
                    var val: any;
                    if (keytype.charAt(keytype.length - 1) === ")") {
                        // row key
                        var uid = datum.ukeys[ukeycount];
                        var linkedtable = this.parent.linked_cloudtables[ukeycount];
                        val = linkedtable.import_item_from_uid(uid);
                        ukeycount += 1;
                    } else {
                        // literal key
                        val = Conv.fromCloud(keytype, datum.lkeys[lkeycount]);
                        lkeycount += 1;
                    }
                    this[this.keys[i]] = val;
                }
                //set up lvals
                Util.assert(this.parent.value_cloudtypes.length === this.values.length);
                for (var i = 0; i < this.values.length; i++) {
                    var property = this.parent.value_cloudtypes[i];
                    this[this.values[i]] = this.parent.session().user_get_lval(property, [this.uid], []);
                }
            }
        }

        export class IndexEntry
            extends RecordEntry {
            constructor() {
                super()
        }
            public compareTo(other: IndexEntry): number {
                var diff = 0;
                this.keys.forEach((k: string): void => {
                    if (!diff) {
                        var a = this[k];
                        var b = other[k];
                        switch (typeof a) {
                            case "string":
                                diff = a.localeCompare(b);
                                break;
                            case "number":
                                diff = a - b;
                                break;
                            case "boolean":
                                if (a !== b)
                                    diff = (a ? 1 : -1);
                                break;
                            default:
                                diff = RTValue.CompareKeys(a, b);
                                break;
                        }
                    }
                });
                return diff;
            }

            public is_deleted(): boolean {
                if (this.isDeleted)
                    return true;
                var deleted = false;
                if (this.keys.length > 0) {
                    this.keys.forEach((k: string) => {
                        if (deleted)
                            return;
                        var key = this[k];
                        if (key && key instanceof TableEntry) {
                            if ((<TableEntry> key).is_deleted())
                                deleted = true;
                        }
                    });
                }
                if (deleted && !this.isDeleted) {
                    this.invalidate();
                }
                return deleted;
            }


            public isDeleted = false;

            public perform_get(fieldname: string, s: IStackFrame): RTValue {
                this.is_deleted();
                return this[fieldname];
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted) {
                    if (value == undefined) // or null
                        delete this[fieldname];
                    else
                        this[fieldname] = value;
                }
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted && value)
                    this[fieldname] += value;
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted)
                    delete this[fieldname];
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                if (!this.isDeleted && !this[fieldname] && value)
                    this[fieldname] = value;
            }

            public hasNondefaultValue(): boolean {
                var found = false;
                this.values.forEach((v: string) => {
                    if (found)
                        return;
                    var val = this[v];
                    if (val) {
                        if (typeof val !== "object")
                            found = true;
                        else {
                            Util.assert(val instanceof RTValue);
                            found = !val.isDefaultValue();
                        }
                    }
                });
                return found;
            }
        }

        export class ObjectEntry
            extends RecordEntry {
            constructor() {
                super()
            }

            public on_render_heap = false;


            public perform_get(fieldname: string, s: IStackFrame): RTValue {
                return this[fieldname];
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.on_render_heap);
                //if (value === undefined)
                //    delete this[fieldname]
                //else
                this[fieldname] = value;
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.on_render_heap);
                if (value)
                    this[fieldname] += value;
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                s.rt.logDataWrite(this.on_render_heap);
                delete this[fieldname];
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.on_render_heap);
                if (!this[fieldname] && value)
                    this[fieldname] = value;
            }

        }

        export class DecoratorEntry
            extends RecordEntry {

            public _written = 0;
            constructor() {
                super()
        }
            public post_to_wall(frame: IStackFrame): void {
                this.clear_if_necessary();
                super.post_to_wall(frame);
            }

            private clear_if_necessary() {
                var decsing = <DecoratorSingleton> this.parent;
                if (this._written < decsing._generation) {
                    this._written = decsing._generation;
                    this.clear_fields();
                }
            }

            private target(): RTValue {
                return this[this.keys[0]];
            }

            public perform_get(fieldname: string, s:IStackFrame): RTValue {
                this.clear_if_necessary();
                return this[fieldname];
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.target().on_render_heap);
                this.clear_if_necessary();
                //if (value === undefined)
                //    delete this[fieldname];
                //else
                this[fieldname] = value;
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.target().on_render_heap);
                this.clear_if_necessary();
                if (value)
                    this[fieldname] += value;
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                s.rt.logDataWrite(this.target().on_render_heap);
                this.clear_if_necessary();
                delete this[fieldname];
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(this.target().on_render_heap);
                this.clear_if_necessary();
                if (!this[fieldname] && value)
                    this[fieldname] = value;
            }

        }


        export class RecordSingleton
            extends RTValue {
            constructor() {
                super()
            }
            public rtType(): string { return this.libName + "$" + this.stableName; }
            public entryCtor: (par: RecordSingleton) => RecordEntry;
            public selfCtor: (ln: string) => RecordSingleton;
            public stableName: string;
            public cloudtype: string;
            public key_cloudtypes: string[];
            public value_cloudtypes: string[];
            public linked_cloudtables: CloudTableSingleton[];
            public localsession: boolean;
            public libName: any;
            public onChangeEvent: RT.Event_;
            public entryKindName: string;
            public noMagicRtType() { return true; }
            public initParent() { }
            public isSerializable() { return true; }

            public session(): Revisions.ClientSession {
                var s = (this.localsession) ? Runtime.theRuntime.sessions.getLocalSession() : Runtime.theRuntime.sessions.getCurrentSession();
                if (!s)
                    Util.oops("missing " + (this.localsession ? "local" : "cloud") + " session, " + this.stableName);
                return s;
            }

            public create_collection(s: IStackFrame): Collection<RecordEntry> {
                var o = Collection.fromArray<RecordEntry>([], this)
                o.on_render_heap = s.rt.rendermode;
                return o;
            }

            public copy_to_collection(s: IStackFrame): Collection<RecordEntry> {
                var o = this.create_collection(s);
                o.a.pushRange(this.get_enumerator());
                return o;
            }

            // returns only entries by this user
            // used by indexes whose first key is of type User
            public my_entries(s: IStackFrame): Collection<RecordEntry> {
                var o = this.create_collection(s);
                var userid = Cloud.getUserId();
                if (userid === undefined)
                    return undefined;
                o.a.pushRange(this.get_enumerator().filter((e) => {
                    var u = e[e.keys[0]];
                    return u._id === userid;
                }));
                return o;
            }


            // returns entries linked to the given rows
            // used by tables with links
            public entries_linked_to(): Collection<RecordEntry> {
                var supplied = arguments;
                var o = this.create_collection(arguments[arguments.length - 1]);
                o.a.pushRange(this.get_enumerator().filter((e) => {
                    for (var i = 0; i < e.keys.length; i++)
                        if (e[e.keys[i]] !== supplied[i])
                            return false;
                    return true;
                }));
                return o;
            }


            public on_changed(body: Action, s: IStackFrame): EventBinding {
                if (!this.onChangeEvent)
                    this.onChangeEvent = new RT.Event_();
                var b = this.onChangeEvent.addHandler(body);
                s.rt.queueLocalEvent(this.onChangeEvent, undefined, true, true);
                return b;
            }

            public logMutation(s: IStackFrame) {
                s.rt.logDataWrite(false);
                if (this.onChangeEvent)
                    s.rt.queueLocalEvent(this.onChangeEvent, undefined, true, true);
            }

            public wait_for_update(r: ResumeCtx)
            {
                if (!this.onChangeEvent)
                    this.onChangeEvent = new RT.Event_();
                this.onChangeEvent.addAwaiter(v => {
                    r.resume()
                })
            }


            public getTable(entries: RecordEntry[], sf: IStackFrame): HTMLElement {
                var tab: HTMLElement = document.createElement("table");
                tab.className = "wall-table";
                //tab.setAttribute("summary", "TODO:table summary");

                //var caption: HTMLElement = document.createElement("caption");
                //caption.textContent = "TODO: caption";
                //tab.appendChild(caption);

                // create dummy elt to access names
                if (entries.length === 0) {
                    var tr: HTMLElement = document.createElement("tr");
                    var td: HTMLElement = document.createElement("td");
                    tr.textContent = "(empty table)"
                tr.appendChild(td);
                    tab.appendChild(tr);
                } else {
                    tab.appendChild(entries[0].getTableHeader());
                    entries.forEach((e: TableEntry) => tab.appendChild(e.getTableRow(sf)));
                }
                return tab;
            }

            public debuggerDisplay(_): HTMLElement {
                return null;
            }

            public invalid_row() {
                return undefined;
            }
            public invalid() {
                return undefined;
            }

            public get_enumerator(): RecordEntry[] { // overridden by index and table
                Util.oops("not implemented: enumerator");
                return [];
            }

            public exportJson(ctx: JsonExportCtx): any {
                var entries = this.get_enumerator();
                return ctx.encodeArrayNode(this, entries.slice(0));
            }

            public to_json(s: IStackFrame): JsonObject {
                var ctx = new JsonExportCtx(s);
                ctx.push(this);
                var json = this.exportJson(ctx);
                ctx.pop(this);
                return JsonObject.wrap(json);
            }

            public prune_to(entries: RecordEntry[]) {
                Util.oops("must be overridden by index and table");
            }

            public from_json(jobj: JsonObject, s: IStackFrame): void {
                this.logMutation(s);
                var ctx = new JsonImportCtx(s);
                var json = jobj.value();
                this.importJsonTableOrIndex(ctx, json);
            }

            public importJsonTableOrIndex(ctx: JsonImportCtx, json: any) {
                if (typeof json !== "object")
                    return;
                if (Array.isArray(json)) {
                    // import individual elements, delaying recursion
                    var elts = (<any[]> json).map(jsonelt => this.importJsonRecord(ctx, undefined, jsonelt, true));
                    // then go over it again and do the actual recursion
                    for (var i = 0; i < elts.length; i++)
                        elts[i].importJsonFields(ctx, json[i]);
                    // finally, prune to what was imported
                    this.prune_to(elts);
                }
                else {
                    // import a single entry
                    this.importJsonRecord(ctx, undefined, json, false);
                }
            }

            public jsonExportKey(ctx: JsonExportCtx) {
                return null; // overridden by table entries
            }


            public importJsonKeys(ctx: JsonImportCtx, jobj: JsonObject) {
                // overridden by compiled code for tables and indexes
                return [];
            }
            public findImportTarget(ctx: JsonImportCtx, id:string, target:RecordEntry, json:any): any {
                Util.oops("subclasses are supposed to override this method");
                return null;
            }

            public importJsonRecord(ctx: JsonImportCtx, target: RecordEntry, json: any, delayrecursion: boolean): RecordEntry {

                this.logMutation(ctx.s);

                var id: string;

                // find the id if present
                if (typeof (json) === "string") {
                    id = ctx.map(this.stableName, json);
                } else if (typeof (json) !== "object" || Array.isArray(json)) {
                    return undefined;
                } else {
                    id = ctx.map(this.stableName, json["⌹id"]);
                }

                // find or construct the correct target
                target = this.findImportTarget(ctx, id, target, json);

                // do the actual importing
                if (target) {
                    if (!delayrecursion)
                        target.importJsonFields(ctx, json);
                    if (id)
                        ctx.addmapping(this.stableName, id, target.jsonExportKey(undefined));
                }

                return target;
            }



        }

        export class TableSingleton
            extends RecordSingleton {

            public row_counter = 0;
            public _elements: TableEntry[];

            constructor() {
                super()
        }
            public initParent() {
                this._elements = [];
            }

            public next_row_number() {
                this.row_counter = this.row_counter + 1;
                return this.row_counter;
            }

            public add_row(s: IStackFrame): TableEntry {
                return this.constructrow(arguments);
            }

            public constructrow(args: IArguments) {
                this.clearCachedData();

                var ent = <TableEntry> new (<any>this.entryCtor)(this);
                ent.rownumber = this.next_row_number();
                this._elements.push(ent);

                Util.assert(args.length == ent.keys.length + 1); // last arg is stackframe
                this.logMutation(args[args.length - 1]);
                for (var i = 0; i < ent.keys.length; ++i)
                    ent[ent.keys[i]] = args[i];

                return ent;
            }

            public row_at(index: number): TableEntry {
                this.cacheItems();
                return this.cacheditems[Math.floor(index)];
            }


            public count() {
                this.cacheItems();
                return this.cacheditems.length;
            }
            public clear(s: IStackFrame) {
                this.logMutation(s);
                this.clearCachedData();
                this._elements.forEach((e) => { e.invalidate(); });
                this._elements = [];
            }

            public prune_to(entries: RecordEntry[]) {
                this._elements = <TableEntry[]>entries;
            }

            public findImportTarget(ctx: JsonImportCtx, id: string, target: RecordEntry, json:any): any {
                if (id && (!target || target.jsonExportKey(undefined) !== id)) {
                    target = undefined;
                    this._elements.forEach((e: TableEntry) => {  //SEBTODO binary search
                        if (e.jsonExportKey(undefined) === id)
                            target = e;
                    });
                }
                if (target && target.is_deleted())
                    target = undefined;
                if (!target && (typeof (json) !== "string")) {
                    var keys = this.importJsonKeys(ctx, json);
                    keys.push(ctx.s);
                    target = this.constructrow(<any> keys);
                }
                return target;
            }


            private cacheditems: TableEntry[];
            private dependentcaches = [];
            private cacheItems() {
                if (this.cacheditems === undefined) {
                    this.cacheditems = this._elements.filter((val: TableEntry) => !val.is_deleted());
                    if (this.cacheditems.length > 0) {
                        var e = this.cacheditems[0];
                        if (e.keys.length > 0) {
                            e.keys.forEach((k: string) => {
                                var key = e[k];
                                Util.assert(key instanceof TableEntry || key instanceof CloudTableEntry);
                                (<any> key.parent).dependentcaches[this.stableName] = this;
                            });
                        }
                    }
                }
            }
            public clearCachedData(): void {
                this.cacheditems = undefined;
                for (var l in this.dependentcaches) {
                    if (this.dependentcaches.hasOwnProperty(l))
                        this.dependentcaches[l].clearCachedData();
                }
            }

            public get_enumerator(): RecordEntry[] {
                this.cacheItems();
                return this.cacheditems;
            }


            public post_to_wall(s: IStackFrame): void {
                s.rt.postBoxedHtml(this.getTable(this.get_enumerator(), s), s.pc);
            }

        }



        export class CloudTableSingleton
            extends RecordSingleton implements TDev.Revisions.IDataCache {

            constructor() {
                super()
            }

            public add_row(s: IStackFrame): CloudTableEntry {
                return this.constructrow(arguments);
            }

            public constructrow(args: IArguments) {



                this.clearCachedData();
                var ent = <CloudTableEntry> new (<any>this.entryCtor)(this);

                Util.assert(args.length == ent.keys.length + 1); // last argument is stackframe
                this.logMutation(args[args.length-1]);
                var links = new Array<string>();
                for (var i = 0; i < ent.keys.length; ++i) {
                    var x = <CloudTableEntry>args[i];
                    var correctsession = x.check(false);
                    if (!correctsession)
                        Util.userError(lf("invalid link argument: originated in a different session"));
                    links.push(x.uid);
                    ent[ent.keys[i]] = x;
                }
                ent.hookup(this.session().user_create_item(this.cloudtype, links, []));
                return ent;
            }


            public prune_to(entries: RecordEntry[]) {
                var map = {};
                entries.forEach(e => map[(<CloudTableEntry>e).uid] = true);
                this.get_enumerator().forEach(r => map[(<CloudTableEntry> r).uid] ? undefined: (<CloudTableEntry> r).delete_row());
            }


            public import_item(item: Revisions.Item): CloudTableEntry {
                if (item.backlink !== undefined)
                    return <CloudTableEntry>(item.backlink);
                else {
                    var ent = <CloudTableEntry> new (<any>this.entryCtor)(this);
                    ent.hookup(item);
                    return ent;
                }
            }

            public import_item_from_uid(uid: string, def?: string): CloudTableEntry {
                if (!uid)
                    return undefined;
                var session = this.session();
                var item = session.user_get_item(uid);
                if (def && (!item || item.definition !== def))
                    return undefined; // import situation: make no effort
                if (item === undefined)
                    item = session.user_create_tombstone(this.cloudtype, uid, this.key_cloudtypes.map(k => undefined), []);
                return this.import_item(item);
            }

            public fromRest(json: any) {
                return this.import_item_from_uid(json["⌹id"]);
            }

            private cacheditems: TDev.Revisions.Item[];
            private dependentcaches = [];
            private cacheItems() {
                if (this.cacheditems === undefined) {
                    var session = this.session();
                    this.cacheditems = session.user_get_items_in_domain(this.cloudtype).sort((a, b) => a.compareTo(b));
                    this.linked_cloudtables.forEach((t) => t.dependentcaches[this.stableName] = this);
                    Runtime.theRuntime.sessions.registerDataCache(this.stableName, this);
                }
            }
            public clearCachedData(): void {
                this.cacheditems = undefined;
                this.linked_cloudtables.forEach((t) => delete t.dependentcaches[this.stableName]);
                Runtime.theRuntime.sessions.unregisterDataCache(this.stableName);
                for (var l in this.dependentcaches) {
                    if (this.dependentcaches.hasOwnProperty(l))
                        this.dependentcaches[l].clearCachedData();
                }
            }

            public count() {
                this.cacheItems();
                return this.cacheditems.length;
            }

            public row_at(index: number): CloudTableEntry {
                this.cacheItems();
                var item = this.cacheditems[Math.floor(index)];
                return item ? this.import_item(item) : undefined;
            }

            public clear() {
                this.cacheItems();
                this.cacheditems.forEach(item => this.session().user_delete_item(item));
                this.clearCachedData();
            }

            public get_enumerator(): RecordEntry[] {
                this.cacheItems();
                var entries = this.cacheditems.map((i: Revisions.Item) => this.import_item(i));
                return entries;
            }


            public post_to_wall(frame: IStackFrame): void {
                frame.rt.postBoxedHtml(this.getTable(this.get_enumerator(), frame), frame.pc);
            }

            public findImportTarget(ctx: JsonImportCtx, id: string, t: RecordEntry, json: any): any {
                var target = <CloudTableEntry> t;
                if (id && (!target || target.jsonExportKey(undefined) !== id)) {
                    if (id[0] === ".")
                        id = id.slice(1);
                    target = this.import_item_from_uid(id, this.cloudtype);
                }
                if (target && target.is_deleted())
                    target = undefined;
                if (!target && (typeof (json) !== "string")) {
                    var keys = this.importJsonKeys(ctx, json);
                    keys.push(ctx.s);
                    target = this.constructrow(<any> keys);
                }
                return target;
            }

        }


        export class CloudIndexEntry
            extends RecordEntry {
            // serialized fields
            public sessionname: string;

            constructor() {
                super()
         }
            public equals(other: RecordEntry): boolean {
                var o = (<CloudIndexEntry>other);
                this.check();
                o.check();
                return (this.sessionname === o.sessionname) && (this.entry === o.entry);
            }

            public getShortStringRepresentation(): string {
                return "[" + this.parent.entryKindName + "]";
            }

            // handle
            public entry: Revisions.Entry;

            // link this table entry with the session item
            public hookup(entry: Revisions.Entry) {
                this.sessionname = entry.session.servername;
                this.entry = entry;
                entry.backlink = this;
                this.read_cloud_fields(entry);
            }

            public unlink() {
                this.decorators = undefined;
                this.entry = undefined;
                for (var i = 0; i < this.values.length; i++) {
                    this[this.values[i]] = undefined;
                }
            }


            public getFieldValue(fieldname: string, s:IStackFrame): any {
                this.check();
                var f = this[fieldname];
                if (f instanceof Revisions.LVal)
                    return Conv.read(this.parent.session(), <Revisions.LVal>f, s);
                else
                    return f;
            }

            public check(abort = true): boolean {
                if (this.sessionname !== this.parent.session().servername) {
                    if (abort)
                        Util.userError(lf("stale index entry: originated in a different session"));
                    else
                        return false;
                }
                if (typeof (this.entry) === "undefined" || this.entry.backlink != this || this.entry.session !== this.parent.session()) {
                    Util.assert(this.keys.length === this.parent.key_cloudtypes.length);
                    var ukeys = new Array<string>();
                    var lkeys = new Array<string>();
                    for (var i = 0; i < this.keys.length; i++) {
                        var cloudtype = this.parent.key_cloudtypes[i];
                        if (cloudtype.charAt(cloudtype.length - 1) === ')') {
                            // row key
                            var uid = (<CloudTableEntry>this[this.keys[i]]).uid;
                            ukeys.push(uid);
                        }
                        else {
                            // literal key
                            lkeys.push(Conv.toCloud(cloudtype, this[this.keys[i]], false));
                        }
                        this.hookup(this.parent.session().user_get_entry(this.parent.cloudtype, ukeys, lkeys));
                    }
                    return true;
                }
                return true;
            }


            public clear_fields(s?: IStackFrame) {
                if (s) this.parent.logMutation(s);
                this.check();
                for (var i = 0; i < this.values.length; i++) {
                    var lval = this[this.values[i]];
                    Conv.clear(this.parent.session(), lval);
                }
            }

            public confirmed(): boolean {
                this.check();
                var session = this.parent.session();
                var confirmed = this.dependenciesconfirmed && !this.values.some((val) => !session.user_is_datum_confirmed(this[val]));
                return confirmed;
            }

            public dependenciesconfirmed(): boolean {
                return !this.keys.some((key) => {
                    var r = this[key];
                    return (r && r instanceof CloudTableEntry && !(<CloudTableEntry>r).existenceConfirmed());
                });
            }

            public compareTo(other: CloudIndexEntry): number {
                this.check();
                other.check();
                var diff = 0;
                this.keys.forEach((k: string): void => {
                    if (!diff) {
                        var a = this[k];
                        var b = other[k];
                        switch (typeof a) {
                            case "string":
                                diff = a.localeCompare(b);
                                break;
                            case "number":
                                diff = a - b;
                                break;
                            case "boolean":
                                if (a !== b)
                                    diff = (a ? 1 : -1);
                                break;
                            default:
                                diff = RTValue.CompareKeys(a, b);
                                break;
                        }
                    }
                });
                return diff;
            }

            public is_deleted(): boolean {
                if (!this.check())
                    return true;
                return this.parent.session().user_is_datum_deleted(this.entry);
            }

            public perform_get(fieldname: string, s:IStackFrame): RTValue {
                this.check();
                return Conv.read(this.parent.session(), this[fieldname], s);
            }
            public perform_confirmed(fieldname: string): boolean {
                this.check();
                return this.parent.session().user_is_datum_confirmed(this[fieldname]);
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, false);
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, true);
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], value, true);
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                this.parent.logMutation(s);
                this.check();
                Conv.modify(this.parent.session(), this[fieldname], undefined, false);
            }


            //set up keys
            public read_cloud_fields(datum: Revisions.Datum) {
                // setup keys
                var ukeys = new Array<string>();
                var lkeys = new Array<string>();
                Util.assert(this.parent.key_cloudtypes.length === this.keys.length);
                for (var i = 0; i < this.keys.length; i++) {
                    var keytype = this.parent.key_cloudtypes[i];
                    var val: any;
                    if (keytype.charAt(keytype.length - 1) === ")") {
                        // row key
                        var uid = datum.ukeys[ukeys.length];
                        var linkedtable = this.parent.linked_cloudtables[ukeys.length];
                        val = linkedtable.import_item_from_uid(uid);
                        ukeys.push(uid);
                    } else {
                        // literal key
                        var lit = datum.lkeys[lkeys.length];
                        val = Conv.fromCloud(keytype, lit);
                        lkeys.push(lit);
                    }
                    this[this.keys[i]] = val;
                }
                //set up lvals
                Util.assert(this.parent.value_cloudtypes.length === this.values.length);
                for (var i = 0; i < this.values.length; i++) {
                    var property = this.parent.value_cloudtypes[i];
                    this[this.values[i]] = this.parent.session().user_get_lval(property, ukeys, lkeys);
                }
            }
        }

        export class PersistentVars {

            public names: string[];              // set by compiled code
            public cloudtypes: string[];
            public localsession: boolean;        // set by compiled code
            public libName: string;              // set by compiled code - the unique id of the library
            public sessions: Revisions.Sessions;

            public session: Revisions.ClientSession;

            constructor(public rt: Runtime) { this.sessions = rt.sessions; }

            public check() {
                if (!this.session || (!this.localsession && this.session !== this.sessions.getCurrentSession())) {
                    this.session = (this.localsession ? this.sessions.getLocalSession() : this.sessions.getCurrentSession());
                    var prefix = (this.libName === "this") ? "" : (this.libName + ".");
                    for (var i = 0; i < this.names.length; i++) {
                        var name = this.names[i];
                        var property = prefix + this.cloudtypes[i];
                        this[name] = this.session.user_get_lval(property, [], [])
                    }
                }
            }

            public perform_get(fieldname: string, s: IStackFrame): RTValue {
                this.check();
                return Conv.read(this.session, this[fieldname], s);
            }
            public perform_confirmed(fieldname: string): boolean {
                this.check();
                return this.session.user_is_datum_confirmed(this[fieldname]);
            }
            public perform_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(false);
                this.check();
                Conv.modify(this.session, this[fieldname], value, false);
            }
            public perform_test_and_set(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(false);
                this.check();
                Conv.modify(this.session, this[fieldname], value, true);
            }
            public perform_add(fieldname: string, value: RTValue, s: IStackFrame) {
                s.rt.logDataWrite(false);
                this.check();
                Conv.modify(this.session, this[fieldname], value, true);
            }
            public perform_clear(fieldname: string, s: IStackFrame) {
                s.rt.logDataWrite(false);
                this.check();
                Conv.modify(this.session, this[fieldname], undefined, false);
            }
        }

        export class CloudIndexSingleton
            extends RecordSingleton {
            constructor() {
                super()
         }

            public clear() {
                var session = this.session();
                var entries = session.user_get_entries_in_indexdomain(this.cloudtype);
                entries.forEach((e) => e.lvals.forEach((l) => Conv.clear(session, l)));
            }

            public count() { return this.session().user_get_entries_in_indexdomain(this.cloudtype).length; }

            public get_enumerator(): RecordEntry[] {
                var entries = this.session().user_get_entries_in_indexdomain(this.cloudtype);
                var x = entries.map((e: Revisions.Entry) => this.import_item(e));
                x.sort((a, b) => a.compareTo(b));
                return x;
            }

            public post_to_wall(frame: IStackFrame): void {
                frame.rt.postBoxedHtml(this.getTable(this.get_enumerator(), frame), frame.pc);
            }

            public import_item(entry: Revisions.Entry): CloudIndexEntry {
                if (typeof (entry.backlink) != "undefined")
                    return <CloudIndexEntry>(entry.backlink);
                else {
                    var ent = <CloudIndexEntry> new (<any>this.entryCtor)(this);
                    ent.hookup(entry);
                    return ent;
                }
            }



            public singleton() { return this.access(arguments); }
            public at() { return this.access(arguments); }

            private access(args: IArguments): CloudIndexEntry {
                Util.assert(args.length - 1 === this.key_cloudtypes.length);
                var ukeys = new Array<string>();
                var lkeys = new Array<string>();
                for (var i = 0; i < this.key_cloudtypes.length; i++) {
                    var cloudtype = this.key_cloudtypes[i];
                    if (cloudtype.charAt(cloudtype.length - 1) === ')') {
                        // row key
                        var uid = (<CloudTableEntry>args[i]).uid;
                        ukeys.push(uid);
                    }
                    else {
                        // literal key
                        lkeys.push(Conv.toCloud(cloudtype, args[i], false));
                    }
                }

                var entry = this.session().user_get_entry(this.cloudtype, ukeys, lkeys);

                return this.import_item(entry);
            }

            public findImportTarget(ctx: JsonImportCtx, id: string, target: RecordEntry, json: any): any {
                var keys = this.importJsonKeys(ctx, json);
                keys.push(ctx.s);
                return this.access(<any> keys);
            }

            public prune_to(entries: RecordEntry[]) {
                entries.forEach(e => (<any>e).flagthatthisentryispresentusingalongnoncollidingname = true);
                this.get_enumerator().forEach(r => (<any>r).flagthatthisentryispresentusingalongnoncollidingname ? undefined : (<CloudIndexEntry> r).clear_fields());
                entries.forEach(e => delete (<any>e).flagthatthisentryispresentusingalongnoncollidingname);
            }


        }


        export class IndexSingleton
            extends RecordSingleton {
            private _index: Hashtable;
            constructor() {
                super()
            }

            public initParent() {
                this._index = Hashtable.forJson()
            }

            public clear() { return this._index.clear(); }
            public count() { return this._index.countFiltered((val: IndexEntry) => (!val.is_deleted() && val.hasNondefaultValue())); }

            public singleton() { return this.access(arguments); }
            public at() { return this.access(arguments); }

            public makekey(args: IArguments) {
                var key = [];
                // the last argument is IStackFrame
                for (var i = 0; i < args.length - 1; ++i) {
                    var a = args[i];
                    switch (typeof a) {
                        case "string":
                        case "number":
                        case "boolean":
                            key.push(a)
                    break;
                        default:
                            Util.assert(!!a);
                            key.push(a.toJsonKey());
                            break;
                    }
                }
                return key;
            }

            public access(args: IArguments) {
                var key = this.makekey(args);
                var e = this._index.get(key);
                if (!e) {
                    //debugger;
                    e = new (<any>this.entryCtor)(this);
                    Util.assert((args.length === 0 && e.keys.length === 0) || (args.length - 1 === e.keys.length));
                    for (var i = 0; i < e.keys.length; ++i)
                        e[e.keys[i]] = args[i];
                    this._index.set(key, e);
                }
                return e;
            }

            public get_enumerator(): RecordEntry[] {
                var a = this._index.filteredValues((val: IndexEntry) => (!val.is_deleted() && val.hasNondefaultValue()));
                a.sort((a, b) => a.compareTo(b));
                return a;
            }



            public post_to_wall(frame: IStackFrame): void {
                frame.rt.postBoxedHtml(this.getTable(this.get_enumerator(), frame), frame.pc);
            }

            public findImportTarget(ctx: JsonImportCtx, id: string, target: RecordEntry, json: any): any {
                var keys = this.importJsonKeys(ctx, json);
                keys.push(ctx.s);
                return this.access(<any> keys);
            }

            public prune_to(entries: RecordEntry[]) {
                entries.forEach(e => (<any>e).flagthatthisentryispresentusingalongnoncollidingname = true);
                var tobedeleted = this._index.filteredValues(e => !(<any>e).flagthatthisentryispresentusingalongnoncollidingname);
                entries.forEach(e => delete (<any>e).flagthatthisentryispresentusingalongnoncollidingname);
                tobedeleted.forEach(e => {
                    var keys = e.keys.map(k => e[k]);
                    keys.push(null); //dummy item for what is ususally context but not needed here
                    var key = this.makekey(<any> keys);
                    this._index.remove(key);
                });
            }
        }

        export class ObjectSingleton
            extends RecordSingleton {
            constructor() {
                super()
            }
            public create(s: IStackFrame): ObjectEntry {
                var o = <ObjectEntry> new (<any>this.entryCtor)(this);
                o.on_render_heap = s.rt.rendermode;
                return o;
            }

            public create_from_json(jobj: JsonObject, s: IStackFrame): ObjectEntry {
                var o = this.create(s)
                o.from_json(jobj, s)
                return o;
            }

            public invalid() {
                return undefined;
            }

            public clear() {
                // no-op ... cannot clear objects this way.
                // here for uniformity (called on all temporary RecordSingleton when resetting globals)
            }

            public importJsonRecord(ctx: JsonImportCtx, target: RecordEntry, json: any): RecordEntry {
                if (!target)
                    target = this.create(ctx.s);
                target.importJsonFields(ctx, json);
                return target;
            }
        }

        export class DecoratorSingleton
            extends RecordSingleton {
            public _generation = 0;
            constructor() {
                super()
            }

            public clear() {
                this._generation = this._generation + 1;
            }

            public at(obj: RTValue, s: IStackFrame) {
                //SEBTODO check if targeting a deleted row/entry (currently wrong if deleted indirectly) - or revamp invalidation to be eager
                var decs = obj.decorators;
                if (!decs)
                    decs = obj.decorators = new DecoratorCollection();
                var key = s.d["libName"] + "$" + this.stableName;
                var dec = decs[key];
                if (!dec) {
                    dec = new (<any>this.entryCtor)(this);
                    dec[dec.keys[0]] = obj;
                    decs[key] = dec;
                }
                return dec;
            }
        }


        // handles how TD types are embedded into cloud types
        export class Conv {


            public static modify(session: Revisions.ClientSession, lval: Revisions.LVal, val: any, relative: boolean) {
                if (val instanceof CloudTableEntry)
                    val = (<CloudTableEntry>val).uid;
                var op = Conv.toCloud(lval.codomain, val, relative);
                session.user_modify_lval(lval, op);
            }

            public static read(session: Revisions.ClientSession, lval: Revisions.LVal, s: IStackFrame):RTValue {
                var cur = session.user_get_value(lval);
                cur = Conv.fromCloud(lval.codomain, cur);
                if (cur && s && lval.codomain.charAt(0) === "^") {
                    var table = <CloudTableSingleton> s.d["$" + lval.codomain.slice(1)];
                    cur = table.import_item_from_uid(cur);
                }
                return cur;
            }

            public static clear(session: Revisions.ClientSession, lval: Revisions.LVal) {
                var op = Conv.toCloud(lval.codomain, undefined, false);
                session.user_modify_lval(lval, op);
            }

            // static domains and codomains

            public static getCloudDomain(kind: string): string {
                switch (kind) {
                    case "Location": return "location";
                    case "User": return "user";
                    case "Boolean": return "boolean"
                    case "Color": return "color";
                    case "DateTime": return "datetime";
                    case "String": return "string";
                    case "Number": return "double";
                    case "Vector3": return "vector3";
                    default: Util.oops("unhandled case for cloud domain: " + (kind || "none"));
                }
            }

            public static getCloudCodomain(kind: string): string {
                 switch (kind) {
                    case "Location": return "location";
                    case "User": return "user";
                    case "Boolean": return "boolean";
                    case "Color": return "color";
                    case "DateTime": return "datetime";
                    case "String": return "string";
                    case "Number": return "double";
                    case "OAuth Response": return "oauthresponse";
                    case "Link": return "link";
                    case "Json Object": return "json";
                    default: Util.oops("unhandled case for cloud codomain: " + (kind || "none"));
                }
            }

            // serialization/deserialization of cloud keys and cloud values

            public static toCloud(kind: string, val: any, relative: boolean = false): string {
                switch (kind) {
                    case "location":
                        if (!val) return "";
                        Util.assert(val instanceof RT.Location_);
                        return (<RT.Location_>val).to_string();
                    case "user":
                        if (!val) return "";
                        Util.assert(val instanceof RT.User);
                        return (<RT.User>val).id();
                    case "boolean":
                        return val ? "t" : "";
                    case "color":
                        if (!val) return "";
                        Util.assert(val instanceof RT.Color);
                        return (<RT.Color>val).toInt32().toString();
                    case "vector3":
                        if (!val) return "";
                        return JSON.stringify((<Vector3>val).exportJson(null));
                    case "datetime":
                        if (!val) return "";
                        Util.assert(val instanceof RT.DateTime);
                        return (<RT.DateTime>val).milliseconds_since_epoch().toString();
                    case "string":
                        if (typeof(val) != "string") val = "";
                        //if (val.length > 4000) return val.substr(0, 4000); // truncate to 4000 characters
                        if (relative)
                            return "^?" + val;
                        if (val.charAt(0) === "^")
                            return "^!" + val;
                        return val;
                    case "double":
                        var newval = (typeof val !== "number" ? 0 : <number>val);
                        return relative ? ("A" + newval) : newval.toString();
                    case "oauthresponse":
                        if (!val) return "";
                        return JSON.stringify((<OAuthResponse>val).exportJson(null));
                    case "link":
                        if (!val) return "";
                        return JSON.stringify((<Link>val).exportJson(null));
                    case "json":
                        if (!val) return "";
                        return JSON.stringify((<RT.JsonObject> val).exportJson(null));
                    default: //reference
                        Util.assert(kind[0] === "^");
                        return val || "";
                }
            }

            public static fromCloud(kind: string, val: any): any {
                // val is either undefined (representing default value) or a string (the reduced op)
                switch (kind) {
                    case "location":
                        if (!val) return; // return undefined value
                        return RT.Location_.mkFromString(val);
                    case "user":
                        if (!val) return; // return undefined value
                        return RT.User.mk(val);
                    case "boolean":
                        return !!val && val !== "false"; // for legacy; new encoding is "" / "t"
                    case "color":
                        if (!val) return; // return undefined value
                        return RT.Color.fromInt32(Number(val));
                    case "datetime":
                        var nr = Number(val || 0); //SEBTODO: think about default
                        return RT.DateTime.mkMs(nr);
                    case "oauthresponse":
                        if (!val) return; // return undefined value
                        return (new OAuthResponse()).importJson(new JsonImportCtx(null), JSON.parse(val));
                    case "vector3":
                        if (!val) return; // return undefined value
                        return Vector3.mkFromJson(new JsonImportCtx(null), JSON.parse(val));
                    case "link":
                        if (!val) return; // return undefined value
                        return (new Link()).importJson(new JsonImportCtx(null), JSON.parse(val));
                    case "json":
                        if (!val) return; // return undefined value
                        return JsonObject.wrap(JSON.parse(val));
                    case "string":
                        if (typeof (val) !== "string")
                            val = "";
                        else if (val.charAt(0) === "^")
                            val = val.substr(2);
                        return val;
                    case "double":
                        if (typeof (val) !== "string")
                            return 0;
                        Util.assert(val.charAt(0) !== "A");
                            //return Number(val.slice(1));
                        return Number(val);
                    default: //reference
                        Util.assert(kind[0] === "^");
                        return val || undefined;
                }
            }



        }
    }
}