/// <reference types="jquery" />
/// <reference types="bootstrap" />
import { AtomicDirectInitializerOutlet, ClassDirectInitializerOutlet, ReferenceDirectInitializerOutlet } from "../../../view/constructs/InitializerOutlet";
import { ConstructOutlet } from "../../../view/constructs/ConstructOutlet";
import { TranslationUnitContext } from "../../compilation/contexts";
import { FunctionEntity, ObjectEntity, ObjectEntityType, UnboundReferenceEntity } from "../../compilation/entities";
import { Simulation } from "../../runtime/Simulation";
import { CompiledTemporaryDeallocator } from "../TemporaryDeallocator";
import { AtomicType, BoundedArrayType, Char, CompleteClassType, CompleteObjectType, FunctionType, ReferenceType, ReferredType, VoidType } from "../../compilation/types";
import { RuntimeConstruct, SuccessfullyCompiled } from "../CPPConstruct";
import { CompiledExpression, Expression } from "../expressions/Expression";
import { RuntimeExpression } from "../expressions/RuntimeExpression";
import { CompiledStringLiteralExpression, RuntimeStringLiteralExpression, StringLiteralExpression } from "../expressions/StringLiteralExpression";
import { CompiledFunctionCall, FunctionCall, RuntimeFunctionCall } from "../FunctionCall";
import { Initializer, RuntimeInitializer } from "./Initializer";
export declare type DirectInitializerKind = "direct" | "copy";
export declare abstract class DirectInitializer extends Initializer {
    static create(context: TranslationUnitContext, target: UnboundReferenceEntity, args: readonly Expression[], kind: DirectInitializerKind): ReferenceDirectInitializer;
    static create(context: TranslationUnitContext, target: ObjectEntity<AtomicType>, args: readonly Expression[], kind: DirectInitializerKind): AtomicDirectInitializer;
    static create(context: TranslationUnitContext, target: ObjectEntity<BoundedArrayType>, args: readonly Expression[], kind: DirectInitializerKind): ArrayDirectInitializer;
    static create(context: TranslationUnitContext, target: ObjectEntity<CompleteClassType>, args: readonly Expression[], kind: DirectInitializerKind): ClassDirectInitializer;
    static create(context: TranslationUnitContext, target: ObjectEntity, args: readonly Expression[], kind: DirectInitializerKind): AtomicDirectInitializer | ArrayDirectInitializer | ClassDirectInitializer;
    static create(context: TranslationUnitContext, target: ObjectEntity | UnboundReferenceEntity, args: readonly Expression[], kind: DirectInitializerKind): ReferenceDirectInitializer | AtomicDirectInitializer | ArrayDirectInitializer | ClassDirectInitializer;
    abstract readonly target: ObjectEntity | UnboundReferenceEntity;
    abstract readonly args: readonly Expression[];
    readonly kind: DirectInitializerKind;
    constructor(context: TranslationUnitContext, kind: DirectInitializerKind);
    abstract createRuntimeInitializer<T extends ObjectEntityType>(this: CompiledDirectInitializer<T>, parent: RuntimeConstruct): RuntimeDirectInitializer<T>;
}
export interface CompiledDirectInitializer<T extends ObjectEntityType = ObjectEntityType> extends DirectInitializer, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly target: ObjectEntity<Exclude<T, ReferenceType>> | UnboundReferenceEntity<Extract<T, ReferenceType>>;
    readonly args: readonly CompiledExpression[];
}
export declare abstract class RuntimeDirectInitializer<T extends ObjectEntityType = ObjectEntityType, C extends CompiledDirectInitializer<T> = CompiledDirectInitializer<T>> extends RuntimeInitializer<C> {
    protected constructor(model: C, parent: RuntimeConstruct);
}
export declare class ReferenceDirectInitializer extends DirectInitializer {
    readonly construct_type = "ReferenceDirectInitializer";
    readonly target: UnboundReferenceEntity;
    readonly args: readonly Expression[];
    readonly arg?: Expression;
    constructor(context: TranslationUnitContext, target: UnboundReferenceEntity, args: readonly Expression[], kind: DirectInitializerKind);
    createRuntimeInitializer<T extends ReferenceType<CompleteObjectType>>(this: CompiledReferenceDirectInitializer<T>, parent: RuntimeConstruct): RuntimeReferenceDirectInitializer<T>;
    createRuntimeInitializer<T extends ReferenceType<CompleteObjectType>>(this: CompiledDirectInitializer<T>, parent: RuntimeConstruct): never;
    createDefaultOutlet(this: CompiledReferenceDirectInitializer, element: JQuery, parent?: ConstructOutlet): ReferenceDirectInitializerOutlet;
    explain(sim: Simulation, rtConstruct: RuntimeConstruct): {
        message: string;
    };
}
export interface CompiledReferenceDirectInitializer<T extends ReferenceType = ReferenceType> extends ReferenceDirectInitializer, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly target: UnboundReferenceEntity<Extract<T, ReferenceType>>;
    readonly args: readonly CompiledExpression[];
    readonly arg: CompiledExpression<ReferredType<T>, "lvalue">;
}
export declare class RuntimeReferenceDirectInitializer<T extends ReferenceType<CompleteObjectType> = ReferenceType<CompleteObjectType>> extends RuntimeDirectInitializer<T, CompiledReferenceDirectInitializer<T>> {
    readonly args: readonly RuntimeExpression<ReferredType<T>, "lvalue">[];
    readonly arg: RuntimeExpression<ReferredType<T>, "lvalue">;
    private alreadyPushed;
    constructor(model: CompiledReferenceDirectInitializer<T>, parent: RuntimeConstruct);
    protected upNextImpl(): void;
    stepForwardImpl(): void;
}
export declare class AtomicDirectInitializer extends DirectInitializer {
    readonly construct_type = "AtomicDirectInitializer";
    readonly target: ObjectEntity<AtomicType>;
    readonly args: readonly Expression[];
    readonly arg: Expression;
    constructor(context: TranslationUnitContext, target: ObjectEntity<AtomicType>, args: readonly Expression[], kind: DirectInitializerKind);
    createRuntimeInitializer<T extends AtomicType>(this: CompiledAtomicDirectInitializer<T>, parent: RuntimeConstruct): RuntimeAtomicDirectInitializer<T>;
    createRuntimeInitializer<T extends CompleteObjectType>(this: CompiledDirectInitializer<T>, parent: RuntimeConstruct): never;
    createDefaultOutlet(this: CompiledAtomicDirectInitializer, element: JQuery, parent?: ConstructOutlet): AtomicDirectInitializerOutlet;
    explain(sim: Simulation, rtConstruct: RuntimeConstruct): {
        message: string;
    };
}
export interface CompiledAtomicDirectInitializer<T extends AtomicType = AtomicType> extends AtomicDirectInitializer, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly target: ObjectEntity<Exclude<T, ReferenceType>>;
    readonly args: readonly CompiledExpression[];
    readonly arg: CompiledExpression<T, "prvalue">;
}
export declare class RuntimeAtomicDirectInitializer<T extends AtomicType = AtomicType> extends RuntimeDirectInitializer<T, CompiledAtomicDirectInitializer<T>> {
    readonly args: readonly RuntimeExpression<T, "prvalue">[];
    readonly arg: RuntimeExpression<T, "prvalue">;
    private alreadyPushed;
    constructor(model: CompiledAtomicDirectInitializer<T>, parent: RuntimeConstruct);
    protected upNextImpl(): void;
    stepForwardImpl(): void;
}
/**
 * Note: Only allowed use is to initialize a char array from a string literal, but this can readily be
 * created in the course of compiling a program if the code attempts to directly initialize an array. That's
 * desirable, because this class will give the appropriate error messages if it's anything other than a
 * char array initialized from a string literal.
 */
