src/necsus/compiletime/systemGen

Search:
Group by:

Types

AppInputs = seq[tuple[argName: string, directive: MonoDirective]]
The list of arguments passed into the app 
BuildArchetype[T] = proc (builder: var ArchetypeBuilder[ComponentDef];
                          systemArgs: seq[SystemArg]; dir: T)
A callback used to construct an archetype 
ConverterDef = ref object
  input*: Archetype[ComponentDef]
  adding*: seq[ComponentDef]
  output*: TupleDirective
  sinkParams*: bool
Defines a function for converting from one tuple shape to another 
ConvertExtractor[T] = proc (context: GenerateContext; dir: T): seq[ConverterDef]
The callback for determining what converters to execute 
DirectiveGen = ref object
  ident*: string
  interest*: set[GenerateHook]
  case kind*: DirectiveKind
  of DirectiveKind.Mono:
    generateMono*: HookGenerator[MonoDirective]
    archetypeMono*: BuildArchetype[MonoDirective]
    chooseNameMono*: NameChooser[MonoDirective]
    systemReturn*: proc (args: DirectiveSet[SystemArg]; returns: MonoDirective): Option[
        NimNode]
    worldFieldsMono*: proc (name: string; returns: MonoDirective): seq[
        WorldField]
    systemArgMono*: SystemArgExtractor[MonoDirective]
    nestedArgsMono*: NestedArgsExtractor[MonoDirective]
  of DirectiveKind.Tuple:
    generateTuple*: HookGenerator[TupleDirective]
    archetypeTuple*: BuildArchetype[TupleDirective]
    chooseNameTuple*: NameChooser[TupleDirective]
    worldFieldsTuple*: proc (name: string; returns: TupleDirective): seq[
        WorldField]
    systemArgTuple*: SystemArgExtractor[TupleDirective]
    nestedArgsTuple*: NestedArgsExtractor[TupleDirective]
    convertersTuple*: ConvertExtractor[TupleDirective]
  of DirectiveKind.None:
    generateNone*: HookGenerator[void]
    systemArgNone*: SystemArgExtractor[void]
  of DirectiveKind.Dual:
    generateDual*: HookGenerator[DualDirective]
    archetypeDual*: BuildArchetype[DualDirective]
    chooseNameDual*: NameChooser[DualDirective]
    worldFieldsDual*: proc (name: string; returns: DualDirective): seq[
        WorldField]
    systemArgDual*: SystemArgExtractor[DualDirective]
    nestedArgsDual*: NestedArgsExtractor[DualDirective]
    convertersDual*: ConvertExtractor[DualDirective]
An object that can contribute to Necsus code generation 
DirectiveKind {.pure.} = enum
  Dual, Tuple, Mono, None
GenerateContext = ref object
  hook*: GenerateHook
  directives*: Table[DirectiveGen, DirectiveSet[SystemArg]]
  inputs*: AppInputs
  archetypes*: ArchetypeSet[ComponentDef]
  appStateTypeName*: NimNode
Information passed in while performing code gen for a generator 
GenerateHook = enum
  Outside, Standard, Late, BeforeLoop, LoopStart, AfterActiveCheck, LoopEnd
The different points at which code can be hooked 
HookGenerator[T] = proc (details: GenerateContext; arg: SystemArg; name: string;
                         dir: T): NimNode
The callback that allows a decorator to generate code for a specific hook 
NameChooser[T] = proc (context, name: NimNode; dir: T): string
Picks the name for an argument 
NestedArgsExtractor[T] = proc (dir: T): seq[RawNestedArg]
Callback that pulls out any nested arguments also required by this directive 
RawNestedArg = tuple[context, name, directive: NimNode]
A field to add to the world object 
SystemArg = ref object
  source*: NimNode
  generator*: DirectiveGen
  originalName*: string
  name*: string
  case kind*: DirectiveKind
  of DirectiveKind.Tuple:
    tupleDir*: TupleDirective
  of DirectiveKind.Mono:
    monoDir*: MonoDirective
  of DirectiveKind.None:
    nil
  of DirectiveKind.Dual:
    dualDir*: DualDirective
  nestedArgs*: seq[SystemArg]
A single arg within a system proc 
SystemArgExtractor[T] = proc (name: string; dir: T): NimNode
The callback used for determining the value to pass when calling the system 
WorldField = tuple[name: string, typ: NimNode]
A field to add to the world object

Procs

proc `$`(arg: SystemArg): string {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: DirectiveGen): bool {....raises: [], tags: [], forbids: [].}
proc `==`(a, b: SystemArg): bool {....raises: [], tags: [], forbids: [].}
proc archetypeFor(ctx: GenerateContext; components: openArray[ComponentDef]): Archetype[
    ComponentDef] {....raises: [KeyError], tags: [], forbids: [].}
Returns the archetype to use for a set of components 
proc archetypeFor(ctx: GenerateContext; dir: TupleDirective): Archetype[
    ComponentDef] {....raises: [KeyError], tags: [], forbids: [].}
Returns the archetype to use for a set of components 
proc buildArchetype(builder: var ArchetypeBuilder[ComponentDef];
                    systemArgs: seq[SystemArg]; arg: SystemArg) {....raises: [],
    tags: [], forbids: [].}
Generates the code for a specific hook 
proc converters(ctx: GenerateContext; arg: SystemArg): seq[ConverterDef] {.
    ...raises: [], tags: [], forbids: [].}
