@neo-one/smart-contract-compiler-esnext-esm/compile/helper/types/ForIterableTypeHelper.js

NEO•ONE TypeScript smart contract compiler.

import { utils } from '@neo-one/utils-esnext-esm';
import { Types } from '../../constants';
import { Helper } from '../Helper';
import { hasArray } from './array';
import { hasArrayStorage } from './arrayStorage';
import { hasIterableIterator } from './iterableIterator';
import { hasMap } from './map';
import { hasMapStorage } from './mapStorage';
import { hasSet } from './set';
import { hasSetStorage } from './setStorage';
export class ForIterableTypeHelper extends Helper {
    constructor({ type, knownType, array, map, set, arrayStorage, mapStorage, setStorage, iterableIterator, defaultCase, }) {
        super();
        this.type = type;
        this.knownType = knownType;
        this.array = array;
        this.map = map;
        this.set = set;
        this.arrayStorage = arrayStorage;
        this.mapStorage = mapStorage;
        this.setStorage = setStorage;
        this.iterableIterator = iterableIterator;
        this.defaultCase = defaultCase;
    }
    emit(sb, node, options) {
        if (this.knownType !== undefined) {
            this.processKnownType(this.knownType, options);
            return;
        }
        sb.emitHelper(node, options, sb.helpers.forType({
            type: this.type,
            defaultCase: this.defaultCase,
            types: [
                {
                    hasType: (type) => hasArray(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isArray);
                    },
                    process: this.array,
                },
                {
                    hasType: (type) => hasArrayStorage(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isArrayStorage);
                    },
                    process: this.arrayStorage,
                },
                {
                    hasType: (type) => hasMap(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isMap);
                    },
                    process: this.map,
                },
                {
                    hasType: (type) => hasMapStorage(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isMapStorage);
                    },
                    process: this.mapStorage,
                },
                {
                    hasType: (type) => hasSet(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isSet);
                    },
                    process: this.set,
                },
                {
                    hasType: (type) => hasSetStorage(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isSetStorage);
                    },
                    process: this.setStorage,
                },
                {
                    hasType: (type) => hasIterableIterator(sb.context, node, type),
                    isRuntimeType: (innerOptions) => {
                        sb.emitHelper(node, innerOptions, sb.helpers.isIterableIterator);
                    },
                    process: this.iterableIterator,
                },
            ],
        }));
    }
    processKnownType(knownType, options) {
        switch (knownType) {
            case Types.Array:
                this.array(options);
                break;
            case Types.ArrayStorage:
                this.arrayStorage(options);
                break;
            case Types.Map:
                this.map(options);
                break;
            case Types.MapStorage:
                this.mapStorage(options);
                break;
            case Types.Set:
                this.set(options);
                break;
            case Types.SetStorage:
                this.setStorage(options);
                break;
            case Types.IterableIterator:
                this.iterableIterator(options);
                break;
            default:
                utils.assertNever(knownType);
        }
    }
}

//# sourceMappingURL=ForIterableTypeHelper.js.map