Check if `r` is a valid OrientDB embedded record. eg:

{:_class "User" :name "Test"}

Determine the structure of the first element of `record-map`.

Transform the record `record-map` into a custom structure. eg.:

(get-structure {:_class "User" :name "Test"}) =>
[{:key-type 7, :field-name :_class, :position 0, :type 7, :value "User"}
 {:key-type 7, :field-name :name, :position 0, :type 7, :value "Test"}]

Return a keyword the identifies the type of `v.` e.g.

(get-type true) => :boolean-type

Calculate the total `headers` size. `fixed-header-int` is needed to
distinguish the calculation of the header size of a record from that of an
embedded map.

Check if `l` is a valid OrienDB link list. e.g.: ["#21:1" "#21:2"]

Check if `m` is a valid OrientDB link map. e.g.: {"test" "#21:2"}

Check if `s` is a valid OrientDB link set. e.g.: #{"#21:1" "#21:2"}

Check if `v` is a valid OrientDB link. e.g.: "#21:1"

Check if `v` is an OrientDB binary type.

Trasform the embedded map `data-map` into a structure. e.g.:

(oemap->structure {:test 1} 0) =>
({:key-type 7, :field-name :test, :position [0 0 0 12], :type 1, :value 1,
  :serialized-value [2]})

Calculate the position of the values in `structure`, offsetting the first
value with `offset.`

Check if `v` is an OrientDB RidBag embedded type.

Check if `v` is an OrientDB RidBag tree type.

Convert `value` in an int32. e.g.: (orient-int32 1) => [0 0 0 1]

Map custom orient types to their respective byte identifier.

Convert the positions in `structure` in int32.

Transform the record `record-map` into a structure. e.g.:

(record-map->structure {:_class "User" :name "Test"} 0) =>
({:key-type 7, :field-name :_class, :type 7, :value "User",
  :serialized-value [8 85 115 101 114], :position [0 0 0 24]}
 {:key-type 7, :field-name :name, :type 7, :value "Test",
  :position [0 0 0 29], :serialized-value [8 84 101 115 116]})

Remove from `v` the entries whose keyword name starts with "_".

Determine the structure of all but the first element of `record-map`.

Serialize `value` based on its type.
It optionally accepts an `offset` which will be used to calculate the position
of `value` from the beginning of the record.

Retrieve the :serialized-value inside `structure`.

Serialize the elements in `header` returning a vector sorted by `key-order`.

Serialize the elements in `structure` returning a sequence sorted by
`key-order`.

Serialize a key-value according to OrientDB specification.
See: http://orientdb.com/docs/last/Record-Schemaless-Binary-Serialization.html#linkmap

Serialize `value` in a vector of bytes with the byte representing its type
coming first. e.g.:

(serialize-list-item true) => [0 1]

Serialize the values inside `structure` according to their type.