s7webserverapi/dist/client/WriteTransaction.d.ts

Unofficial Simatic-S7-Webserver JSON-RPC-API Client for S7-1200/1500 PLCs

import { Observable, Subject } from "rxjs";
import { CacheMethod, FlattenKeys, S7DataTypes } from "../util/types";
import { CacheStructure } from "./CacheStructure";
/**
 * When we call the write function of the PLCConnector, we dont instantly get a response back. We basically want a Observable that sends a single value when the transaction is done.
 *
 * This class handles this. When writing, we create a new transaction. This is especially a shared Observable that we send back to the writing-caller and the polling-loop will collect the write-transaction here and when the transaction is done it will send a value to the Observable.
*/
export declare abstract class RPCTransactionHandler<KeyObject, T extends RPCTransaction<KeyObject, K>, K = unknown> {
    transactions: (T | null)[];
    nextId: number;
    freeSlots: number[];
    getAllTransactionsKeys(): number[];
    getTransaction(id: number): T | undefined;
    getTransactionFromKey(key: FlattenKeys<KeyObject>[]): T | undefined;
    transactionExists(id: number): boolean;
    removeTransaction(id: number): void;
    addDependentKey(id: number, key: FlattenKeys<KeyObject>): void;
}
export declare class WriteTransactionHandler<KeyObject> extends RPCTransactionHandler<KeyObject, WriteTransaction<KeyObject>, boolean> {
    isCurrentlyWriting(hmiKey: FlattenKeys<KeyObject> | FlattenKeys<KeyObject>[]): boolean;
    createTransaction(key: FlattenKeys<KeyObject>[], value: S7DataTypes): Observable<boolean>;
    resolveDependentKey(id: number, key: FlattenKeys<KeyObject>, result: boolean, cacheRef?: CacheStructure<KeyObject>): boolean;
}
export declare class GetTransactionHandler<KeyObject> extends RPCTransactionHandler<KeyObject, GetTransaction<KeyObject>, S7DataTypes> {
    private writeTransactionHandler;
    private cacheRef;
    constructor(writeTransactionHandler: WriteTransactionHandler<KeyObject>, cacheRef: CacheStructure<KeyObject>);
    getTransactionFromKey(keys: FlattenKeys<KeyObject>[], depth?: number, cacheMethod?: CacheMethod): GetTransaction<KeyObject> | undefined;
    createTransaction(key: FlattenKeys<KeyObject>[], cacheMethod: CacheMethod, depth: number): Observable<unknown>;
    resolveDependentKey(id: number, key: FlattenKeys<KeyObject>, value: S7DataTypes): boolean;
}
export declare abstract class RPCTransaction<KeyObject, K> {
    keys: FlattenKeys<KeyObject>[];
    value: S7DataTypes;
    id: number;
    dependentKeys: Map<FlattenKeys<KeyObject>, boolean | null>;
    subject: Subject<K>;
    constructor(key: FlattenKeys<KeyObject>[], id: number);
    addDependentKey(key: FlattenKeys<KeyObject>): void;
}
export declare class GetTransaction<KeyObject> extends RPCTransaction<KeyObject, S7DataTypes> {
    depth: number;
    private writeTransactionHandler;
    private cacheRef;
    cacheMethod: CacheMethod;
    internalReadStack: [FlattenKeys<KeyObject>, number][];
    constructor(key: FlattenKeys<KeyObject>[], id: number, cacheMethod: CacheMethod, depth: number, writeTransactionHandler: WriteTransactionHandler<KeyObject>, cacheRef: CacheStructure<KeyObject>);
    initialize(): void;
    initIgnoreCache(): void;
    useIgnoreCache(): void;
    useCache(): void;
    createConcatenatedObject(): {
        [key: string]: S7DataTypes;
    };
    initUseCache(): void;
    initUseWrite(): void;
    initWaitForWrite(): void;
    publishGetData(): void;
    resolveDependentKey(key: FlattenKeys<KeyObject>, value: S7DataTypes): void;
    checkAndResolve(): boolean;
}
export declare class WriteTransaction<KeyObject> extends RPCTransaction<KeyObject, boolean> {
    constructor(key: FlattenKeys<KeyObject>[], value: S7DataTypes, id: number);
    resolveDependentKey(key: FlattenKeys<KeyObject>, result: boolean): void;
    checkAndResolve(): [boolean, boolean];
}