Returns a list of all the convertsers needed by a system 
proc generateForHook(arg: SystemArg; details: GenerateContext; name: string): NimNode {.
    ...raises: [], tags: [], forbids: [].}
Generates the code for a specific hook 
proc generateName(arg: SystemArg): string {....raises: [], tags: [], forbids: [].}
proc globalName(ctx: GenerateContext; name: string): NimNode {....raises: [],
    tags: [], forbids: [].}
Generates a deterministic name for a global identifier 
proc globalStr(ctx: GenerateContext; name: string): string {....raises: [],
    tags: [], forbids: [].}
Generates a deterministic name for a global identifier that is unique to this app 
proc hash(arg: SystemArg): Hash {....raises: [], tags: [], forbids: [].}
proc hash(gen: DirectiveGen): Hash {....raises: [], tags: [], forbids: [].}
proc name(convert: ConverterDef): NimNode {....raises: [], tags: [], forbids: [].}
Returns the name for referencing a ConverterDef 
proc nameOf(ctx: GenerateContext; arg: SystemArg): string {....raises: [KeyError],
    tags: [], forbids: [].}
Returns the name used for a system arg 
proc newConverter(input: Archetype[ComponentDef]; adding: seq[ComponentDef];
                  output: Archetype[ComponentDef]; sinkParams: bool): ConverterDef {.
    ...raises: [], tags: [], forbids: [].}
proc newConverter(input: Archetype[ComponentDef]; output: TupleDirective): ConverterDef {.
    ...raises: [], tags: [], forbids: [].}
proc newGenerator(ident: string; interest: set[GenerateHook];
                  generate: HookGenerator[DualDirective];
                  archetype: BuildArchetype[DualDirective] = noArchetype;
                  chooseName: NameChooser[DualDirective] = defaultName;
    worldFields: proc (name: string; dir: DualDirective): seq[WorldField] = defaultWorldField;
    systemArg: SystemArgExtractor[DualDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[
    DualDirective] = defaultNestedArgs; converters: ConvertExtractor[
    DualDirective] = defaultConverters): DirectiveGen {....raises: [], tags: [],
    forbids: [].}
Create a tuple based generator 
proc newGenerator(ident: string; interest: set[GenerateHook];
                  generate: HookGenerator[MonoDirective];
                  archetype: BuildArchetype[MonoDirective] = noArchetype;
                  chooseName: NameChooser[MonoDirective] = defaultName;
    systemReturn: proc (args: DirectiveSet[SystemArg]; returns: MonoDirective): Option[
    NimNode] = defaultSystemReturn; worldFields: proc (name: string;
    dir: MonoDirective): seq[WorldField] = defaultWorldField; systemArg: SystemArgExtractor[
    MonoDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[
    MonoDirective] = defaultNestedArgs): DirectiveGen {....raises: [], tags: [],
    forbids: [].}
Creates a mono based generator 
proc newGenerator(ident: string; interest: set[GenerateHook];
                  generate: HookGenerator[TupleDirective];
                  archetype: BuildArchetype[TupleDirective] = noArchetype;
                  chooseName: NameChooser[TupleDirective] = defaultName;
    worldFields: proc (name: string; dir: TupleDirective): seq[WorldField] = defaultWorldField;
    systemArg: SystemArgExtractor[TupleDirective] = defaultSystemArg; nestedArgs: NestedArgsExtractor[
    TupleDirective] = defaultNestedArgs; converters: ConvertExtractor[
    TupleDirective] = defaultConverters): DirectiveGen {....raises: [], tags: [],
    forbids: [].}
Create a tuple based generator 
proc newGenerator(ident: string; interest: set[GenerateHook];
                  generate: HookGenerator[void]; worldFields: proc (name: string): seq[
    WorldField] = defaultWorldFieldNone;
                  systemArg: SystemArgExtractor[void] = defaultSystemArgNone): DirectiveGen {.
    ...raises: [], tags: [], forbids: [].}
Creates a 'none' generator 
proc newSystemArg[T: TupleDirective | MonoDirective | DualDirective | void](
    source: NimNode; generator: DirectiveGen; originalName: string;
    name: string; nestedArgs: seq[SystemArg] = @[]; directive: T): SystemArg
Instantiates a SystemArg 
proc sendEventProcName(directive: MonoDirective): tuple[
    internal, external: NimNode] {....raises: [], tags: [], forbids: [].}
Generates the proc name for sending an event to all listening inboxes 
proc signature(conv: ConverterDef): string {....raises: [], tags: [], forbids: [].}
Produces a globally unique signature for a converter 
proc systemArg(ctx: GenerateContext; arg: SystemArg): NimNode {.
    ...raises: [KeyError], tags: [], forbids: [].}
Returns the value to pass to a system when executin the given argument 
proc systemArg(directives: Table[DirectiveGen, DirectiveSet[SystemArg]];
               arg: SystemArg): NimNode {....raises: [KeyError], tags: [],
    forbids: [].}
Returns the value to pass to a system when executin the given argument 
proc worldFields(arg: SystemArg; name: string): seq[WorldField] {.
    ...raises: [Exception], tags: [RootEffect], forbids: [].}
Generates the code for a specific hook

Iterators

iterator allArgs(args: openArray[SystemArg]): SystemArg {....raises: [], tags: [],
    forbids: [].}
iterator nodes(arg: SystemArg): NimNode {....raises: [], tags: [], forbids: [].}
Pulls all nodes out of an arg

Made with Nim. Generated: 2025-04-16 03:56:46 UTC