Skip to content

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

[Source]

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 underlying 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

[Source]

Create a Flags instance with an optional initial value. Default is 0 (no flags set).

new iso create(
  value': B = 0)
: Flags[A, B] iso^

Parameters

  • value': B = 0

Returns


Public Functions

value

[Source]

Returns the bit encoding of the set flags.

fun box value()
: B

Returns

  • B

apply

[Source]

Returns true if the flag is set.

fun box apply(
  flag: A)
: Bool val

Parameters

  • flag: A

Returns


all

[Source]

Sets all bits, including undefined flags.

fun ref all()
: None val

Returns


clear

[Source]

Unsets all flags.

fun ref clear()
: None val

Returns


set

[Source]

Sets the flag.

fun ref set(
  flag: A)
: None val

Parameters

  • flag: A

Returns


unset

[Source]

Unsets the flag.

fun ref unset(
  flag: A)
: None val

Parameters

  • flag: A

Returns


flip

[Source]

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

[Source]

The union of this and that.

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

Parameters

Returns


intersect

[Source]

The intersection of this and that.

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

Parameters

Returns


difference

[Source]

The symmetric difference of this and that.

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

Parameters

Returns


remove

[Source]

Unset flags that are set in that.

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

Parameters

Returns


add

[Source]

This with the flag set.

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

Parameters

  • flag: A

Returns


sub

[Source]

This with the flag unset.

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

Parameters

  • flag: A

Returns


op_or

[Source]

The union of this and that.

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

Parameters

Returns


op_and

[Source]

The intersection of this and that.

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

Parameters

Returns


op_xor

[Source]

The symmetric difference of this and that.

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

Parameters

Returns


without

[Source]

The flags in this that are not in that.

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

Parameters

Returns


clone

[Source]

Create a clone.

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

Returns


eq

[Source]

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

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

Parameters

Returns


lt

[Source]

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

[Source]

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

[Source]

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

[Source]

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

[Source]

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

Parameters

Returns


ne

[Source]

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

Parameters

Returns