export declare class ArrayDirectInitializer extends DirectInitializer {
    readonly construct_type = "ArrayDirectInitializer";
    readonly target: ObjectEntity<BoundedArrayType>;
    readonly args: readonly Expression[];
    readonly arg?: StringLiteralExpression;
    constructor(context: TranslationUnitContext, target: ObjectEntity<BoundedArrayType>, args: readonly Expression[], kind: "direct" | "copy");
    createRuntimeInitializer(this: CompiledArrayDirectInitializer, parent: RuntimeConstruct): RuntimeArrayDirectInitializer;
    createRuntimeInitializer<T extends CompleteObjectType>(this: CompiledDirectInitializer<T>, parent: RuntimeConstruct): never;
    createDefaultOutlet(this: CompiledAtomicDirectInitializer, element: JQuery, parent?: ConstructOutlet): AtomicDirectInitializerOutlet;
    explain(sim: Simulation, rtConstruct: RuntimeConstruct): {
        message: string;
    };
}
export interface CompiledArrayDirectInitializer extends ArrayDirectInitializer, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly target: ObjectEntity<BoundedArrayType<Char>>;
    readonly args: readonly CompiledStringLiteralExpression[];
    readonly arg: CompiledStringLiteralExpression;
}
export declare class RuntimeArrayDirectInitializer extends RuntimeDirectInitializer<BoundedArrayType<Char>, CompiledArrayDirectInitializer> {
    readonly arg: RuntimeStringLiteralExpression;
    readonly args: readonly RuntimeStringLiteralExpression[];
    private alreadyPushed;
    constructor(model: CompiledArrayDirectInitializer, parent: RuntimeConstruct);
    protected upNextImpl(): void;
    stepForwardImpl(): void;
}
export declare class ClassDirectInitializer extends DirectInitializer {
    readonly construct_type = "ClassDirectInitializer";
    readonly target: ObjectEntity<CompleteClassType>;
    readonly args: readonly Expression[];
    readonly ctor?: FunctionEntity<FunctionType<VoidType>>;
    readonly ctorCall?: FunctionCall;
    constructor(context: TranslationUnitContext, target: ObjectEntity<CompleteClassType>, args: readonly Expression[], kind: DirectInitializerKind);
    createRuntimeInitializer<T extends CompleteClassType>(this: CompiledClassDirectInitializer<T>, parent: RuntimeConstruct): RuntimeClassDirectInitializer<T>;
    createRuntimeInitializer<T extends CompleteObjectType>(this: CompiledDirectInitializer<T>, parent: RuntimeConstruct): never;
    createDefaultOutlet(this: CompiledClassDirectInitializer, element: JQuery, parent?: ConstructOutlet): ClassDirectInitializerOutlet;
    explain(sim: Simulation, rtConstruct: RuntimeConstruct): {
        message: string;
    };
}
export interface CompiledClassDirectInitializer<T extends CompleteClassType = CompleteClassType> extends ClassDirectInitializer, SuccessfullyCompiled {
    readonly temporaryDeallocator?: CompiledTemporaryDeallocator;
    readonly target: ObjectEntity<Exclude<T, ReferenceType>>;
    readonly args: readonly CompiledExpression[];
    readonly ctor: FunctionEntity<FunctionType<VoidType>>;
    readonly ctorCall: CompiledFunctionCall<FunctionType<VoidType>>;
}
export declare class RuntimeClassDirectInitializer<T extends CompleteClassType = CompleteClassType> extends RuntimeDirectInitializer<T, CompiledClassDirectInitializer<T>> {
    readonly ctorCall?: RuntimeFunctionCall<FunctionType<VoidType>>;
    private index;
    constructor(model: CompiledClassDirectInitializer<T>, parent: RuntimeConstruct);
    protected upNextImpl(): void;
    stepForwardImpl(): void;
}