Flatbuffer.Schema (flatbuffer v0.3.0)

Schema definition and parser for FlatBuffers.

Handles parsing and processing of FlatBuffer schema files (.fbs), including type definitions, namespaces, and includes. Supports:

  • Tables, structs, enums, and unions
  • Basic types (bool, int, float, string, etc.)
  • Vectors and references
  • Schema includes and namespaces
  • File identifiers

Example

{:ok, schema} = Schema.from_file("schema.fbs")
# or
{:ok, schema} = Schema.from_string(schema_string)

# Optionally, you can supply a resolver for includes
{:ok, schema} = Schema.from_file("schema.fbs", resolver: &File.read/1)

Summary

Functions

Reads and parses a FlatBuffer schema from a file.

Parses a FlatBuffer schema from a string.

Types

enum_def()

@type enum_def() ::
  {:enum,
   %{
     members: %{
       required(enum_name()) => integer(),
       required(integer()) => enum_name()
     }
   }}

enum_name()

@type enum_name() :: atom()

field_name()

@type field_name() :: atom()

from_errors()

@type from_errors() ::
  {:error, {:no_resolver, file_name :: String.t()}}
  | {:error, :root_type_is_undefined}
  | {:error, {:root_type_not_found, type_name :: String.t()}}
  | {:error, {:root_type_is_not_a_table, type_name :: String.t()}}
  | {:error, {:type_not_found, type_name :: String.t()}}

resolver_fn()

@type resolver_fn() :: (filename :: String.t() -> String.t())

struct_def()

@type struct_def() :: {:struct, %{members: [{field_name(), type_def()}]}}

t()

@type t() :: %Flatbuffer.Schema{
  entities: %{required(type_name()) => type_def()},
  id: binary() | nil,
  root_type: type_ref()
}

table_def()

@type table_def() ::
  {:table,
   %{
     fields: [{field_name(), type_ref()}],
     indices: %{required(field_name()) => {integer(), type_ref()}}
   }}

type_def()

@type type_def() :: table_def() | struct_def() | union_def() | enum_def()

type_name()

@type type_name() :: String.t()

type_ref()

@type type_ref() ::
  {:table, %{name: type_name()}}
  | {:struct, %{name: type_name()}}
  | {:enum, %{name: type_name()}}
  | {:union, %{name: type_name()}}
  | {:vector, type_ref()}
  | {:bool, %{default: boolean()}}
  | {:byte, %{default: integer()}}
  | {:ubyte, %{default: integer()}}
  | {:short, %{default: integer()}}
  | {:ushort, %{default: integer()}}
  | {:int, %{default: integer()}}
  | {:uint, %{default: integer()}}
  | {:long, %{default: integer()}}
  | {:ulong, %{default: integer()}}
  | {:float, %{default: float()}}
  | {:double, %{default: float()}}
  | {:string, %{default: String.t()}}

union_def()

@type union_def() ::
  {:union,
   %{
     members: %{
       required(type_name()) => integer(),
       required(integer()) => type_name()
     }
   }}

Functions

from_file(file_name, opts \\ [])

@spec from_file(file_name :: String.t(), opts :: [{:resolver, resolver_fn()}]) ::
  {:ok, t()} | from_errors()

Reads and parses a FlatBuffer schema from a file.

Parameters

  • file_name (String.t()): The path to the schema file.
  • opts ([resolver: resolver_fn()]): Optional keyword list of options.
    • :resolver (resolver_fn()): A function to resolve imports or includes within the schema.

Returns

  • The parsed schema, or an error tuple if the schema could not be parsed.

Examples

iex> Flatbuffer.Schema.from_file("path/to/schema.fbs")
{:ok, schema}

iex> Flatbuffer.Schema.from_file("path/to/schema.fbs", resolver: &my_resolver/1)
{:ok, schema}

from_string(string, opts \\ [])

@spec from_string(string :: String.t(), opts :: [{:resolver, resolver_fn()}]) ::
  {:ok, t()} | from_errors()

Parses a FlatBuffer schema from a string.

Parameters

  • string (String.t()): The FlatBuffer schema as a string.
  • opts ([resolver: resolver_fn()]): Optional keyword list of options.
    • :resolver (resolver_fn()): A function used to resolve schema dependencies.

Returns

A parsed schema.

Examples

iex(1)> schema = """ ...(1)> table Table { ...(1)> field: int; ...(1)> } ...(1)> ...(1)> root_type Table; ...(1)> """ iex(2)> {:ok, parsed_schema} = Flatbuffer.Schema.from_string(schema)

resolve_types(entities)