ArenaPool <Type>

This pool works like an arena allocator, it preallocates a large list of objects and passes them out sequentially It is meant to be freed all at once, so things that can be reclaimed after a frame are the ideal type.

If you need to take singular objects and put singular objects back RentalPool is ideal.

Hierarchy

• ArenaPool
  • Pool

Index

Constructors

• constructor

Properties

• builder
• disableWarnings
• index
• maxObjects
• objects
• recycler
• totalAllocations

Methods

• borrow
• dispose
• done
• get
• preallocate
• using

Constructors

constructor

• ArenaPool<Type>(builder: () => Type, recycler?: (instance: Type) => Type, maxObjects?: number): ArenaPool<Type>

• Type parameters

  • Type

  Parameters

  • builder: () => Type

  • optionalrecycler: (instance: Type) => Type

  • maxObjects: number = 100

  Returns ArenaPool<Type>

Properties

publicbuilder

builder: () => Type

Type declaration

• • (): Type

  • Returns Type

publicdisableWarnings

disableWarnings: boolean = false

publicindex

index: number = 0

publicmaxObjects

maxObjects: number = 100

publicobjects

objects: Type[] = []

publicoptionalrecycler

recycler?: (instance: Type) => Type

Type declaration

• • (instance: Type): Type

  • Parameters

    • instance: Type

    Returns Type

publictotalAllocations

totalAllocations: number = 0

Methods

borrow

• borrow(context: (object: Type) => void): void

• Use a single instance out of th pool and immediately return it to the pool

  ---

  Parameters

  • context: (object: Type) => void

  Returns void

dispose

• dispose(): void

• Returns void

done

• done(...objects: Type[]): Type[]
• done(): void

• Signals we are done with the pool objects for now, Reclaims all objects in the pool.

  If a list of pooled objects is passed to done they are un-hooked from the pool and are free to be passed to consumers

  ---

  Parameters

  • rest...objects: Type[]

    A list of object to separate from the pool

  Returns Type[]

get

• get(): Type

• Retrieve a value from the pool, will allocate a new instance if necessary or recycle from the pool

  ---

  Returns Type

preallocate

• preallocate(): void

• Returns void

using

• using(context: (pool: ArenaPool<Type>) => void | Type[]): Type[]

• Use many instances out of the in the context and return all to the pool.

  By returning values out of the context they will be un-hooked from the pool and are free to be passed to consumers

  ---

  Parameters

  • context: (pool: ArenaPool<Type>) => void | Type[]

  Returns Type[]