#+TITLE: Notas de desarrollo.
#+OPTIONS: ^:nil

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


#+begin_src shell :results output 
tree src
#+end_src

#+RESULTS:
#+begin_example
src
├── elements
│   ├── data.rs
│   ├── dt_gen_format.rs
│   ├── equipment.rs
│   ├── mod.rs
│   ├── point.rs
│   └── value_pair.rs
├── generators.rs
├── lib.rs
├── main.rs
└── stream
    ├── async_read.rs
    ├── async_read.rs~
    ├── async_write.rs
    ├── async_write.rs~
    ├── mod.rs
    ├── read.rs
    ├── write.rs
    ├── write.rs~
    └── write_to_stream.rs

2 directories, 18 files
#+end_example


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

#+begin_src rust
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)
}
#+end_src

** 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)

#+begin_src rust
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)
}
#+end_src


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