Flags[A: Flag[B] val, optional B: ((U8 val | U16 val | U32 val | U64 val | U128 val | ULong val | USize val) & Integer[B] val)]

Flags is a set of flags. The flags that are recognised should be passed as a union type for type parameter A. For example:

primitive SSE fun value(): U64 => 1

primitive AVX fun value(): U64 => 2

primitive RDTSCP fun value(): U64 => 4

type Features is Flags[(SSE | AVX | RDTSCP)]

Type parameter B is the unlying field used to store the flags.

class ref Flags[A: Flag[B] val, optional B: ((U8 val | U16 val | U32 val | 
    U64 val | U128 val | ULong val | 
    USize val) & Integer[B] val)] is
  Comparable[Flags[A, B] box] ref

Implements


Constructors

create

new iso create()
: Flags[A, B] iso^

Returns


Public Functions

value

Returns the bit encoding of the set flags.

fun box value()
: B

Returns

  • B

apply

Returns true if the flag is set.

fun box apply(
  flag: A)
: Bool val

Parameters

  • flag: A

Returns


all

Sets all bits, including undefined flags.

fun ref all()
: None val

Returns


clear

Unsets all flags.

fun ref clear()
: None val

Returns


set

Sets the flag.

fun ref set(
  flag: A)
: None val

Parameters

  • flag: A

Returns


unset

Unsets the flag.

fun ref unset(
  flag: A)
: None val

Parameters

  • flag: A

Returns


flip

Sets the flag if it is unset, unsets the flag if it is set.

fun ref flip(
  flag: A)
: None val

Parameters

  • flag: A

Returns


union

The union of this and that.

fun ref union(
  that: Flags[A, B] box)
: None val

Parameters

Returns


intersect

The intersection of this and that.

fun ref intersect(
  that: Flags[A, B] box)
: None val

Parameters

Returns


difference

The symmetric difference of this and that.

fun ref difference(
  that: Flags[A, B] box)
: None val

Parameters

Returns


remove

Unset flags that are set in that.

fun ref remove(
  that: Flags[A, B] box)
: None val

Parameters

Returns


add

This with the flag set.

fun box add(
  flag: A)
: Flags[A, B] iso^

Parameters

  • flag: A

Returns


sub

This with the flag unset.

fun box sub(
  flag: A)
: Flags[A, B] iso^

Parameters

  • flag: A

Returns


op_or

The union of this and that.

fun box op_or(
  that: Flags[A, B] box)
: Flags[A, B] iso^

Parameters

Returns


op_and

The intersection of this and that.

fun box op_and(
  that: Flags[A, B] box)
: Flags[A, B] iso^

Parameters

Returns


op_xor

The symmetric difference of this and that.

fun box op_xor(
  that: Flags[A, B] box)
: Flags[A, B] iso^

Parameters

Returns


without

The flags in this that are not in that.

fun box without(
  that: Flags[A, B] box)
: Flags[A, B] iso^

Parameters

Returns


clone

Create a clone.

fun box clone()
: Flags[A, B] iso^

Returns


eq

Returns true if this has the same flags set as that.

fun box eq(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns


lt

Returns true if the flags set on this are a strict subset of the flags set on that. Flags is only partially ordered, so lt is not the opposite of ge.

fun box lt(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns


le

Returns true if the flags set on this are a subset of the flags set on that or they are the same. Flags is only partially ordered, so le is not the opposite of te.

fun box le(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns


gt

Returns true if the flags set on this are a struct superset of the flags set on that. Flags is only partially ordered, so gt is not the opposite of le.

fun box gt(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns


ge

Returns true if the flags set on this are a superset of the flags set on that or they are the same. Flags is only partially ordered, so ge is not the opposite of lt.

fun box ge(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns


compare

fun box compare(
  that: Flags[A, B] box)
: (Less val | Equal val | Greater val)

Parameters

Returns


ne

fun box ne(
  that: Flags[A, B] box)
: Bool val

Parameters

Returns