Librdata bindings

librdata.scala

package librdata

import _root_.scala.scalanative.unsafe.*
import _root_.scala.scalanative.unsigned.*
import _root_.scala.scalanative.libc.*
import _root_.scala.scalanative.*

object predef:
  private[librdata] trait CEnumU[T](using eq: T =:= UInt):
    given Tag[T] = Tag.UInt.asInstanceOf[Tag[T]]
    extension (inline t: T)
     inline def int: CInt = eq.apply(t).toInt
     inline def uint: CUnsignedInt = eq.apply(t)
     inline def value: CUnsignedInt = eq.apply(t)


object enumerations:
  import predef.*
  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_error_e = CUnsignedInt
  object rdata_error_e extends CEnumU[rdata_error_e]:
    given _tag: Tag[rdata_error_e] = Tag.UInt
    inline def define(inline a: Long): rdata_error_e = a.toUInt
    val RDATA_OK = define(0)
    val RDATA_ERROR_OPEN = define(1)
    val RDATA_ERROR_SEEK = define(2)
    val RDATA_ERROR_READ = define(3)
    val RDATA_ERROR_MALLOC = define(4)
    val RDATA_ERROR_USER_ABORT = define(5)
    val RDATA_ERROR_PARSE = define(6)
    val RDATA_ERROR_WRITE = define(7)
    val RDATA_ERROR_FACTOR = define(8)
    val RDATA_ERROR_UNSUPPORTED_COMPRESSION = define(9)
    val RDATA_ERROR_UNSUPPORTED_CHARSET = define(10)
    val RDATA_ERROR_CONVERT = define(11)
    val RDATA_ERROR_CONVERT_BAD_STRING = define(12)
    val RDATA_ERROR_CONVERT_LONG_STRING = define(13)
    val RDATA_ERROR_CONVERT_SHORT_STRING = define(14)
    val RDATA_ERROR_UNSUPPORTED_S_EXPRESSION = define(15)
    val RDATA_ERROR_UNSUPPORTED_STORAGE_CLASS = define(16)
    inline def getName(inline value: rdata_error_e): Option[String] =
      inline value match
        case RDATA_OK => Some("RDATA_OK")
        case RDATA_ERROR_OPEN => Some("RDATA_ERROR_OPEN")
        case RDATA_ERROR_SEEK => Some("RDATA_ERROR_SEEK")
        case RDATA_ERROR_READ => Some("RDATA_ERROR_READ")
        case RDATA_ERROR_MALLOC => Some("RDATA_ERROR_MALLOC")
        case RDATA_ERROR_USER_ABORT => Some("RDATA_ERROR_USER_ABORT")
        case RDATA_ERROR_PARSE => Some("RDATA_ERROR_PARSE")
        case RDATA_ERROR_WRITE => Some("RDATA_ERROR_WRITE")
        case RDATA_ERROR_FACTOR => Some("RDATA_ERROR_FACTOR")
        case RDATA_ERROR_UNSUPPORTED_COMPRESSION => Some("RDATA_ERROR_UNSUPPORTED_COMPRESSION")
        case RDATA_ERROR_UNSUPPORTED_CHARSET => Some("RDATA_ERROR_UNSUPPORTED_CHARSET")
        case RDATA_ERROR_CONVERT => Some("RDATA_ERROR_CONVERT")
        case RDATA_ERROR_CONVERT_BAD_STRING => Some("RDATA_ERROR_CONVERT_BAD_STRING")
        case RDATA_ERROR_CONVERT_LONG_STRING => Some("RDATA_ERROR_CONVERT_LONG_STRING")
        case RDATA_ERROR_CONVERT_SHORT_STRING => Some("RDATA_ERROR_CONVERT_SHORT_STRING")
        case RDATA_ERROR_UNSUPPORTED_S_EXPRESSION => Some("RDATA_ERROR_UNSUPPORTED_S_EXPRESSION")
        case RDATA_ERROR_UNSUPPORTED_STORAGE_CLASS => Some("RDATA_ERROR_UNSUPPORTED_STORAGE_CLASS")
        case _ => None
    extension (a: rdata_error_e)
      inline def &(b: rdata_error_e): rdata_error_e = a & b
      inline def |(b: rdata_error_e): rdata_error_e = a | b
      inline def is(b: rdata_error_e): Boolean = (a & b) == b

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_file_format_e = CUnsignedInt
  object rdata_file_format_e extends CEnumU[rdata_file_format_e]:
    given _tag: Tag[rdata_file_format_e] = Tag.UInt
    inline def define(inline a: Long): rdata_file_format_e = a.toUInt
    val RDATA_WORKSPACE = define(0)
    val RDATA_SINGLE_OBJECT = define(1)
    inline def getName(inline value: rdata_file_format_e): Option[String] =
      inline value match
        case RDATA_WORKSPACE => Some("RDATA_WORKSPACE")
        case RDATA_SINGLE_OBJECT => Some("RDATA_SINGLE_OBJECT")
        case _ => None
    extension (a: rdata_file_format_e)
      inline def &(b: rdata_file_format_e): rdata_file_format_e = a & b
      inline def |(b: rdata_file_format_e): rdata_file_format_e = a | b
      inline def is(b: rdata_file_format_e): Boolean = (a & b) == b

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_io_flags_e = CUnsignedInt
  object rdata_io_flags_e extends CEnumU[rdata_io_flags_e]:
    given _tag: Tag[rdata_io_flags_e] = Tag.UInt
    inline def define(inline a: Long): rdata_io_flags_e = a.toUInt
    val RDATA_SEEK_SET = define(0)
    val RDATA_SEEK_CUR = define(1)
    val RDATA_SEEK_END = define(2)
    inline def getName(inline value: rdata_io_flags_e): Option[String] =
      inline value match
        case RDATA_SEEK_SET => Some("RDATA_SEEK_SET")
        case RDATA_SEEK_CUR => Some("RDATA_SEEK_CUR")
        case RDATA_SEEK_END => Some("RDATA_SEEK_END")
        case _ => None
    extension (a: rdata_io_flags_e)
      inline def &(b: rdata_io_flags_e): rdata_io_flags_e = a & b
      inline def |(b: rdata_io_flags_e): rdata_io_flags_e = a | b
      inline def is(b: rdata_io_flags_e): Boolean = (a & b) == b

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_type_e = CUnsignedInt
  object rdata_type_e extends CEnumU[rdata_type_e]:
    given _tag: Tag[rdata_type_e] = Tag.UInt
    inline def define(inline a: Long): rdata_type_e = a.toUInt
    val RDATA_TYPE_STRING = define(0)
    val RDATA_TYPE_INT32 = define(1)
    val RDATA_TYPE_REAL = define(2)
    val RDATA_TYPE_LOGICAL = define(3)
    val RDATA_TYPE_TIMESTAMP = define(4)
    val RDATA_TYPE_DATE = define(5)
    inline def getName(inline value: rdata_type_e): Option[String] =
      inline value match
        case RDATA_TYPE_STRING => Some("RDATA_TYPE_STRING")
        case RDATA_TYPE_INT32 => Some("RDATA_TYPE_INT32")
        case RDATA_TYPE_REAL => Some("RDATA_TYPE_REAL")
        case RDATA_TYPE_LOGICAL => Some("RDATA_TYPE_LOGICAL")
        case RDATA_TYPE_TIMESTAMP => Some("RDATA_TYPE_TIMESTAMP")
        case RDATA_TYPE_DATE => Some("RDATA_TYPE_DATE")
        case _ => None
    extension (a: rdata_type_e)
      inline def &(b: rdata_type_e): rdata_type_e = a & b
      inline def |(b: rdata_type_e): rdata_type_e = a | b
      inline def is(b: rdata_type_e): Boolean = (a & b) == b

