Fencible
Mixin

internal

This mixin is used to apply reentrancy barriers to instance methods. For details, see fenced.

No results

Properties

Properties are getters/setters or publicly accessible variables on this class

fenced : Object

internal

static

This class property returns an object that specifies the instance methods which need reentrancy protection.

It is used like so:

 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         reentrantMethod : true
     };

     reentrantMethod() {
         // things() may cause reentrantMethod() to be called...
         // but we won't be allowed to reenter this method since we are already inside it
         this.things();
     }
 }

This can also be used to protect mutually reentrant method groups:

 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         foo : 'foobar'
         bar : 'foobar'
     };

     foo() {
         console.log('foo');
         this.bar();
     }

     bar() {
         console.log('bar');
         this.foo();
     }
 }

 instance = new Foo();
 instance.foo();
 >> foo
 instance.bar();
 >> bar

The value for a fenced method value can be true, a string, an array of strings, or a MethodFence options object.

Internally these methods are protected by defining a wrapper function on the instance. The class methods remain on the class prototype and are guarded by the instance-level method. This allows these methods to use super calls, just like other methods.

isFencible : Booleantrue

READONLY

static

ADVANCED

Identifies an object as an instance of Fencible class, or subclass thereof.

isFencible : Booleantrue

READONLY

ADVANCED

Identifies an object as an instance of Fencible class, or subclass thereof.

Type definitions

MethodFence
A description of how to protect a method from reentry.

A value of true is transformed using the key as the all value. For example, this:
```
 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         foo : true
     };
```
Is equivalent to this:
```
 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         foo : {
             all : ['foo']
         }
     };
```
Strings are split on spaces to produce the all array. For example, this:
```
 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         foo : 'foo bar'
     };
```
Is equivalent to this:
```
 class Foo extends Base.mixin(Fencible) {
     static fenced = {
         foo : {
             all : ['foo', 'bar']
         }
     };
```
This indicates that foo() cannot be reentered if foo() or bar() are already executing. On entry to foo(), both foo() and bar() will be fenced (prevented from entering).
Properties
- all : String/String[]
  
  One or more keys that must all be currently unlocked to allow entry to the fenced method. String values are converted to an array by splitting on spaces.
- any : String/String[]
  
  One or more keys of which at least one must be currently unlocked to allow entry to the fenced method. String values are converted to an array by splitting on spaces.
- lock : String/String[]
  
  One or more keys that will be locked on entry to the fenced method and released on exit. String values are converted to an array by splitting on spaces. By default, this array includes all keys in all and any.

Source path

Core/mixin/Fencible.js

Inheritance tree1

Fencible

Fencible Mixin internal

Properties

Type definitions

Properties

Source path

Inheritance tree1

Contents

Fencible
Mixin

internal