View Source Kinda.Wrapper.Generate (kinda v0.11.0)

Generic emission helpers for wrapper manifests.

Summary

Types

callback_bridge_backlog_entry()

@type callback_bridge_backlog_entry() :: %{
  function: Kinda.Wrapper.Function.t(),
  callback_bridge: Kinda.Wrapper.CallbackBridge.t()
}

callback_bridge_manifest()

@type callback_bridge_manifest() :: %{
  required(String.t()) => pos_integer() | [callback_bridge_manifest_entry()]
}

callback_bridge_manifest_entry()

@type callback_bridge_manifest_entry() :: %{
  required(String.t()) =>
    callback_bridge_manifest_function() | callback_bridge_manifest_metadata()
}

callback_bridge_manifest_function()

@type callback_bridge_manifest_function() :: %{
  required(String.t()) =>
    String.t() | non_neg_integer() | boolean() | [String.t()] | nil
}

callback_bridge_manifest_metadata()

@type callback_bridge_manifest_metadata() :: %{
  required(String.t()) => String.t() | [String.t()]
}

declaration_manifest()

@type declaration_manifest() :: map()

declaration_manifest_struct()

@type declaration_manifest_struct() :: Kinda.CodeGen.DeclarationManifest.t()

declaration_surfaces_struct()

@type declaration_surfaces_struct() :: Kinda.CodeGen.DeclarationSurfaces.t()

signature_manifest()

@type signature_manifest() :: %{
  required(String.t()) =>
    pos_integer() | [signature_manifest_entry()] | [signature_manifest_record()]
}

signature_manifest_entry()

@type signature_manifest_entry() :: %{
  required(String.t()) =>
    signature_manifest_function()
    | [signature_manifest_variant()]
    | String.t()
    | nil
}

signature_manifest_function()

@type signature_manifest_function() :: %{
  required(String.t()) =>
    String.t()
    | non_neg_integer()
    | [String.t() | nil]
    | map()
    | [map() | nil]
    | nil
}

signature_manifest_record()

@type signature_manifest_record() :: %{
  required(String.t()) =>
    String.t() | map() | [signature_manifest_record_field()]
}

signature_manifest_record_field()

@type signature_manifest_record_field() :: %{
  required(String.t()) => String.t() | map() | nil
}

signature_manifest_variant()

@type signature_manifest_variant() :: %{
  required(String.t()) =>
    String.t() | false | [String.t()] | [map()] | map() | nil
}

Functions

callback_bridge_backlog(manifest, policy)

@spec callback_bridge_backlog(Kinda.Wrapper.Manifest.t(), module()) :: [
  callback_bridge_backlog_entry()
]

callback_bridge_manifest(manifest, policy)

@spec callback_bridge_manifest(Kinda.Wrapper.Manifest.t(), module()) ::
  callback_bridge_manifest()

declaration_manifest(manifest, policy)

@spec declaration_manifest(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_manifest()

declaration_manifest_struct(manifest, policy)

@spec declaration_manifest_struct(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_manifest_struct()

declaration_surfaces_struct(manifest, policy)

@spec declaration_surfaces_struct(Kinda.Wrapper.Manifest.t(), module()) ::
  declaration_surfaces_struct()

elixir_functions(manifest, policy)

@spec elixir_functions(Kinda.Wrapper.Manifest.t(), module()) :: [{atom(), [atom()]}]

elixir_nif_decls(manifest, policy)

@spec elixir_nif_decls(Kinda.Wrapper.Manifest.t(), module()) :: [
  Kinda.CodeGen.NIFDecl.t()
]

render_callback_bridge_report(manifest, policy)

@spec render_callback_bridge_report(Kinda.Wrapper.Manifest.t(), module()) ::
  String.t()

render_elixir_manifest(manifest, policy)

@spec render_elixir_manifest(Kinda.Wrapper.Manifest.t(), module()) :: String.t()

render_zig_nif_entries(manifest, policy)

@spec render_zig_nif_entries(Kinda.Wrapper.Manifest.t(), module()) :: String.t()

signature_manifest(manifest, policy)

@spec signature_manifest(Kinda.Wrapper.Manifest.t(), module()) :: signature_manifest()

write_callback_bridge_manifest(manifest, policy, path, encoder)

@spec write_callback_bridge_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (callback_bridge_manifest() -> iodata())
) :: :ok

write_callback_bridge_report(manifest, policy, path)

@spec write_callback_bridge_report(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t()
) :: :ok

write_declaration_manifest(manifest, policy, path, encoder)

@spec write_declaration_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (declaration_manifest() -> iodata())
) :: :ok

write_elixir_manifest(manifest, policy, path)

@spec write_elixir_manifest(Kinda.Wrapper.Manifest.t(), module(), nil | String.t()) ::
  :ok

write_signature_manifest(manifest, policy, path, encoder)

@spec write_signature_manifest(
  Kinda.Wrapper.Manifest.t(),
  module(),
  nil | String.t(),
  (signature_manifest() -> iodata())
) :: :ok

write_zig_nif_entries(manifest, policy, path)

@spec write_zig_nif_entries(Kinda.Wrapper.Manifest.t(), module(), nil | String.t()) ::
  :ok

zig_entries(manifest, policy)

@spec zig_entries(Kinda.Wrapper.Manifest.t(), module()) :: [String.t()]