const classafFancom::Flag

sys::Obj
  afFancom::Flag

A Flag represents many states by setting and clearing bits on a Int.

Using Ints as flags is still valid, but the Flags class gives superior debugging info. An example Flags class:

const class MyFlags : Flags {
  static const MyFlags one     := MyFlags(1, "one")
  static const MyFlags two     := MyFlags(2, "two")
  static const MyFlags three   := MyFlags(3, "three")
  static const MyFlags four    := MyFlags(4, "four")

  new make(Int flag, Str? name) : super(flag, name) { }
  new makeFromVariant(Variant variant) : super(variant) { }	
}

Set and clear bits by using + and - operators:

(MyFlags.two + MyFlags.two) .toStr  --> two
(MyFlags.two - MyFlags.four).toStr  --> two

Multiple flags may be set:

(MyFlags.one + MyFlags.four).toStr  --> one|four
(MyFlags.two + MyFlags.four).toStr  --> two|four

Flags are automatically coalesced:

(MyFlags.one + MyFlags.three) .toStr  --> three 

Unknown flags are presented as numbers:

(MyFlags(16))               .toStr  --> (18)
(MyFlags(10))               .toStr  --> two|(8)
(MyFlags(27))               .toStr  --> three|(8)|(16)

Every Flags subclass needs to declare the following ctor to fulfil the variant surrogate contract:

new makeFromVariant(Variant variant) : super(variant) { }
contains

Source

Bool contains(Flag flag)

Returns true if the given flag is set on this object.

equals

Source

virtual override Bool equals(Obj? obj)

hash

Source

virtual override Int hash()

make

Source

new make(Int value, Str? name := null)

makeFromVariant

Source

new makeFromVariant(Variant variant)

Variant surrogate ctor

minus

Source

@Operator
This minus(Flag b)

Removes Flag b. Shortcut is a - b.

name

Source

Str name { private set }

plus

Source

@Operator
This plus(Flag b)

Add Flag b. Shortcut is a + b.

toStr

Source

virtual override Str toStr()

toVariant

Source

Variant toVariant()

Variant surrogate method

value

Source

const Int value