# Table of Contents

1.  [Data](#org63433df)
    1.  [ValuePair](#org38f4a8b)
    2.  [Point](#org1426c02)
    3.  [Equipment](#org3afe002)
    4.  [DT\_GEN Format](#org4f28bf5)
    5.  [Data](#org90c666d)
2.  [Random data gen](#orgabd0641)
3.  [Stream I/O](#org7b4d2ec)
    1.  [Lectura de archivos](#org188e324)
    2.  [Lectura de stream y entrega de vector](#orgc4c81f6)
    3.  [Lectura de stream y entrega a stream](#org7e82481)
4.  [Tests](#org6808af5)



<a id="org63433df"></a>

# Data

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

Se necesita construir lo siguiente.


<a id="org38f4a8b"></a>

## DONE ValuePair


<a id="org1426c02"></a>

## DONE Point


<a id="org3afe002"></a>

## DONE Equipment


<a id="org4f28bf5"></a>

## DONE DT\_GEN Format


<a id="org90c666d"></a>

## DONE Data

Todo está definido bajo una estrucura de directorios.

    tree src


<a id="orgabd0641"></a>

# 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.


<a id="org7b4d2ec"></a>

# 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.


<a id="org188e324"></a>

## 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)
    }


<a id="orgc4c81f6"></a>

## 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)
    }


<a id="org7e82481"></a>

## 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.


<a id="org6808af5"></a>

# 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.