1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! Core types and abstractions used by the Rune ecosystem.
//!
//! # Feature Flags
//!
//! This crate has the following cargo feature flags:
//!
//! - `std` - enables functionality that requires the standard library
//!   (typically implementations of `std::error::Error`)

#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(feature = "unstable_doc_cfg", feature(doc_cfg))]

#[cfg(test)]
#[macro_use]
extern crate std;

extern crate alloc;

mod element_type;
mod logging;
mod pixel_format;
mod resources;
mod shape;
mod tensor;
mod tensor_list;
mod value;

pub use crate::{
    element_type::{AsElementType, ElementType, UnknownElementType},
    logging::SerializableRecord,
    pixel_format::{PixelFormat, PixelFormatConversionError},
    resources::{decode_inline_resource, InlineResource},
    shape::Shape,
    tensor::{Tensor, TensorView, TensorViewMut},
    tensor_list::{TensorList, TensorListMut},
    value::{AsType, InvalidConversionError, Type, Value},
};

/// The mimetype used for a TensorFlow Lite model.
pub const TFLITE_MIMETYPE: &str = "application/tflite-model";
/// The mimetype used for a TensorFlow model.
pub const TF_MIMETYPE: &str = "application/tf-model";
/// The mimetype used for a ONNX model.
pub const ONNX_MIMETYPE: &str = "application/onnx-model";
/// The mimetype used for a TensorFlow JS model.
pub const TFJS_MIMETYPE: &str = "application/tfjs-model";

/// The version number for this crate.
pub const VERSION: &str = env!("CARGO_PKG_VERSION");

macro_rules! constants {
    ($name:ident { $(
        $(#[$constant_meta:meta])*
        $constant:ident = $value:expr
    ),* $(,)* }) => {
        pub mod $name {
            $(
                $( #[$constant_meta] )*
                pub const $constant: u32 = $value;
            )*

            pub const fn all() -> &'static [(&'static str, u32)] {
                &[
                    $(
                        (stringify!($constant), $value)
                    ),*
                ]
            }


            pub fn from_name(name: &str) -> Option<u32> {
                for (candidate, id) in all() {
                    if *candidate == name {
                        return Some(*id);
                    }
                }

                None
            }

            pub fn name(value: u32) -> Option<&'static str> {
                for (name, candidate) in all().iter() {
                    if *candidate == value {
                        return Some(*name);
                    }
                }

                None
            }
        }
    };
}

constants! {
    capabilities {
        RAND = 1,
        SOUND = 2,
        ACCEL = 3,
        IMAGE = 4,
        RAW = 5,
        FLOAT_IMAGE = 6,
    }
}

constants! {
    outputs {
        /// A serial device which consumes JSON-encoded data.
        SERIAL = 1,
        BLE = 2,
        PIN = 3,
        WIFI = 4,
        /// A raw tensor output.
        ///
        /// The buffer passed from the Rune to the runtime will be laid out
        /// as:
        ///
        /// | Field     | Length   | Description                                                                   |
        /// | --------- | -------- | ----------------------------------------------------------------------------- |
        /// | shape_len | 4        | A little-endian u32 containing the shape field's length                       |
        /// | shape     | variable | A UTF-8 string encoding the tensor's shape (i.e. element type and dimensions) |
        /// | elements  | variable | The tensor data itself, in little-endian format                               |
        ///
        /// This pattern may be repeated an arbitrary number of times, depending
        /// on how many tensors are being outputted.
        TENSOR = 5,
    }
}