1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
import { DataType, nil, QueryError, RegClass, _IType } from '../interfaces-private.ts';import { TypeBase } from './datatype-base.ts';import { Evaluator } from '../evaluator.ts';import { parseRegClass } from '../utils.ts';import { Types } from './datatypes.ts';import { buildCtx } from '../parser/context.ts';
export class RegClassImpl extends TypeBase<RegClass> {


    get primary(): DataType {        return DataType.regclass;    }
    doCanCast(_to: _IType): boolean | nil {        switch (_to.primary) {            case DataType.text:            case DataType.integer:                return true;        }        return null;    }
    doCast(a: Evaluator, to: _IType): Evaluator {        const { schema } = buildCtx();        switch (to.primary) {            case DataType.text:                return a                    .setType(Types.text())                    .setConversion((raw: RegClass) => {                        return raw?.toString();                    }                        , toText => ({ toText }))            case DataType.integer:                return a                    .setType(Types.text())                    .setConversion((raw: RegClass) => {
                        // === regclass -> int
                        const cls = parseRegClass(raw);
                        // if its a number, then try to get it.                        if (typeof cls === 'number') {                            return schema.getObjectByRegOrName(cls)                                ?.reg.classId                                ?? cls;                        }
                        // get the object or throw                        return schema.getObjectByRegOrName(raw)                            .reg.classId;                    }                        , toText => ({ toText }))        }        throw new Error('failed to cast');    }


    doCanBuildFrom(from: _IType) {        switch (from.primary) {            case DataType.text:                return true;        }        return false;    }
    doBuildFrom(value: Evaluator, from: _IType): Evaluator<RegClass> | nil {        const { schema } = buildCtx();        switch (from.primary) {            case DataType.text:                return value                    .setConversion((str: string) => {                        // === text -> regclass
                        const cls = parseRegClass(str);
                        // if its a number, then try to get it.                        if (typeof cls === 'number') {                            return schema.getObjectByRegOrName(cls)                                ?.name                                ?? cls;                        }
                        // else, get or throw.                        return schema.getObject(cls)                            .name;                    }                        , strToRegClass => ({ strToRegClass }));        }        return null;    }
}