123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338
//================================================================ /** * @packageDocumentation * @module std   *///================================================================import { ILockable } from "../base/thread/ILockable";import { ISharedTimedLockable } from "../base/thread/ISharedTimedLockable";
import { AccessType } from "../internal/thread/AccessType";import { LockType } from "../internal/thread/LockType";
import { List } from "../container/List";import { InvalidArgument } from "../exception/InvalidArgument";import { sleep_for } from "./global";
/** * Shared timed mutex. *  * @author Jeongho Nam - https://github.com/samchon */export class SharedTimedMutex implements ISharedTimedLockable{    private source_: ILockable;    private queue_: List<IResolver>;
    private writing_: number;    private reading_: number;
    /* ---------------------------------------------------------        CONSTRUCTORS    --------------------------------------------------------- */    /**     * Default Constructor.     */    public constructor();
    /**     * @internal     */    public constructor(source: ILockable);
    public constructor(source: ILockable | null = null)    {        this.source_ = (source !== null) ? source : this;        this.queue_ = new List();
        this.writing_ = 0;        this.reading_ = 0;    }
    private _Current_access_type(): AccessType | null    {        return this.queue_.empty()            ? null            : this.queue_.front().accessType;    }
    /* ---------------------------------------------------------        WRITE LOCK    --------------------------------------------------------- */    /**     * @inheritDoc     */    public lock(): Promise<void>    {        return new Promise<void>(resolve =>        {            // CONSTRUCT RESOLVER            let resolver: IResolver = {                handler: (this.writing_++ === 0 && this.reading_ === 0)                    ? null                    : resolve,                accessType: AccessType.WRITE,                lockType: LockType.HOLD            };            this.queue_.push_back(resolver);
            // LOCK OR WAIT            if (resolver.handler === null)                resolve();        });    }
    /**     * @inheritDoc     */    public async try_lock(): Promise<boolean>    {        // LOCKABLE ?        if (this.writing_ !== 0 || this.reading_ !== 0)            return false;
        // CONSTRUCT RESOLVER        this.queue_.push_back({            handler: null,            accessType: AccessType.WRITE,            lockType: LockType.KNOCK        });
        // RETURNS        ++this.writing_;        return true;    }
    /**     * @inheritDoc     */    public try_lock_for(ms: number): Promise<boolean>    {        return new Promise<boolean>(resolve =>        {            // CONSTRUCT RESOLVER            let it: List.Iterator<IResolver> = this.queue_.insert(this.queue_.end(),            {                handler: (this.writing_++ === 0 && this.reading_ === 0)                    ? null                    : resolve,                accessType: AccessType.WRITE,                lockType: LockType.KNOCK            });
            if (it.value.handler === null)                resolve(true); // SUCCESS            else             {                // AUTOMATIC UNLOCK AFTER TIMEOUT                sleep_for(ms).then(() =>                {                    // NOT YET, THEN DO UNLOCK                    if (it.value.handler !== null)                    {                        --this.writing_;                        this._Cancel(it);                    }                });            }        });    }
    /**     * @inheritDoc     */    public async try_lock_until(at: Date): Promise<boolean>    {        // COMPUTE MILLISECONDS TO WAIT        let now: Date = new Date();        let ms: number = at.getTime() - now.getTime();
        return await this.try_lock_for(ms);    }
    /**     * @inheritDoc     */    public async unlock(): Promise<void>    {        if (this._Current_access_type() !== AccessType.WRITE)            throw new InvalidArgument(`Error on std.${this.source_.constructor.name}.unlock(): this mutex is free on the unique lock.`);
        --this.writing_;        this.queue_.pop_front();
        this._Release();    }
    /* ---------------------------------------------------------        READ LOCK    --------------------------------------------------------- */    /**     * @inheritDoc     */    public lock_shared(): Promise<void>    {        return new Promise<void>(resolve =>        {            let resolver: IResolver = {                handler: (this.writing_ === 0)                    ? null                    : resolve,                accessType: AccessType.READ,                lockType: LockType.HOLD            }            this.queue_.push_back(resolver);                        ++this.reading_;            if (resolver.handler === null)                resolve();        });    }
    /**     * @inheritDoc     */    public async try_lock_shared(): Promise<boolean>    {        if (this.writing_ !== 0)            return false;                ++this.reading_;        this.queue_.push_back({            handler: null,            accessType: AccessType.READ,            lockType: LockType.KNOCK        });        return true;    }
    /**     * @inheritDoc     */    public try_lock_shared_for(ms: number): Promise<boolean>    {        return new Promise<boolean>(resolve =>        {            // CONSTRUCT RESOLVER            let it: List.Iterator<IResolver> = this.queue_.insert(this.queue_.end(),             {                handler: (this.writing_ === 0)                    ? null                    : resolve,                accessType: AccessType.READ,                lockType: LockType.KNOCK            });                        ++this.reading_;            if (it.value.handler === null)                resolve(true);            else            {                // AUTOMATIC UNLOCK AFTER TIMEOUT                sleep_for(ms).then(() =>                {                    // NOT YET, THEN DO UNLOCK                    if (it.value.handler !== null)                    {                        --this.reading_;                        this._Cancel(it);                    }                });            }        });    }
    /**     * @inheritDoc     */    public async try_lock_shared_until(at: Date): Promise<boolean>    {        // COMPUTE MILLISECONDS TO WAIT        let now: Date = new Date();        let ms: number = at.getTime() - now.getTime();
        return await this.try_lock_shared_for(ms);    }
    /**     * @inheritDoc     */    public async unlock_shared(): Promise<void>    {        if (this._Current_access_type() !== AccessType.READ)            throw new InvalidArgument(`Error on std.${this.source_.constructor.name}.unlock_shared(): this mutex is free on the shared lock.`);
        --this.reading_;        this.queue_.pop_front();
        this._Release();    }
    /* ---------------------------------------------------------        RELEASE    --------------------------------------------------------- */    private _Release(): void    {        // STEP TO THE NEXT LOCKS        let current: AccessType = this._Current_access_type()!;        let resolverList: IResolver[] = [];
        for (let resolver of this.queue_)        {            // DIFFERENT ACCESS TYPE COMES?            if (resolver.accessType !== current)                break;
            // COPY AND CLEAR            else if (resolver.handler !== null)            {                resolverList.push({ ...resolver });                resolver.handler = null;            }                        // STOP AFTER WRITE LOCK            if (resolver.accessType === AccessType.WRITE)                break;        }
        // CALL THE HANDLERS        for (let resolver of resolverList)            if (resolver.lockType === LockType.HOLD)                resolver.handler!();            else                resolver.handler!(true);    }
    private _Cancel(it: List.Iterator<IResolver>): void    {        //----        // POP THE RELEASE        //----        // DO RASE        this.queue_.erase(it);
        // EXTRACT HANDLER TO AVOID THE `this._Release()`        let handler: Function = it.value.handler!;        it.value.handler = null;
        //----        // POST-PROCESS        //----        // CHECK THE PREVIOUS RESOLVER        let prev: List.Iterator<IResolver> = it.prev();
        // RELEASE IF IT IS THE LASTEST RESOLVER        if (prev.equals(this.queue_.end()) === false && prev.value.handler === null)            this._Release();                // (LAZY) RETURNS FAILURE        handler(false);    }}
interface IResolver{    handler: Function | null;    accessType: AccessType; // read or write    lockType: LockType; // void or boolean}