Table of Contents

1. Data
   1. ValuePair
   2. Point
   3. Equipment
   4. DT_GEN Format
   5. Data
2. Random data gen
3. Stream I/O
   1. Lectura de archivos
   2. Lectura de stream y entrega de vector
   3. Lectura de stream y entrega a stream
4. Tests

Data

La estructura Data contiene toda la información que podría generar un sensor base.

Se necesita construir lo siguiente.

DONE ValuePair

DONE Point

DONE Equipment

DONE DT_GEN Format

DONE Data

Todo está definido bajo una estrucura de directorios.

tree src

Random data gen

Es la serie de funciones que construyen aleatoriamente datos a solicitud.

En generators.rs tenemos la función create_data que genera una instancia de Data aleatoria.

Stream I/O

Creación de comando que permite una entrada y deserializarla. Sea un stream o de un archivo.

Hay dos funciones síncronas que permite leer o escribir desde un stream.

• read_io
• write-io

De estas dos derivan las asociadas a archivos, para leer o escribir a archivos.

• read_file
• write_file

Asímismo, de manera asíncrona se usa tokio para crear las funciones que toman leen desde un buffer y lo envían por un canal y viceversa.

• render_to_stream
• stream_to_writer

Estas funcionalidades son claves para que este módulo se pueda utilizar, por ejemplo, en servidores tcp o servicios generadores de datos para simular sensores.

Lectura de archivos

En stream.rs -> read_file se implementa una función sencilla que toma un archivo completo y lo deserializa directamente para convertirlo en un array de Data.

Esto es solo para un archivo de tipo json.

pub fn read_file<P: AsRef<Path>>(
    path: P) -> Result<Vec<Data>, Box<dyn Error>> {
    // open file if exists path
    let file = File::open(path)?;
    // set file to buffer
    let reader = BufReader::new(file);
    // read the json contents
    let json_data = serde_json::from_reader(reader)?;
    // Return Data
    Ok(json_data)
}

Lectura de stream y entrega de vector

Si el origen del dato viene de un stream, entonces se usa read_io que toma la serie de valores (o de un archivo no json)

pub fn read_io<R: io::BufRead >(
    mut input: R,
    end_flag: &String,
    print: bool) -> Result<Vec<Data>, Box<dyn Error>> {
    let mut lines: Vec<String> = vec![];
    let mut dataset: Vec<Data> = vec![];
    for value in input.lines() {
        let line = value?;
          if line.as_str().trim() == end_flag   {
              let new_value = lines.join("");
              let new_data = Data::json_loads(&new_value);
              if print {
                  println!("{}", new_data);
              }
              dataset.push(new_data);
              lines.clear();
          } else {
              if !line.trim().is_empty() {
                  lines.push(line);
                  }
          }
        }
    Ok(dataset)
}

Lectura de stream y entrega a stream

En este caso, en vez de lograr un acumulador, tomar el Data convertido enviarlo mediante un stream con rasgo Write.

Por ejemplo, podría necesitar enviarlo por una cola a un stream de socket, entonces crear un módulo que tome el dato, lo procese y envíe a otra parte, si es que lo necesita. También podría utilizarse para enviar a un proceso concurrente o funcionalidad atómica separada.

Tests

Todas las operaciones disponibles para crear datos y enviarlos o recibirlos por stream están testeadas.

Revisar los tests pueden servir para aprender a usar las funciones.