object aliases:
  import _root_.librdata.enumerations.*
  import _root_.librdata.aliases.*
  import _root_.librdata.structs.*

  type int32_t = scala.scalanative.unsafe.CInt
  object int32_t: 
    val _tag: Tag[int32_t] = summon[Tag[scala.scalanative.unsafe.CInt]]
    inline def apply(inline o: scala.scalanative.unsafe.CInt): int32_t = o
    extension (v: int32_t)
      inline def value: scala.scalanative.unsafe.CInt = v

  type off_t = posix.unistd.off_t
  object off_t: 
    val _tag: Tag[off_t] = summon[Tag[posix.unistd.off_t]]
    inline def apply(inline o: posix.unistd.off_t): off_t = o
    extension (v: off_t)
      inline def value: posix.unistd.off_t = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_close_handler = CFuncPtr1[Ptr[Byte], CInt]
  object rdata_close_handler: 
    given _tag: Tag[rdata_close_handler] = Tag.materializeCFuncPtr1[Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr1[Ptr[Byte], CInt]): rdata_close_handler = o
    extension (v: rdata_close_handler)
      inline def value: CFuncPtr1[Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_column_handler = CFuncPtr5[CString, rdata_type_t, Ptr[Byte], CLongInt, Ptr[Byte], CInt]
  object rdata_column_handler: 
    given _tag: Tag[rdata_column_handler] = Tag.materializeCFuncPtr5[CString, rdata_type_t, Ptr[Byte], CLongInt, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr5[CString, rdata_type_t, Ptr[Byte], CLongInt, Ptr[Byte], CInt]): rdata_column_handler = o
    extension (v: rdata_column_handler)
      inline def value: CFuncPtr5[CString, rdata_type_t, Ptr[Byte], CLongInt, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_column_name_handler = CFuncPtr3[CString, CInt, Ptr[Byte], CInt]
  object rdata_column_name_handler: 
    given _tag: Tag[rdata_column_name_handler] = Tag.materializeCFuncPtr3[CString, CInt, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr3[CString, CInt, Ptr[Byte], CInt]): rdata_column_name_handler = o
    extension (v: rdata_column_name_handler)
      inline def value: CFuncPtr3[CString, CInt, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_data_writer = CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]
  object rdata_data_writer: 
    given _tag: Tag[rdata_data_writer] = Tag.materializeCFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]
    inline def apply(inline o: CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]): rdata_data_writer = o
    extension (v: rdata_data_writer)
      inline def value: CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_error_handler = CFuncPtr2[CString, Ptr[Byte], Unit]
  object rdata_error_handler: 
    given _tag: Tag[rdata_error_handler] = Tag.materializeCFuncPtr2[CString, Ptr[Byte], Unit]
    inline def apply(inline o: CFuncPtr2[CString, Ptr[Byte], Unit]): rdata_error_handler = o
    extension (v: rdata_error_handler)
      inline def value: CFuncPtr2[CString, Ptr[Byte], Unit] = v

  /**
   * [bindgen] header: rdata.h
  */
  type rdata_error_t = rdata_error_e
  object rdata_error_t: 
    given _tag: Tag[rdata_error_t] = rdata_error_e._tag
    inline def apply(inline o: rdata_error_e): rdata_error_t = o
    extension (v: rdata_error_t)
      inline def value: rdata_error_e = v

  /**
   * [bindgen] header: rdata.h
  */
  type rdata_file_format_t = rdata_file_format_e
  object rdata_file_format_t: 
    given _tag: Tag[rdata_file_format_t] = rdata_file_format_e._tag
    inline def apply(inline o: rdata_file_format_e): rdata_file_format_t = o
    extension (v: rdata_file_format_t)
      inline def value: rdata_file_format_e = v

  /**
   * [bindgen] header: rdata.h
  */
  type rdata_io_flags_t = rdata_io_flags_e
  object rdata_io_flags_t: 
    given _tag: Tag[rdata_io_flags_t] = rdata_io_flags_e._tag
    inline def apply(inline o: rdata_io_flags_e): rdata_io_flags_t = o
    extension (v: rdata_io_flags_t)
      inline def value: rdata_io_flags_e = v

  /**
   * [bindgen] header: rdata.h
  */
  type rdata_off_t = off_t
  object rdata_off_t: 
    given _tag: Tag[rdata_off_t] = off_t._tag
    inline def apply(inline o: off_t): rdata_off_t = o
    extension (v: rdata_off_t)
      inline def value: off_t = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_open_handler = CFuncPtr2[CString, Ptr[Byte], CInt]
  object rdata_open_handler: 
    given _tag: Tag[rdata_open_handler] = Tag.materializeCFuncPtr2[CString, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr2[CString, Ptr[Byte], CInt]): rdata_open_handler = o
    extension (v: rdata_open_handler)
      inline def value: CFuncPtr2[CString, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_progress_handler = CFuncPtr2[Double, Ptr[Byte], CInt]
  object rdata_progress_handler: 
    given _tag: Tag[rdata_progress_handler] = Tag.materializeCFuncPtr2[Double, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr2[Double, Ptr[Byte], CInt]): rdata_progress_handler = o
    extension (v: rdata_progress_handler)
      inline def value: CFuncPtr2[Double, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_read_handler = CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]
  object rdata_read_handler: 
    given _tag: Tag[rdata_read_handler] = Tag.materializeCFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]
    inline def apply(inline o: CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t]): rdata_read_handler = o
    extension (v: rdata_read_handler)
      inline def value: CFuncPtr3[Ptr[Byte], size_t, Ptr[Byte], ssize_t] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_seek_handler = CFuncPtr3[rdata_off_t, rdata_io_flags_t, Ptr[Byte], rdata_off_t]
  object rdata_seek_handler: 
    given _tag: Tag[rdata_seek_handler] = Tag.materializeCFuncPtr3[rdata_off_t, rdata_io_flags_t, Ptr[Byte], rdata_off_t]
    inline def apply(inline o: CFuncPtr3[rdata_off_t, rdata_io_flags_t, Ptr[Byte], rdata_off_t]): rdata_seek_handler = o
    extension (v: rdata_seek_handler)
      inline def value: CFuncPtr3[rdata_off_t, rdata_io_flags_t, Ptr[Byte], rdata_off_t] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_table_handler = CFuncPtr2[CString, Ptr[Byte], CInt]
  object rdata_table_handler: 
    given _tag: Tag[rdata_table_handler] = Tag.materializeCFuncPtr2[CString, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr2[CString, Ptr[Byte], CInt]): rdata_table_handler = o
    extension (v: rdata_table_handler)
      inline def value: CFuncPtr2[CString, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_text_value_handler = CFuncPtr3[CString, CInt, Ptr[Byte], CInt]
  object rdata_text_value_handler: 
    given _tag: Tag[rdata_text_value_handler] = Tag.materializeCFuncPtr3[CString, CInt, Ptr[Byte], CInt]
    inline def apply(inline o: CFuncPtr3[CString, CInt, Ptr[Byte], CInt]): rdata_text_value_handler = o
    extension (v: rdata_text_value_handler)
      inline def value: CFuncPtr3[CString, CInt, Ptr[Byte], CInt] = v

  /**
   * [bindgen] header: rdata.h
  */
  type rdata_type_t = rdata_type_e
  object rdata_type_t: 
    given _tag: Tag[rdata_type_t] = rdata_type_e._tag
    inline def apply(inline o: rdata_type_e): rdata_type_t = o
    extension (v: rdata_type_t)
      inline def value: rdata_type_e = v

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_update_handler = CFuncPtr4[CLongInt, rdata_progress_handler, Ptr[Byte], Ptr[Byte], rdata_error_t]
  object rdata_update_handler: 
    given _tag: Tag[rdata_update_handler] = Tag.materializeCFuncPtr4[CLongInt, rdata_progress_handler, Ptr[Byte], Ptr[Byte], rdata_error_t]
    inline def apply(inline o: CFuncPtr4[CLongInt, rdata_progress_handler, Ptr[Byte], Ptr[Byte], rdata_error_t]): rdata_update_handler = o
    extension (v: rdata_update_handler)
      inline def value: CFuncPtr4[CLongInt, rdata_progress_handler, Ptr[Byte], Ptr[Byte], rdata_error_t] = v

  type size_t = libc.stddef.size_t
  object size_t: 
    val _tag: Tag[size_t] = summon[Tag[libc.stddef.size_t]]
    inline def apply(inline o: libc.stddef.size_t): size_t = o
    extension (v: size_t)
      inline def value: libc.stddef.size_t = v

  type ssize_t = posix.sys.types.ssize_t
  object ssize_t: 
    val _tag: Tag[ssize_t] = summon[Tag[posix.sys.types.ssize_t]]
    inline def apply(inline o: posix.sys.types.ssize_t): ssize_t = o
    extension (v: ssize_t)
      inline def value: posix.sys.types.ssize_t = v

  type time_t = posix.sys.types.time_t
  object time_t: 
    val _tag: Tag[time_t] = summon[Tag[posix.sys.types.time_t]]
    inline def apply(inline o: posix.sys.types.time_t): time_t = o
    extension (v: time_t)
      inline def value: posix.sys.types.time_t = v

  type tm = posix.time.tm
  object tm: 
    val _tag: Tag[tm] = summon[Tag[posix.time.tm]]
    inline def apply(inline o: posix.time.tm): tm = o
    extension (v: tm)
      inline def value: posix.time.tm = v

object structs:
  import _root_.librdata.enumerations.*
  import _root_.librdata.aliases.*
  import _root_.librdata.structs.*

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_column_s = CStruct6[rdata_type_t, CInt, CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], int32_t, Ptr[CString]]
  object rdata_column_s:
    given _tag: Tag[rdata_column_s] = Tag.materializeCStruct6Tag[rdata_type_t, CInt, CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], int32_t, Ptr[CString]]
    def apply()(using Zone): Ptr[rdata_column_s] = scala.scalanative.unsafe.alloc[rdata_column_s](1)
    def apply(`type` : rdata_type_t, index : CInt, name : CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], label : CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], factor_count : int32_t, factor : Ptr[CString])(using Zone): Ptr[rdata_column_s] = 
      val ____ptr = apply()
      (!____ptr).`type` = `type`
      (!____ptr).index = index
      (!____ptr).name = name
      (!____ptr).label = label
      (!____ptr).factor_count = factor_count
      (!____ptr).factor = factor
      ____ptr
    extension (struct: rdata_column_s)
      def `type` : rdata_type_t = struct._1
      def type_=(value: rdata_type_t): Unit = !struct.at1 = value
      def index : CInt = struct._2
      def index_=(value: CInt): Unit = !struct.at2 = value
      def name : CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]] = struct._3
      def name_=(value: CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]]): Unit = !struct.at3 = value
      def label : CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]] = struct._4
      def label_=(value: CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]]): Unit = !struct.at4 = value
      def factor_count : int32_t = struct._5
      def factor_count_=(value: int32_t): Unit = !struct.at5 = value
      def factor : Ptr[CString] = struct._6
      def factor_=(value: Ptr[CString]): Unit = !struct.at6 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_column_t = CStruct6[rdata_type_t, CInt, CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], int32_t, Ptr[CString]]
  object rdata_column_t:
    given _tag: Tag[rdata_column_t] = Tag.materializeCStruct6Tag[rdata_type_t, CInt, CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], int32_t, Ptr[CString]]
    def apply()(using Zone): Ptr[rdata_column_t] = scala.scalanative.unsafe.alloc[rdata_column_t](1)
    def apply(`type` : rdata_type_t, index : CInt, name : CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]], label : CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]], factor_count : int32_t, factor : Ptr[CString])(using Zone): Ptr[rdata_column_t] = 
      val ____ptr = apply()
      (!____ptr).`type` = `type`
      (!____ptr).index = index
      (!____ptr).name = name
      (!____ptr).label = label
      (!____ptr).factor_count = factor_count
      (!____ptr).factor = factor
      ____ptr
    extension (struct: rdata_column_t)
      def `type` : rdata_type_t = struct._1
      def type_=(value: rdata_type_t): Unit = !struct.at1 = value
      def index : CInt = struct._2
      def index_=(value: CInt): Unit = !struct.at2 = value
      def name : CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]] = struct._3
      def name_=(value: CArray[CChar, Nat.Digit3[Nat._2, Nat._5, Nat._6]]): Unit = !struct.at3 = value
      def label : CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]] = struct._4
      def label_=(value: CArray[CChar, Nat.Digit4[Nat._1, Nat._0, Nat._2, Nat._4]]): Unit = !struct.at4 = value
      def factor_count : int32_t = struct._5
      def factor_count_=(value: int32_t): Unit = !struct.at5 = value
      def factor : Ptr[CString] = struct._6
      def factor_=(value: Ptr[CString]): Unit = !struct.at6 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_io_s = CStruct7[rdata_open_handler, rdata_close_handler, rdata_seek_handler, rdata_read_handler, rdata_update_handler, Ptr[Byte], CInt]
  object rdata_io_s:
    given _tag: Tag[rdata_io_s] = Tag.materializeCStruct7Tag[rdata_open_handler, rdata_close_handler, rdata_seek_handler, rdata_read_handler, rdata_update_handler, Ptr[Byte], CInt]
    def apply()(using Zone): Ptr[rdata_io_s] = scala.scalanative.unsafe.alloc[rdata_io_s](1)
    def apply(open : rdata_open_handler, close : rdata_close_handler, seek : rdata_seek_handler, read : rdata_read_handler, update : rdata_update_handler, io_ctx : Ptr[Byte], external_io : CInt)(using Zone): Ptr[rdata_io_s] = 
      val ____ptr = apply()
      (!____ptr).open = open
      (!____ptr).close = close
      (!____ptr).seek = seek
      (!____ptr).read = read
      (!____ptr).update = update
      (!____ptr).io_ctx = io_ctx
      (!____ptr).external_io = external_io
      ____ptr
    extension (struct: rdata_io_s)
      def open : rdata_open_handler = struct._1
      def open_=(value: rdata_open_handler): Unit = !struct.at1 = value
      def close : rdata_close_handler = struct._2
      def close_=(value: rdata_close_handler): Unit = !struct.at2 = value
      def seek : rdata_seek_handler = struct._3
      def seek_=(value: rdata_seek_handler): Unit = !struct.at3 = value
      def read : rdata_read_handler = struct._4
      def read_=(value: rdata_read_handler): Unit = !struct.at4 = value
      def update : rdata_update_handler = struct._5
      def update_=(value: rdata_update_handler): Unit = !struct.at5 = value
      def io_ctx : Ptr[Byte] = struct._6
      def io_ctx_=(value: Ptr[Byte]): Unit = !struct.at6 = value
      def external_io : CInt = struct._7
      def external_io_=(value: CInt): Unit = !struct.at7 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_io_t = CStruct7[rdata_open_handler, rdata_close_handler, rdata_seek_handler, rdata_read_handler, rdata_update_handler, Ptr[Byte], CInt]
  object rdata_io_t:
    given _tag: Tag[rdata_io_t] = Tag.materializeCStruct7Tag[rdata_open_handler, rdata_close_handler, rdata_seek_handler, rdata_read_handler, rdata_update_handler, Ptr[Byte], CInt]
    def apply()(using Zone): Ptr[rdata_io_t] = scala.scalanative.unsafe.alloc[rdata_io_t](1)
    def apply(open : rdata_open_handler, close : rdata_close_handler, seek : rdata_seek_handler, read : rdata_read_handler, update : rdata_update_handler, io_ctx : Ptr[Byte], external_io : CInt)(using Zone): Ptr[rdata_io_t] = 
      val ____ptr = apply()
      (!____ptr).open = open
      (!____ptr).close = close
      (!____ptr).seek = seek
      (!____ptr).read = read
      (!____ptr).update = update
      (!____ptr).io_ctx = io_ctx
      (!____ptr).external_io = external_io
      ____ptr
    extension (struct: rdata_io_t)
      def open : rdata_open_handler = struct._1
      def open_=(value: rdata_open_handler): Unit = !struct.at1 = value
      def close : rdata_close_handler = struct._2
      def close_=(value: rdata_close_handler): Unit = !struct.at2 = value
      def seek : rdata_seek_handler = struct._3
      def seek_=(value: rdata_seek_handler): Unit = !struct.at3 = value
      def read : rdata_read_handler = struct._4
      def read_=(value: rdata_read_handler): Unit = !struct.at4 = value
      def update : rdata_update_handler = struct._5
      def update_=(value: rdata_update_handler): Unit = !struct.at5 = value
      def io_ctx : Ptr[Byte] = struct._6
      def io_ctx_=(value: Ptr[Byte]): Unit = !struct.at6 = value
      def external_io : CInt = struct._7
      def external_io_=(value: CInt): Unit = !struct.at7 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_parser_s = CStruct10[rdata_table_handler, rdata_column_handler, rdata_column_name_handler, rdata_column_name_handler, rdata_text_value_handler, rdata_text_value_handler, rdata_column_handler, rdata_text_value_handler, rdata_error_handler, Ptr[rdata_io_t]]
  object rdata_parser_s:
    given _tag: Tag[rdata_parser_s] = Tag.materializeCStruct10Tag[rdata_table_handler, rdata_column_handler, rdata_column_name_handler, rdata_column_name_handler, rdata_text_value_handler, rdata_text_value_handler, rdata_column_handler, rdata_text_value_handler, rdata_error_handler, Ptr[rdata_io_t]]
    def apply()(using Zone): Ptr[rdata_parser_s] = scala.scalanative.unsafe.alloc[rdata_parser_s](1)
    def apply(table_handler : rdata_table_handler, column_handler : rdata_column_handler, column_name_handler : rdata_column_name_handler, row_name_handler : rdata_column_name_handler, text_value_handler : rdata_text_value_handler, value_label_handler : rdata_text_value_handler, dim_handler : rdata_column_handler, dim_name_handler : rdata_text_value_handler, error_handler : rdata_error_handler, io : Ptr[rdata_io_t])(using Zone): Ptr[rdata_parser_s] = 
      val ____ptr = apply()
      (!____ptr).table_handler = table_handler
      (!____ptr).column_handler = column_handler
      (!____ptr).column_name_handler = column_name_handler
      (!____ptr).row_name_handler = row_name_handler
      (!____ptr).text_value_handler = text_value_handler
      (!____ptr).value_label_handler = value_label_handler
      (!____ptr).dim_handler = dim_handler
      (!____ptr).dim_name_handler = dim_name_handler
      (!____ptr).error_handler = error_handler
      (!____ptr).io = io
      ____ptr
    extension (struct: rdata_parser_s)
      def table_handler : rdata_table_handler = struct._1
      def table_handler_=(value: rdata_table_handler): Unit = !struct.at1 = value
      def column_handler : rdata_column_handler = struct._2
      def column_handler_=(value: rdata_column_handler): Unit = !struct.at2 = value
      def column_name_handler : rdata_column_name_handler = struct._3
      def column_name_handler_=(value: rdata_column_name_handler): Unit = !struct.at3 = value
      def row_name_handler : rdata_column_name_handler = struct._4
      def row_name_handler_=(value: rdata_column_name_handler): Unit = !struct.at4 = value
      def text_value_handler : rdata_text_value_handler = struct._5
      def text_value_handler_=(value: rdata_text_value_handler): Unit = !struct.at5 = value
      def value_label_handler : rdata_text_value_handler = struct._6
      def value_label_handler_=(value: rdata_text_value_handler): Unit = !struct.at6 = value
      def dim_handler : rdata_column_handler = struct._7
      def dim_handler_=(value: rdata_column_handler): Unit = !struct.at7 = value
      def dim_name_handler : rdata_text_value_handler = struct._8
      def dim_name_handler_=(value: rdata_text_value_handler): Unit = !struct.at8 = value
      def error_handler : rdata_error_handler = struct._9
      def error_handler_=(value: rdata_error_handler): Unit = !struct.at9 = value
      def io : Ptr[rdata_io_t] = struct._10
      def io_=(value: Ptr[rdata_io_t]): Unit = !struct.at10 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_parser_t = CStruct10[rdata_table_handler, rdata_column_handler, rdata_column_name_handler, rdata_column_name_handler, rdata_text_value_handler, rdata_text_value_handler, rdata_column_handler, rdata_text_value_handler, rdata_error_handler, Ptr[rdata_io_t]]
  object rdata_parser_t:
    given _tag: Tag[rdata_parser_t] = Tag.materializeCStruct10Tag[rdata_table_handler, rdata_column_handler, rdata_column_name_handler, rdata_column_name_handler, rdata_text_value_handler, rdata_text_value_handler, rdata_column_handler, rdata_text_value_handler, rdata_error_handler, Ptr[rdata_io_t]]
    def apply()(using Zone): Ptr[rdata_parser_t] = scala.scalanative.unsafe.alloc[rdata_parser_t](1)
    def apply(table_handler : rdata_table_handler, column_handler : rdata_column_handler, column_name_handler : rdata_column_name_handler, row_name_handler : rdata_column_name_handler, text_value_handler : rdata_text_value_handler, value_label_handler : rdata_text_value_handler, dim_handler : rdata_column_handler, dim_name_handler : rdata_text_value_handler, error_handler : rdata_error_handler, io : Ptr[rdata_io_t])(using Zone): Ptr[rdata_parser_t] = 
      val ____ptr = apply()
      (!____ptr).table_handler = table_handler
      (!____ptr).column_handler = column_handler
      (!____ptr).column_name_handler = column_name_handler
      (!____ptr).row_name_handler = row_name_handler
      (!____ptr).text_value_handler = text_value_handler
      (!____ptr).value_label_handler = value_label_handler
      (!____ptr).dim_handler = dim_handler
      (!____ptr).dim_name_handler = dim_name_handler
      (!____ptr).error_handler = error_handler
      (!____ptr).io = io
      ____ptr
    extension (struct: rdata_parser_t)
      def table_handler : rdata_table_handler = struct._1
      def table_handler_=(value: rdata_table_handler): Unit = !struct.at1 = value
      def column_handler : rdata_column_handler = struct._2
      def column_handler_=(value: rdata_column_handler): Unit = !struct.at2 = value
      def column_name_handler : rdata_column_name_handler = struct._3
      def column_name_handler_=(value: rdata_column_name_handler): Unit = !struct.at3 = value
      def row_name_handler : rdata_column_name_handler = struct._4
      def row_name_handler_=(value: rdata_column_name_handler): Unit = !struct.at4 = value
      def text_value_handler : rdata_text_value_handler = struct._5
      def text_value_handler_=(value: rdata_text_value_handler): Unit = !struct.at5 = value
      def value_label_handler : rdata_text_value_handler = struct._6
      def value_label_handler_=(value: rdata_text_value_handler): Unit = !struct.at6 = value
      def dim_handler : rdata_column_handler = struct._7
      def dim_handler_=(value: rdata_column_handler): Unit = !struct.at7 = value
      def dim_name_handler : rdata_text_value_handler = struct._8
      def dim_name_handler_=(value: rdata_text_value_handler): Unit = !struct.at8 = value
      def error_handler : rdata_error_handler = struct._9
      def error_handler_=(value: rdata_error_handler): Unit = !struct.at9 = value
      def io : Ptr[rdata_io_t] = struct._10
      def io_=(value: Ptr[rdata_io_t]): Unit = !struct.at10 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_writer_s = CStruct10[rdata_file_format_t, rdata_data_writer, size_t, rdata_error_handler, Ptr[Byte], Ptr[Byte], CInt, Ptr[Ptr[rdata_column_t]], int32_t, int32_t]
  object rdata_writer_s:
    given _tag: Tag[rdata_writer_s] = Tag.materializeCStruct10Tag[rdata_file_format_t, rdata_data_writer, size_t, rdata_error_handler, Ptr[Byte], Ptr[Byte], CInt, Ptr[Ptr[rdata_column_t]], int32_t, int32_t]
    def apply()(using Zone): Ptr[rdata_writer_s] = scala.scalanative.unsafe.alloc[rdata_writer_s](1)
    def apply(file_format : rdata_file_format_t, data_writer : rdata_data_writer, bytes_written : size_t, error_handler : rdata_error_handler, user_ctx : Ptr[Byte], atom_table : Ptr[Byte], bswap : CInt, columns : Ptr[Ptr[rdata_column_t]], columns_count : int32_t, columns_capacity : int32_t)(using Zone): Ptr[rdata_writer_s] = 
      val ____ptr = apply()
      (!____ptr).file_format = file_format
      (!____ptr).data_writer = data_writer
      (!____ptr).bytes_written = bytes_written
      (!____ptr).error_handler = error_handler
      (!____ptr).user_ctx = user_ctx
      (!____ptr).atom_table = atom_table
      (!____ptr).bswap = bswap
      (!____ptr).columns = columns
      (!____ptr).columns_count = columns_count
      (!____ptr).columns_capacity = columns_capacity
      ____ptr
    extension (struct: rdata_writer_s)
      def file_format : rdata_file_format_t = struct._1
      def file_format_=(value: rdata_file_format_t): Unit = !struct.at1 = value
      def data_writer : rdata_data_writer = struct._2
      def data_writer_=(value: rdata_data_writer): Unit = !struct.at2 = value
      def bytes_written : size_t = struct._3
      def bytes_written_=(value: size_t): Unit = !struct.at3 = value
      def error_handler : rdata_error_handler = struct._4
      def error_handler_=(value: rdata_error_handler): Unit = !struct.at4 = value
      def user_ctx : Ptr[Byte] = struct._5
      def user_ctx_=(value: Ptr[Byte]): Unit = !struct.at5 = value
      def atom_table : Ptr[Byte] = struct._6
      def atom_table_=(value: Ptr[Byte]): Unit = !struct.at6 = value
      def bswap : CInt = struct._7
      def bswap_=(value: CInt): Unit = !struct.at7 = value
      def columns : Ptr[Ptr[rdata_column_t]] = struct._8
      def columns_=(value: Ptr[Ptr[rdata_column_t]]): Unit = !struct.at8 = value
      def columns_count : int32_t = struct._9
      def columns_count_=(value: int32_t): Unit = !struct.at9 = value
      def columns_capacity : int32_t = struct._10
      def columns_capacity_=(value: int32_t): Unit = !struct.at10 = value

  /**
   * [bindgen] header: rdata.h
  */
  opaque type rdata_writer_t = CStruct10[rdata_file_format_t, rdata_data_writer, size_t, rdata_error_handler, Ptr[Byte], Ptr[Byte], CInt, Ptr[Ptr[rdata_column_t]], int32_t, int32_t]
  object rdata_writer_t:
    given _tag: Tag[rdata_writer_t] = Tag.materializeCStruct10Tag[rdata_file_format_t, rdata_data_writer, size_t, rdata_error_handler, Ptr[Byte], Ptr[Byte], CInt, Ptr[Ptr[rdata_column_t]], int32_t, int32_t]
    def apply()(using Zone): Ptr[rdata_writer_t] = scala.scalanative.unsafe.alloc[rdata_writer_t](1)
    def apply(file_format : rdata_file_format_t, data_writer : rdata_data_writer, bytes_written : size_t, error_handler : rdata_error_handler, user_ctx : Ptr[Byte], atom_table : Ptr[Byte], bswap : CInt, columns : Ptr[Ptr[rdata_column_t]], columns_count : int32_t, columns_capacity : int32_t)(using Zone): Ptr[rdata_writer_t] = 
      val ____ptr = apply()
      (!____ptr).file_format = file_format
      (!____ptr).data_writer = data_writer
      (!____ptr).bytes_written = bytes_written
      (!____ptr).error_handler = error_handler
      (!____ptr).user_ctx = user_ctx
      (!____ptr).atom_table = atom_table
      (!____ptr).bswap = bswap
      (!____ptr).columns = columns
      (!____ptr).columns_count = columns_count
      (!____ptr).columns_capacity = columns_capacity
      ____ptr
    extension (struct: rdata_writer_t)
      def file_format : rdata_file_format_t = struct._1
      def file_format_=(value: rdata_file_format_t): Unit = !struct.at1 = value
      def data_writer : rdata_data_writer = struct._2
      def data_writer_=(value: rdata_data_writer): Unit = !struct.at2 = value
      def bytes_written : size_t = struct._3
      def bytes_written_=(value: size_t): Unit = !struct.at3 = value
      def error_handler : rdata_error_handler = struct._4
      def error_handler_=(value: rdata_error_handler): Unit = !struct.at4 = value
      def user_ctx : Ptr[Byte] = struct._5
      def user_ctx_=(value: Ptr[Byte]): Unit = !struct.at5 = value
      def atom_table : Ptr[Byte] = struct._6
      def atom_table_=(value: Ptr[Byte]): Unit = !struct.at6 = value
      def bswap : CInt = struct._7
      def bswap_=(value: CInt): Unit = !struct.at7 = value
      def columns : Ptr[Ptr[rdata_column_t]] = struct._8
      def columns_=(value: Ptr[Ptr[rdata_column_t]]): Unit = !struct.at8 = value
      def columns_count : int32_t = struct._9
      def columns_count_=(value: int32_t): Unit = !struct.at9 = value
      def columns_capacity : int32_t = struct._10
      def columns_capacity_=(value: int32_t): Unit = !struct.at10 = value


@extern
private[librdata] object extern_functions:
  import _root_.librdata.enumerations.*
  import _root_.librdata.aliases.*
  import _root_.librdata.structs.*

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_add_column(writer : Ptr[rdata_writer_t], name : CString, `type` : rdata_type_t): Ptr[rdata_column_t] = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_date_value(writer : Ptr[rdata_writer_t], value : Ptr[tm]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_int32_value(writer : Ptr[rdata_writer_t], value : int32_t): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_logical_value(writer : Ptr[rdata_writer_t], value : CInt): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_real_value(writer : Ptr[rdata_writer_t], value : Double): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_string_value(writer : Ptr[rdata_writer_t], value : CString): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_append_timestamp_value(writer : Ptr[rdata_writer_t], value : time_t): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_begin_column(writer : Ptr[rdata_writer_t], column : Ptr[rdata_column_t], row_count : int32_t): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_begin_file(writer : Ptr[rdata_writer_t], ctx : Ptr[Byte]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_begin_table(writer : Ptr[rdata_writer_t], variable_name : CString): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_column_add_factor(column : Ptr[rdata_column_t], factor : CString): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_column_set_label(column : Ptr[rdata_column_t], label : CString): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_end_column(writer : Ptr[rdata_writer_t], column : Ptr[rdata_column_t]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_end_file(writer : Ptr[rdata_writer_t]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_end_table(writer : Ptr[rdata_writer_t], row_count : int32_t, datalabel : CString): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_error_message(error_code : rdata_error_t): CString = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_get_column(writer : Ptr[rdata_writer_t], j : int32_t): Ptr[rdata_column_t] = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_parse(parser : Ptr[rdata_parser_t], filename : CString, user_ctx : Ptr[Byte]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_parser_free(parser : Ptr[rdata_parser_t]): Unit = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_parser_init(): Ptr[rdata_parser_t] = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_close_handler(parser : Ptr[rdata_parser_t], close_handler : rdata_close_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_column_handler(parser : Ptr[rdata_parser_t], column_handler : rdata_column_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_column_name_handler(parser : Ptr[rdata_parser_t], column_name_handler : rdata_column_name_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_dim_handler(parser : Ptr[rdata_parser_t], dim_handler : rdata_column_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_dim_name_handler(parser : Ptr[rdata_parser_t], dim_name_handler : rdata_text_value_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_error_handler(parser : Ptr[rdata_parser_t], error_handler : rdata_error_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_io_ctx(parser : Ptr[rdata_parser_t], io_ctx : Ptr[Byte]): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_open_handler(parser : Ptr[rdata_parser_t], open_handler : rdata_open_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_read_handler(parser : Ptr[rdata_parser_t], read_handler : rdata_read_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_row_name_handler(parser : Ptr[rdata_parser_t], row_name_handler : rdata_column_name_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_seek_handler(parser : Ptr[rdata_parser_t], seek_handler : rdata_seek_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_table_handler(parser : Ptr[rdata_parser_t], table_handler : rdata_table_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_text_value_handler(parser : Ptr[rdata_parser_t], text_value_handler : rdata_text_value_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_update_handler(parser : Ptr[rdata_parser_t], update_handler : rdata_update_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_set_value_label_handler(parser : Ptr[rdata_parser_t], value_label_handler : rdata_text_value_handler): rdata_error_t = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_writer_free(writer : Ptr[rdata_writer_t]): Unit = extern

  /**
   * [bindgen] header: rdata.h
  */
  def rdata_writer_init(write_callback : rdata_data_writer, format : rdata_file_format_t): Ptr[rdata_writer_t] = extern


object functions:
  import _root_.librdata.enumerations.*
  import _root_.librdata.aliases.*
  import _root_.librdata.structs.*

  import extern_functions.*
  export extern_functions.*

object types:
  export _root_.librdata.structs.*
  export _root_.librdata.aliases.*
  export _root_.librdata.enumerations.*

object all:
  export _root_.librdata.enumerations.rdata_error_e
  export _root_.librdata.enumerations.rdata_file_format_e
  export _root_.librdata.enumerations.rdata_io_flags_e
  export _root_.librdata.enumerations.rdata_type_e
  export _root_.librdata.aliases.int32_t
  export _root_.librdata.aliases.off_t
  export _root_.librdata.aliases.rdata_close_handler
  export _root_.librdata.aliases.rdata_column_handler
  export _root_.librdata.aliases.rdata_column_name_handler
  export _root_.librdata.aliases.rdata_data_writer
  export _root_.librdata.aliases.rdata_error_handler
  export _root_.librdata.aliases.rdata_error_t
  export _root_.librdata.aliases.rdata_file_format_t
  export _root_.librdata.aliases.rdata_io_flags_t
  export _root_.librdata.aliases.rdata_off_t
  export _root_.librdata.aliases.rdata_open_handler
  export _root_.librdata.aliases.rdata_progress_handler
  export _root_.librdata.aliases.rdata_read_handler
  export _root_.librdata.aliases.rdata_seek_handler
  export _root_.librdata.aliases.rdata_table_handler
  export _root_.librdata.aliases.rdata_text_value_handler
  export _root_.librdata.aliases.rdata_type_t
  export _root_.librdata.aliases.rdata_update_handler
  export _root_.librdata.aliases.size_t
  export _root_.librdata.aliases.ssize_t
  export _root_.librdata.aliases.time_t
  export _root_.librdata.aliases.tm
  export _root_.librdata.structs.rdata_column_s
  export _root_.librdata.structs.rdata_column_t
  export _root_.librdata.structs.rdata_io_s
  export _root_.librdata.structs.rdata_io_t
  export _root_.librdata.structs.rdata_parser_s
  export _root_.librdata.structs.rdata_parser_t
  export _root_.librdata.structs.rdata_writer_s
  export _root_.librdata.structs.rdata_writer_t
  export _root_.librdata.functions.rdata_add_column
  export _root_.librdata.functions.rdata_append_date_value
  export _root_.librdata.functions.rdata_append_int32_value
  export _root_.librdata.functions.rdata_append_logical_value
  export _root_.librdata.functions.rdata_append_real_value
  export _root_.librdata.functions.rdata_append_string_value
  export _root_.librdata.functions.rdata_append_timestamp_value
  export _root_.librdata.functions.rdata_begin_column
  export _root_.librdata.functions.rdata_begin_file
  export _root_.librdata.functions.rdata_begin_table
  export _root_.librdata.functions.rdata_column_add_factor
  export _root_.librdata.functions.rdata_column_set_label
  export _root_.librdata.functions.rdata_end_column
  export _root_.librdata.functions.rdata_end_file
  export _root_.librdata.functions.rdata_end_table
  export _root_.librdata.functions.rdata_error_message
  export _root_.librdata.functions.rdata_get_column
  export _root_.librdata.functions.rdata_parse
  export _root_.librdata.functions.rdata_parser_free
  export _root_.librdata.functions.rdata_parser_init
  export _root_.librdata.functions.rdata_set_close_handler
  export _root_.librdata.functions.rdata_set_column_handler
  export _root_.librdata.functions.rdata_set_column_name_handler
  export _root_.librdata.functions.rdata_set_dim_handler
  export _root_.librdata.functions.rdata_set_dim_name_handler
  export _root_.librdata.functions.rdata_set_error_handler
  export _root_.librdata.functions.rdata_set_io_ctx
  export _root_.librdata.functions.rdata_set_open_handler
  export _root_.librdata.functions.rdata_set_read_handler
  export _root_.librdata.functions.rdata_set_row_name_handler
  export _root_.librdata.functions.rdata_set_seek_handler
  export _root_.librdata.functions.rdata_set_table_handler
  export _root_.librdata.functions.rdata_set_text_value_handler
  export _root_.librdata.functions.rdata_set_update_handler
  export _root_.librdata.functions.rdata_set_value_label_handler
  export _root_.librdata.functions.rdata_writer_free
  export _root_.librdata.functions.rdata_writer_init