Documentación - ErrorsManager

doc/es/description.w.md

El proyecto ErrorsManager es un proyeto ideado y desarrollado por Srx00 orientado a gestionar errores de una forma eficiente, compacta, sencilla y compatible entre plataformas. La idea radica en que la forma más simple de poder gestionar y mostrar errores de tipo global es gestionando un sistema Booleano que nos permite identificar punto a punto si algo es correcto o no, donde la solución más práctica, sencilla, eficiente, de bajos recursos y bajo peso sería el uso natural de binarios sobre valores enteros como valores comunes a todos los lenguajes, mediante la práctica del Bitwise y operadores binarios, ya sean nativos (Como en la mayoría de los lenguajes) o alternativos (Como es parcialmente en el caso de SQL Server), sin embargo, esto nos da un problema de funcionamiento real el cual podemos ver representado en la siguiente tabla:

Lenguaje	Bits de entero	Bits de Bitwise seguros
JavaScript	32	31
SQL Server	64	28
Python	Infinito	Infinito
Lenguaje	Bits de entero	Bits de Bitwise seguros

Es cierto que Python no puede trabajar valores infinitos y que su valor máximo entero es de 64 bits, sin embargo, éste hace uso de una práctica que individualiza los dígitos del valor y los calcula en múltiples ciclos, que pese a ser un proceso más lento por ser fuera de la mantisa, aunque éstos se agrupon binariamente, permite un uso que puede extenderse hasta casi los 4GB de longitud, por tanto, hablando de semejantes longitudes lo consideramos, al uso de esta librería, como infinito.

Es verdad que en los SQL el entero es de 32 bits, sin embargo, existe la variación del BigInt que nos permite tener enteros de hasta 64 bits. Es importante tener en cuenta que ciertos motores como MySQL/MariaDB no contemplan el uso físico de la mantisa pudiendo ser ejectados en entornos de 32 bits y poder trabajar valores de 64 bits, por lo que se cuenta únicamente por gestión de memoria, pero como uso serguro en decimal tenemos 64 bits, pero como uso Bitwise lo tenemos que bajar de 32 bits.

Visto este problema tanto de limitaciones como de diferentes longitudes de trabajo para los Bitwise existe esta librería. La idea es cambiar un valor numérico entero por un String cuya longitud se condiciona a los 2GB en la mínima (32 bits de mantisa, pese a que éste sea realmente más, pero no en potencia 2 que serían los 4GB). También hay que tener en cuenta que el espacio asignado en lenguajes fuertemente tipados o de gestión de memoria, sería un despropósito asignar semejante cantidades, motivo por el cual, esta librería lo deja a una longitud de 512 bytes de tamaño para la gestión de errores. Dicha longitud se basará en Base64, base la cual sería una potencia 6 de base 2, es decir, por caracter tendríamos una gestión de 6 errores simultáneos distintos, por lo que 512 bytes daría lugar a la posibilidad de gestión de 512 * 6, que vendría siendo 3072 errores simultáneos por String.

Esta librería permite alternar trabajo con Strings y valores numéricos enteros, siendo más eficiente y rápido, además de nativo, el uso de valores numéricos enteros positivos, así que se aconseja que mientras se esté por debajo de los 28 bits de longitud se haga uso de este sistema, a partir de ahí se aconseja el uso de Strings mediante esta librería.

doc/es/projects.w.md

Proyectos

Este proyecto es independiente a nivel de funcionamiento como librería, independientemente del lenguaje que se esté utilizando, sin embargo, a nivel de página Web, éste hace uso de los siguientes proyectos.

WMarkDown
- https://wmarkdown.k3y.pw/
- https://git.k3y.pw/Whalers/WMarkDown
AnP
- https://anp.k3y.pw/
- https://git.k3y.pw/AnP/AnP
CDN de KyMAN
- https://cdn.k3y.pw/
- https://git.k3y.pw/KyMAN/CDN

Dicho proyecto hereda de otros proyectos a partir de los aquí presentados, por ejemplo, a partir del WMarkDown hereda del MathJAX, highlight.js y MermaidJS de JavaScript, entre otros. Si vais al proyecto WMarkDown podréis ver más información acerca de dichas dependencias.

Por otro lado, este proyecto es usado en proyectos tales como los siguientes:

AnP
- https://anp.k3y.pw/
- https://git.k3y.pw/AnP/AnP

Al ser un proyecto para uso tan crudo y básico, éste puede aparecer en proyectos de los cuales herede para funciones como la Web o servicio de servidor, entre otros.

doc/es/design.w.md

Diseño

El diseño de la interfaz de muestreo e información del proyecto ErrorsManager viene siendo la extraída de forma directa del proyecto AnP y el propio WMarkDown, con la diferencia principal de los colores primario y secundario.

Empezando por los colores, tenemos los siguientes:

Tipo	Hexadecimal	RGBA	Muestra
Fondo	#EFEFEF	rgba(239, 239, 239, 1)	#EFEFEF
Frontal	#222	rgba(34, 34, 34, 1)	#222
Primario	#812	rgba(136, 17, 34, 1)	#812
Secundario	#218	rgba(34, 17, 136, 1)	#218
Gris	#888	rgba(136, 136, 136, 1)	#888
Tabla título	#19888888	rgba(136, 136, 136, 0.1)	rgba(136, 136, 136, 0.1)
Tabla Select	#19888888	rgba(136, 136, 136, 0.1)	rgba(136, 136, 136, 0.1)
Tabla impar	#38888888	rgba(136, 136, 136, 0.2)	rgba(136, 136, 136, 0.2)
Tabla par	#00FFFFFF	rgba(255, 255, 255, 0)	rgba(255, 255, 255, 0)
Borde interno	#19888888	rgba(136, 136, 136, 0.5)	rgba(136, 136, 136, 0.5)
Diccionario	#551a22	rgba(85, 26, 34, 1)	#551a22
Diccionario en	#224d55	rgba(34, 77, 85, 1)	#224d55
Code impar	#38C8C8C8	rgba(200, 200, 200, 0.2)	rgba(200, 200, 200, 0.2)
Tipo	Hexadecimal	RGBA	Muestra

Por otro lado, tenemos las fuentes de texto usados en la Web de este proyecto, las cuales son:

Roboto. Para el texto en general.
- https://fonts.google.com/specimen/Roboto?query=roboto
Roboto Mono. Para los bloques de código.
- https://fonts.google.com/specimen/Roboto+Mono?query=roboto
Font Awesome. Para la iconificación general de la Web.
- https://fontawesome.com/

El tamaño de la fuente, así como de los elementos de la Web se basan en un sistema que simulan los DPI en la Web, usando la magnitud "EM" para determinar un tamaño dinámico sobre el bloque anfitrión del mismo. Por defecto, éste se basa en dividir en 40 celdas desde el lado de la pantalla o del marco de visualización más estrecho, quedando como tamaño de fuente por defecto una celda.

La cabecera hace uso de 4 celdas y el pie de página consta de 2. Ambos ordenan sus elementos en un bloque Flex a modo tupla.

Finalmente tenemos el logo del proyecto, que representa una centralización de recursos sobre otros proyectos exponiendo un punto central del que parten todos los demás proyectos más grandes.

doc/es/integration.w.md

Integración

El proyecto ErrorsManager viene siendo un proyecto que se basa principalmente en un objeto que parte de una clase, aunque en lenguajes como los SQL, éste parte de una librería que contiene las acciones necesarias para poder trabajar con ésta.

JavaScript/ECMAScript

En proyectos de JavaScript/ECMAScript, existen varias formas de ser adjuntas, sin embargo, aquí hablaremos únicamente de la adjunción directa vía etiqueta SCRIPT de HTML pues cada entorno de desarrollo tendrá su forma de cargar dicha librería. Para poder hacer uso de esta librería puede ser mediante sistema local, a partir de descargar dicha librería; o bien, hacer uso de la librería original de este servidor o cualquier otro CDN, aunque se aconseja siempre que sea el oficial.

typehtml
characters200
lines1

<script data-type="text/javascript;charset=utf-8" data-language="ECMAScript 2015" src="https://errorsmanager.k3y.pw/ecma/ErrorsManager.ecma.js" data-crossorigin="anonymous" charset="utf-8"></script>

Srx00
Estos atributos que aquí se exponen son míos con la folosofía de preservar ciertos atributos que antiguamente se utilizaban y que a creencia personal, son útiles para identificar a qué clase de Script te enfrentas sin necesidad de tener que ver el contenido del fichero que vinculan, así que los elementos que salen como data- no serían nacesarios de aplicar, simplemente siguen una filosofía personal que siempre aparecerán expuestos en mis desarrollos personales.

Los Links que se pueden usar para dicho fin son los siguientes:

Para descargar el archivo original tenemos el siguiente link:

https://git.k3y.pw/KyMAN/ErrorsManager/src/branch/main/Public/ecma/ErrorsManager.ecma.js

Luego, para poder hacer uso de dicha librería simplemente hemos de crear el objeto que contiene las órdenes con el alfabeto correspondiente.

typejs
characters106
lines6

"use strict";

const errors_manager = new ErrorsManager();

console.log(errors_manager.get_alphabet());

De esta forma, comprobamos que realmente funciona imprimiendo el alfabeto usado para el String.

Python

La integración en Python se puede hacer de varias formas según interese al desarrollador, sin embargo, hay que tener encuenta que ésto puede dar lugar a problemas de funcionalidad según se haga.

Recuerda que Python funciona bajo los permisos del usuario ejecutor, por lo que es importante tener encuenta los permisos, ya sean por las ACL como por los permisos nativos del sistema.

Directo

La integración directa dentro de un proyecto Python sería básicamente descargar el siguiente archivo Python desde el propio Git e integrarlo dentro de nuestro proyecto.

https://git.k3y.pw/KyMAN/ErrorsManager/src/branch/main/Python/ErrorsManager.py

Si el fichero fue instalado en el directorio "Assets" dentro de nuestro proyecto, su implementación sería la siguiente:

typepy
characters182
lines9

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.get_alphabet())

Enlace Simbólico

Una integración a partir de un Enlace Simbólico (Sistemas UNIX) o Acceso Directo (Sistemas DOS) simlemente es tener descargado el archivo mencionado justo en el apartado Directo en cualquier parte de que nos interese tenerlo como un recurso compartido y éste ser vinculado mediante Enlace Simbólico o Acceso Directo dentro de nuestro proyecto. Siguiendo con el ejemplo anterior, y en nuestro caso, en un entorno UNIX, éste sería:

typesh
characters239
lines8

#!/bin/bash

mkdir /CARPETA_DE_RECURSOS_COMPARTIDOS
cd /CARPETA_DE_RECURSOS_COMPARTIDOS

wget https://git.k3y.pw/KyMAN/ErrorsManager/raw/branch/main/Python/ErrorsManager.py
ln -s ErrorsManager.py /PROYECTO_PYTHON/Assets/ErrorsManager.py

Y de la misma forma que el anterior, tendríamos:

typepy
characters182
lines9

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.get_alphabet())

Indirecto o En Caliente

La última forma que se expone es la carga indirecta o compilado en caliente. Python tiene 3 modos de trabajo:

Compilado, donde se compila un PYC u otro formato dependiendo del propio compilador, que pese a seguir siendo interpretado por una VM, éste ya no tendría el proceso del precompilado.
Precompilado, donde se ejecuta directamente un archivo PY que lance toda la aplicación, ya sea con carga de archivos importados o seá únicamente un fichero, donde se compila en memoria y tras ello será ejecutado e interpretado. Este método es el más habitual.
Compilado en caliente, el cual se usa para cargar librerías que pueden o no estar dentro del proyecto y se cargan como ficheros binarios, luego éstos se compilan en caliente dentro de la aplicació ya ejecutada y luego se ejecutan éstos al nivel donde se haga la compilación.

En este caso sería el último, y ésto nos permite cargar cualquier fichero en cualquier punto del sistema operativo mediante su Path, ya sea absoluto o relativo. Suponiendo que está en un directorio de recursos compartidos entre aplicaciones, y partiendo del ejemplo del apartado anterior Enlace Simbólico, el resultado sería el siguiente:

typepython
characters582
lines25

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from os.path import exists as path_exists

path:str = "/CARPETA_DE_RECURSOS_COMPARTIDOS/ErrorsManager.py"

if path_exists(path):

    opened:BufferedReader

    with open(path, "rb") as opened:
        try:

            exec(compile(opened.read(), "ErrorsManager.py", "exec"), globals())

            errors_manager:ErrorsManager = ErrorsManager()

            print(errors_manager.get_alphabet())

        except Exception as exception:
            print(exception.getMessage())
else:
    print("No existe el Path '" + path + "'.")

Este método tiene tres problemas: el primero de todos, y más importante es que hay que tener en cuenta que para aplicaciones compiladas no vale pues la librería quedaría sin compilar a petición de la aplicación; requiere de que exista siempre esa librería, sino nos dirá que no existe, y eso puede ser un problema a la hora de compartir el proyecto; y finalmente, los permisos que tenga el fichero para ser cargado, aunque no le afectaría el permiso de ejecución pues como podemos ver, simplemente lee su contenido y luego lo ejecuta, pero no ejecuta propiamente el fichero.

doc/es/manual.w.md

Manual

manual/basis.w.md

En este apartado se analizará cada una de las funcionalidades de esta librería, en común entre todos los lenguajes, de esta forma se podrá gestionar de una forma común entre los distintos entornos a los que pertenece.

Antes de empezar, hay que aclarar que esta librería se basa en un funcionamiento mediante Bitwise dentro de un String, donde cada caracter representa un valor numérico entero en una base binaria cuya potencia por defecto será 6, es decir, que cada caracter representa un valor numérico decimal entero positivo entre 0 y 63, ambos incluídos, y cuando hay más de un valor, éste será como cuando hay más de un dígito en base decimal, permitiendo recrear valores numéricos enormes. Para poder llevar a cabo ésto, se requiere de un alfabeto de caracteres el cual determina por posición, qué valor numérico decimal entero positivo representa. Por defecto, el alfabeto usado es el Base64, el cual es el siguiente:

typetxt
characters67
lines1

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=

Es cierto que Base64 realmente no tiene 64 caracteres, sino 65. Esto sucede por el caracter de relleno para que cumpla con el protocolo de la codificación de Base64. En nuestro caso, éste último caracter será ignorado pues se usará, dentro del conjunto matemático los 64 caracteres que representan las posiciones de la 0 a la 63, los cuales incluyen el caracter más ("+") y el caracter igual ("=").

¡OJO!
Es importante entender que se diferenciarán las mayúsculas de las minúsculas cara entornos como los SQL lo cual hay que forzarlo en las funciones de trabajo con caracteres y Strings.

IMPORTANTE
Para que los errores puedan ser multiplataforma e integrados en lenguajes o plataformas externas, el alfabeto y la potencia de la base han de coincidir, sino, los errores en formato String serán mal interpretados.

La librería trabaja tres tipos muy concretos de datos equivalentes de error:

Integer: Viene siendo un valor numérico entero cuyos Bits representan, de forma Booleana, cada uno de los errores, hasta un máximo seguro de 28 bits de longitud.
String: Viene siendo una cadena de caracteres en el alfabeto dado que determina el código de error. Viene a representar lo mismo que el Integer pero con la diferencia de que cada caracter viene siendo un valor numérico en una base específica cuya unión hace enteros simulados más largos y cuyos bits por posición, representan lo dicho anteriormente.
Array: Viene siendo lo mismo que el String pero cada caracter es subsituído por el entero correspondiente al que hace referencia dentro de un vector, lista, Array, tupla, etc., y éste está comprendido entre 0 y la base del String menos 1, ambos incluídos. Por ejemplo, en Base64 sería entre 0 y 63, ambos incuídos.

typemaths
characters184
lines11


\begin{align}

Base = 64 \\
Rango(x, y) = [x, y] = [0, 64 - 1] = [0, 2^{log_2{64}} - 1] \\ \\

B = Base \\
Rango(x, y) = [x, y] = [0, B - 1] = [0, 2^{log_2{B}} - 1] \\

\end{align}

Es importante mencionar que el código de error visual es el propio String, sin embargo, el código de error para ser procesado y trabajado es el Array.

La librería se basa en un objeto o en un espacio de nombres, pero entornos que no posean ninguna de las dos cosas señaladas anteriormente o que el uso de éstas requiera de un trabajo engorroso o profundo sobre dicho entorno, éstos usarán la cabecera de nombre en todos sus elementos a usar errors_manager_ en Snake o ErrorsManager en Pascal según convenga su uso.

Métodos y Funciones: Irá en Snake.
Tablas y Vistas: Irá en Pascal.
Variables: Irá en Snake.
Constantes: Irá en Snake Upper.

La librería, al no trabajar entorno gráfico pues es simplemente para el lado de desarrollo, ésta no posee entradas en Kebab para clases e IDs entre otras claves. Además, por filosofía no se usa Camel, sino Pascal.

manual/set_alphabet.w.md

set_alphabet

ErrorsManager.set_alphabet

voidobjectpublicErrorsManager.set_alphabetRequiredNullishStringalphabet

Name	Required	Nullable	Typed	Default Value
alphabet	True	True	String
Name	Required	Nullable	Typed	Default Value

El método set_alphabet es un método objeto para establecer de forma externa al objeto, el alfabeto que determinará el código resultante de error y que condicionará su interpretación. Dicha función tendrá de entrada la nueva cadena la cual será un String de al menos 64 caracteres, y éstos han de ser distintos entre sí o funcionará mal. No hay retorno.

typepy
characters436
lines16

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()
nuevo_alfabeto:str = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM+/"

# Imprime el alfabeto por defecto.
print(errors_manager.get_alphabet())

errors_manager.set_alphabet(nuevo_alfabeto)

# Imprime el nuevo alfabeto con su nuevo orden.
print(errors_manager.get_alphabet())

typejs
characters431
lines15

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager(), 
      /** @type {String} */
      nuevo_alfabeto = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM+/";

// Imprime el alfabeto por defecto.
console.log(errors_manager.get_alphabet());

errors_manager.set_alphabet(nuevo_alfabeto);

// Imprime el nuevo alfabeto con su nuevo orden.
console.log(errors_manager.get_alphabet());

Se pueden cambiar los caracteres por otros que no sean necesariamente de base64, sin embargo, hay que tener en cuenta la compatibilidad entre plataformas e interpretación de dichos caracteres tanto en el traspaso de una plataforma a otra así como en la capacidad del lenguaje que se esté trabajando. Se aconseja ir siempre a la parte más restrictiva del proyecto.

manual/get_alphabet.w.md

get_alphabet

ErrorsManager.get_alphabet

stringobjectpublicErrorsManager.get_alphabet

Name	Required	Nullable	Typed	Default Value
Name	Required	Nullable	Typed	Default Value

El método get_alphabet es un método objeto que retorna el alfabeto actualmente en uso del objeto ErrorsManager.

typepy
characters329
lines11

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

mi_alfabeto:str = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM+/"
errors_manager:ErrorsManager = ErrorsManager(mi_alfabeto)

# Imprime mi alfabeto como alfabeto actual en uso.
print(errors_manager.get_alphabet())

typejs
characters315
lines10

"use strict";

/** @type {String} */
const mi_alfabeto = "qwertyuiopasdfghjklzxcvbnm1234567890QWERTYUIOPASDFGHJKLZXCVBNM+/", 
      /** @type {ErrorsManager} */
      errors_manager = new ErrorsManager(mi_alfabeto);

// Imprime mi alfabeto como alfabeto actual en uso.
console.log(errors_manager.get_alphabet());

manual/is_string.w.md

is_string

ErrorsManager.is_string

BooleanstaticpublicErrorsManager.is_stringRequiredNullishAnyvalue

Name	Required	Nullable	Typed	Default Value
value	True	True	Any
Name	Required	Nullable	Typed	Default Value

El método is_string es un método estático que verifica si el valor dado es un String o no.

typepy
characters1063
lines24

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(["Prueba 1", errors_manager.is_string("")])
print(["Prueba 2", errors_manager.is_string("Hola xD")])
print(["Prueba 3", errors_manager.is_string(None)])
print(["Prueba 4", errors_manager.is_string(5)])
print(["Prueba 5", errors_manager.is_string(-8)])
print(["Prueba 6", errors_manager.is_string(-104.56)])
print(["Prueba 7", errors_manager.is_string(6.007)])
print(["Prueba 8", errors_manager.is_string(.345)])
print(["Prueba 9", errors_manager.is_string(ErrorsManager)])
print(["Prueba 10", errors_manager.is_string(errors_manager)])
print(["Prueba 11", errors_manager.is_string(["Esto es un String"])])
print(["Prueba 12", errors_manager.is_string(['S', 't', 'r', 'i', 'n', 'g'])])
print(["Prueba 13", errors_manager.is_string(True)])
print(["Prueba 14", errors_manager.is_string(False)])
print(["Prueba 15", errors_manager.is_string((True,))])
print(["Prueba 16", errors_manager.is_string([2, 45, 18, 24])])

typejs
characters1120
lines22

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.is_string("")]);
console.log(["Prueba 2", errors_manager.is_string("Hola xD")]);
console.log(["Prueba 3", errors_manager.is_string(null)]);
console.log(["Prueba 4", errors_manager.is_string(5)]);
console.log(["Prueba 5", errors_manager.is_string(-8)]);
console.log(["Prueba 6", errors_manager.is_string(-104.56)]);
console.log(["Prueba 7", errors_manager.is_string(6.007)]);
console.log(["Prueba 8", errors_manager.is_string(.345)]);
console.log(["Prueba 9", errors_manager.is_string(ErrorsManager)]);
console.log(["Prueba 10", errors_manager.is_string(errors_manager)]);
console.log(["Prueba 11", errors_manager.is_string(["Esto es un String"])]);
console.log(["Prueba 12", errors_manager.is_string(['S', 't', 'r', 'i', 'n', 'g'])]);
console.log(["Prueba 13", errors_manager.is_string(true)]);
console.log(["Prueba 14", errors_manager.is_string(false)]);
console.log(["Prueba 15", errors_manager.is_string([true])]);
console.log(["Prueba 16", errors_manager.is_string([2, 45, 18, 24])]);

En los ejemplos anteriores sacaríamos los siguientes resultados:

Prueba	Python	JavaScript
1	True	true
2	True	true
3	True	true
4	False	false
5	False	false
6	False	false
7	False	false
8	False	false
9	False	false
10	False	false
11	False	false
12	False	false
13	False	false
14	False	false
15	False	false
16	False	false
Prueba	Python	JavaScript

manual/is_integer.w.md

is_integer

ErrorsManager.is_integer

BooleanstaticpublicErrorsManager.is_integerRequiredNullishAnyvalue

Name	Required	Nullable	Typed	Default Value
value	True	True	Any
Name	Required	Nullable	Typed	Default Value

El método is_integer es un método estático que verifica si el valor dado es un un valor numérico entero o no.

typepy
characters1079
lines24

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(["Prueba 1", errors_manager.is_integer("")])
print(["Prueba 2", errors_manager.is_integer("Hola xD")])
print(["Prueba 3", errors_manager.is_integer(None)])
print(["Prueba 4", errors_manager.is_integer(5)])
print(["Prueba 5", errors_manager.is_integer(-8)])
print(["Prueba 6", errors_manager.is_integer(-104.56)])
print(["Prueba 7", errors_manager.is_integer(6.007)])
print(["Prueba 8", errors_manager.is_integer(.345)])
print(["Prueba 9", errors_manager.is_integer(ErrorsManager)])
print(["Prueba 10", errors_manager.is_integer(errors_manager)])
print(["Prueba 11", errors_manager.is_integer(["Esto es un String"])])
print(["Prueba 12", errors_manager.is_integer(['S', 't', 'r', 'i', 'n', 'g'])])
print(["Prueba 13", errors_manager.is_integer(True)])
print(["Prueba 14", errors_manager.is_integer(False)])
print(["Prueba 15", errors_manager.is_integer((True,))])
print(["Prueba 16", errors_manager.is_integer([2, 45, 18, 24])])

typejs
characters1136
lines22

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.is_integer("")]);
console.log(["Prueba 2", errors_manager.is_integer("Hola xD")]);
console.log(["Prueba 3", errors_manager.is_integer(null)]);
console.log(["Prueba 4", errors_manager.is_integer(5)]);
console.log(["Prueba 5", errors_manager.is_integer(-8)]);
console.log(["Prueba 6", errors_manager.is_integer(-104.56)]);
console.log(["Prueba 7", errors_manager.is_integer(6.007)]);
console.log(["Prueba 8", errors_manager.is_integer(.345)]);
console.log(["Prueba 9", errors_manager.is_integer(ErrorsManager)]);
console.log(["Prueba 10", errors_manager.is_integer(errors_manager)]);
console.log(["Prueba 11", errors_manager.is_integer(["Esto es un String"])]);
console.log(["Prueba 12", errors_manager.is_integer(['S', 't', 'r', 'i', 'n', 'g'])]);
console.log(["Prueba 13", errors_manager.is_integer(true)]);
console.log(["Prueba 14", errors_manager.is_integer(false)]);
console.log(["Prueba 15", errors_manager.is_integer([true])]);
console.log(["Prueba 16", errors_manager.is_integer([2, 45, 18, 24])]);

En los ejemplos anteriores sacaríamos los siguientes resultados:

Prueba	Python	JavaScript
1	False	false
2	False	false
3	False	false
4	True	true
5	True	true
6	False	false
7	False	false
8	False	false
9	False	false
10	False	false
11	False	false
12	False	false
13	False	false
14	False	false
15	False	false
16	False	false
Prueba	Python	JavaScript

manual/is_array.w.md

is_array

ErrorsManager.is_array

BooleanstaticpublicErrorsManager.is_arrayRequiredNullishAnyvalue

Name	Required	Nullable	Typed	Default Value
value	True	True	Any
Name	Required	Nullable	Typed	Default Value

El método is_array es un método estático que verifica si el valor dado es un Array o no, y en caso de estar en entornos como Python, hablamos de si son Listas o Tuplas.

typepy
characters1047
lines24

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(["Prueba 1", errors_manager.is_array("")])
print(["Prueba 2", errors_manager.is_array("Hola xD")])
print(["Prueba 3", errors_manager.is_array(None)])
print(["Prueba 4", errors_manager.is_array(5)])
print(["Prueba 5", errors_manager.is_array(-8)])
print(["Prueba 6", errors_manager.is_array(-104.56)])
print(["Prueba 7", errors_manager.is_array(6.007)])
print(["Prueba 8", errors_manager.is_array(.345)])
print(["Prueba 9", errors_manager.is_array(ErrorsManager)])
print(["Prueba 10", errors_manager.is_array(errors_manager)])
print(["Prueba 11", errors_manager.is_array(["Esto es un String"])])
print(["Prueba 12", errors_manager.is_array(['S', 't', 'r', 'i', 'n', 'g'])])
print(["Prueba 13", errors_manager.is_array(True)])
print(["Prueba 14", errors_manager.is_array(False)])
print(["Prueba 15", errors_manager.is_array((True,))])
print(["Prueba 16", errors_manager.is_array([2, 45, 18, 24])])

typejs
characters1104
lines22

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.is_array("")]);
console.log(["Prueba 2", errors_manager.is_array("Hola xD")]);
console.log(["Prueba 3", errors_manager.is_array(null)]);
console.log(["Prueba 4", errors_manager.is_array(5)]);
console.log(["Prueba 5", errors_manager.is_array(-8)]);
console.log(["Prueba 6", errors_manager.is_array(-104.56)]);
console.log(["Prueba 7", errors_manager.is_array(6.007)]);
console.log(["Prueba 8", errors_manager.is_array(.345)]);
console.log(["Prueba 9", errors_manager.is_array(ErrorsManager)]);
console.log(["Prueba 10", errors_manager.is_array(errors_manager)]);
console.log(["Prueba 11", errors_manager.is_array(["Esto es un String"])]);
console.log(["Prueba 12", errors_manager.is_array(['S', 't', 'r', 'i', 'n', 'g'])]);
console.log(["Prueba 13", errors_manager.is_array(true)]);
console.log(["Prueba 14", errors_manager.is_array(false)]);
console.log(["Prueba 15", errors_manager.is_array([true])]);
console.log(["Prueba 16", errors_manager.is_array([2, 45, 18, 24])]);

En los ejemplos anteriores sacaríamos los siguientes resultados:

Prueba	Python	JavaScript
1	False	false
2	False	false
3	False	false
4	False	false
5	False	false
6	False	false
7	False	false
8	False	false
9	False	false
10	False	false
11	True	true
12	True	true
13	False	false
14	False	false
15	True	true
16	True	true
Prueba	Python	JavaScript

manual/type.w.md

type

ErrorsManager.type

StringstaticpublicErrorsManager.typeRequiredNullishAnyvalue

Name	Required	Nullable	Typed	Default Value
value	True	True	Any
Name	Required	Nullable	Typed	Default Value

El método type es un método estático que retorna el tipado de una variable con respecto a si es:

string: Si es un texto.
integer: Si es un valor numérico entero.
array: Si es un Array, Vector, Lista, Tupla, etc. De valores numéricos enteros.
unknown: Si no es ninguno de los tipos anteriores.

La librería sólo trabaja los tipados String, Integer y Array de enteros. Si es otro tipado, ésta lo tomará como desconocido y lo tratará como algo inesperado o un error, pero no hará saltar una Excepción.

typepy
characters983
lines24

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(["Prueba 1", errors_manager.type("")])
print(["Prueba 2", errors_manager.type("Hola xD")])
print(["Prueba 3", errors_manager.type(None)])
print(["Prueba 4", errors_manager.type(5)])
print(["Prueba 5", errors_manager.type(-8)])
print(["Prueba 6", errors_manager.type(-104.56)])
print(["Prueba 7", errors_manager.type(6.007)])
print(["Prueba 8", errors_manager.type(.345)])
print(["Prueba 9", errors_manager.type(ErrorsManager)])
print(["Prueba 10", errors_manager.type(errors_manager)])
print(["Prueba 11", errors_manager.type(["Esto es un String"])])
print(["Prueba 12", errors_manager.type(['S', 't', 'r', 'i', 'n', 'g'])])
print(["Prueba 13", errors_manager.type(True)])
print(["Prueba 14", errors_manager.type(False)])
print(["Prueba 15", errors_manager.type((True,))])
print(["Prueba 16", errors_manager.type([2, 45, 18, 24])])

typejs
characters1040
lines22

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.type("")]);
console.log(["Prueba 2", errors_manager.type("Hola xD")]);
console.log(["Prueba 3", errors_manager.type(null)]);
console.log(["Prueba 4", errors_manager.type(5)]);
console.log(["Prueba 5", errors_manager.type(-8)]);
console.log(["Prueba 6", errors_manager.type(-104.56)]);
console.log(["Prueba 7", errors_manager.type(6.007)]);
console.log(["Prueba 8", errors_manager.type(.345)]);
console.log(["Prueba 9", errors_manager.type(ErrorsManager)]);
console.log(["Prueba 10", errors_manager.type(errors_manager)]);
console.log(["Prueba 11", errors_manager.type(["Esto es un String"])]);
console.log(["Prueba 12", errors_manager.type(['S', 't', 'r', 'i', 'n', 'g'])]);
console.log(["Prueba 13", errors_manager.type(true)]);
console.log(["Prueba 14", errors_manager.type(false)]);
console.log(["Prueba 15", errors_manager.type([true])]);
console.log(["Prueba 16", errors_manager.type([2, 45, 18, 24])]);

En los ejemplos anteriores sacaríamos los siguientes resultados:

Prueba	Python	JavaScript
1	string	string
2	string	string
3	unknown	unknown
4	integer	integer
5	integer	integer
6	unknown	unknown
7	unknown	unknown
8	unknown	unknown
9	unknown	unknown
10	unknown	unknown
11	array	array
12	array	array
13	unknown	unknown
14	unknown	unknown
15	array	array
16	array	array
Prueba	Python	JavaScript

manual/process.w.md

process

ErrorsManager.process

Array<Array<Integer, String>>objectpublicErrorsManager.processRequiredInteger|String|Array<Integer>codeRequiredArray<String>messages

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
messages	True	False	Array<String>
Name	Required	Nullable	Typed	Default Value

El método process es un método objeto que retorna el alfabeto actualmente en uso del objeto ErrorsManager.

typepy
characters384
lines13

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

i:int
errors_manager:ErrorsManager = ErrorsManager()
error_messages:tuple[str] = ["error_message_" + str(i) for i in range(16)]

print(errors_manager.process(105, error_messages))
print(errors_manager.process("pB", error_messages))
print(errors_manager.process([41, 1], error_messages))

typejs
characters396
lines11

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager(), 
      /** @type {Array.<String>} */
      error_messages = "0123456789abcdef".split("").map((_, i) => "error_message_" + i);

console.log(errors_manager.process(105, error_messages));
console.log(errors_manager.process("pB", error_messages));
console.log(errors_manager.process([41, 1], error_messages));

El resultado de estas pruebas es:

i	Bit	Mensaje
0	0	error_message_0
3	3	error_message_3
5	5	error_message_5
6	6	error_message_6
i	Bit	Mensaje

Esto viene siendo porque el código de error se puede ver de la siguiente forma:

Byte	String	Array	Binario
0	p	41	101001
1	B	1	000001
Byte	String	Array	Binario

Si unimos todos los valores en un único binario tendríamos:

105 = [1, 41] = [000001, 101001] = 000001101001 = 1101001

Si miramos las posiciones de los bytes tenemos:

Bit	Valor	Mensaje
0	1	error_message_0
1	0
2	0
3	1	error_message_3
4	0
5	1	error_message_5
6	1	error_message_6
7	0
8	0
9	0
10	0
11	0
Bit	Valor	Mensaje

manual/bits.w.md

bits

ErrorsManager.bits

integerobjectpublicErrorsManager.bitsRequiredInteger|String|Array<Integer>code

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
Name	Required	Nullable	Typed	Default Value

El método bits es un método objeto que retorna el número de bits que contiene el código de error, que viene siendo el número de comprobaciones Booleanas que contiene.

typepy
characters246
lines11

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.bits(105))
print(errors_manager.bits("pB"))
print(errors_manager.bits([41, 1]))

typejs
characters213
lines9

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(errors_manager.bits(105));
console.log(errors_manager.bits("pB"));
console.log(errors_manager.bits([41, 1]));

La respuesta en todos los casos sería 7.

Es importante destacar que el número de Bits parte desde la última comprobación de error Booleano que dio "true", es decir, si se esperan 20 comprobaciones pero los últimos valores de comprobación son "false", es decir, que no tienen error, éstos no saldrán reflejados en el valor de bits final, a excepción de valores de relleno que pueden ser dados en los Sring y los Array.

manual/to_array.w.md

to_array

ErrorsManager.to_array

Array<Integer>objectpublicErrorsManager.to_arrayRequiredInteger|String|Array<Integer>codeIntegerlength

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
length	False	False	Integer
Name	Required	Nullable	Typed	Default Value

El método to_array es un método objeto que transforma un código de error cualquiera en un código de error de tipo Array con la opción de especificar bits de relleno con 0.

typepy
characters384
lines15

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.to_array(105))
print(errors_manager.to_array("pB"))
print(errors_manager.to_array([41, 1]))

print(errors_manager.to_array(105, 20))
print(errors_manager.to_array("pB", 20))
print(errors_manager.to_array([41, 1], 20))

typejs
characters372
lines13

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(errors_manager.to_array(105));
console.log(errors_manager.to_array("pB"));
console.log(errors_manager.to_array([41, 1]));

console.log(errors_manager.to_array(105, 20));
console.log(errors_manager.to_array("pB", 20));
console.log(errors_manager.to_array([41, 1], 20));

La respuesta en 3 primeros casos sería el Array [41, 1], mientras que en los otros 3 sería [41, 1, 0, 0].

Si se especifica el valor "length", éste rellenará el Array con tantos 0 como requiera.

manual/to_array_binary.w.md

to_array_binary

ErrorsManager.to_array_binary

Array<String>objectpublicErrorsManager.to_array_binaryRequiredInteger|String|Array<Integer>code

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
Name	Required	Nullable	Typed	Default Value

El método to_array_binary es un método objeto que transforma un código de error cualquiera en un Array de hexas en binario en formato String.

typepy
characters279
lines11

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.to_array_binary(105))
print(errors_manager.to_array_binary("pB"))
print(errors_manager.to_array_binary([41, 1]))

typejs
characters246
lines9

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(errors_manager.to_array_binary(105));
console.log(errors_manager.to_array_binary("pB"));
console.log(errors_manager.to_array_binary([41, 1]));

La respuesta en todos los casos sería el Array ["101001", "000001"].

El valor devuelto por este método no es trabajable como código de error pues sólo existe a modo de comprobaciones.

manual/to_integer.w.md

to_integer

ErrorsManager.to_integer

IntegerobjectpublicErrorsManager.to_integerRequiredInteger|String|Array<Integer>code

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
Name	Required	Nullable	Typed	Default Value

El método to_integer es un método objeto que transforma un código de error cualquiera en un código de error de tipo Integer.

typepy
characters264
lines11

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.to_integer(105))
print(errors_manager.to_integer("pB"))
print(errors_manager.to_integer([41, 1]))

typejs
characters231
lines9

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(errors_manager.to_integer(105));
console.log(errors_manager.to_integer("pB"));
console.log(errors_manager.to_integer([41, 1]));

La respuesta en todos los casos sería el valor numérico entero 105.

IMPORTANTE
Si el código de error tiene más Bits de los que puede trabajar el lenguaje donde se encuentra la librería, éste detendrá el proceso con una Excepción.

manual/to_string.w.md

to_string

ErrorsManager.to_string

StringobjectpublicErrorsManager.to_stringRequiredInteger|String|Array<Integer>codeIntegerlength

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
length	False	False	Integer
Name	Required	Nullable	Typed	Default Value

El método to_string es un método objeto que transforma un código de error cualquiera en un código de error de tipo String con la opción de especificar bits de relleno con el equivalente a 0 en el alfabeto seleccionado.

typepy
characters390
lines15

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(errors_manager.to_string(105))
print(errors_manager.to_string("pB"))
print(errors_manager.to_string([41, 1]))

print(errors_manager.to_string(105, 20))
print(errors_manager.to_string("pB", 20))
print(errors_manager.to_string([41, 1], 20))

typejs
characters378
lines13

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(errors_manager.to_string(105));
console.log(errors_manager.to_string("pB"));
console.log(errors_manager.to_string([41, 1]));

console.log(errors_manager.to_string(105, 20));
console.log(errors_manager.to_string("pB", 20));
console.log(errors_manager.to_string([41, 1], 20));

La respuesta en 3 primeros casos sería el String "pB", mientras que en los otros 3 sería "pBAA".

Si se especifica el valor "length", éste rellenará el String con tantos caracteres equivalentes a 0 como requiera. En el caso de ser el alfabeto por defecto, es decir, un Base64, el caracter equivalente a 0 es el caracter "A".

manual/to_unknown.w.md

to_unknown

ErrorsManager.to_unknown

Any|nullobjectpublicErrorsManager.to_unknownNullishAnycode

Name	Required	Nullable	Typed	Default Value
code	False	True	Any
Name	Required	Nullable	Typed	Default Value

El método to_unknown es un método objeto que sirve para ejecutar en caso de ser un tipado no conocido por la librería como código de error. Básicamente retorna el mismo valor que se le da.

typepy
characters475
lines14

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(["Prueba 1", errors_manager.to_unknown(105)])
print(["Prueba 2", errors_manager.to_unknown("pB")])
print(["Prueba 3", errors_manager.to_unknown([41, 1])])
print(["Prueba 4", errors_manager.to_unknown(None)])
print(["Prueba 5", errors_manager.to_unknown(errors_manager)])
print(["Prueba 5", errors_manager.to_unknown(True)])

typejs
characters463
lines12

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.to_unknown(105)]);
console.log(["Prueba 2", errors_manager.to_unknown("pB")]);
console.log(["Prueba 3", errors_manager.to_unknown([41, 1])]);
console.log(["Prueba 4", errors_manager.to_unknown(null)]);
console.log(["Prueba 5", errors_manager.to_unknown(errors_manager)]);
console.log(["Prueba 5", errors_manager.to_unknown(true)]);

Los resultados serían los siguientes:

Prueba	Python	Javascript
1	105
2	pB
3	[41, 1]
4	None	null
5	errors_manager[ErrorsManager]
6	True	true
Prueba	Python	Javascript

manual/has.w.md

has

ErrorsManager.has

BooleanobjectpublicErrorsManager.hasRequiredInteger|String|Array<Integer>codeInteger|Array<Integer>bits

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
bits	False	False	Integer\|Array<Integer>
Name	Required	Nullable	Typed	Default Value

El método has es un método objeto que verifica si hay error o no en el código dado o en un o varios bits dados.

typepy
characters1239
lines35

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(("Prueba 1", errors_manager.has(0)))
print(("Prueba 2", errors_manager.has("A")))
print(("Prueba 3", errors_manager.has([0, 0])))

print(("Prueba 4", errors_manager.has(105)))
print(("Prueba 5", errors_manager.has("pB")))
print(("Prueba 6", errors_manager.has([41, 1])))

print(("Prueba 7", errors_manager.has(105, 5)))
print(("Prueba 8", errors_manager.has("pB", 5)))
print(("Prueba 9", errors_manager.has([41, 1], 5)))

print(("Prueba 10", errors_manager.has(105, 4)))
print(("Prueba 11", errors_manager.has("pB", 4)))
print(("Prueba 12", errors_manager.has([41, 1], 4)))

print(("Prueba 13", errors_manager.has(105, (5, 6))))
print(("Prueba 14", errors_manager.has("pB", (5, 6))))
print(("Prueba 15", errors_manager.has([41, 1], (5, 6))))

print(("Prueba 16", errors_manager.has(105, (4, 5, 6))))
print(("Prueba 17", errors_manager.has("pB", (4, 5, 6))))
print(("Prueba 18", errors_manager.has([41, 1], (4, 5, 6))))

print(["Prueba 19", errors_manager.has(105, (1, 2))])
print(["Prueba 20", errors_manager.has("pB", (1, 2))])
print(["Prueba 121", errors_manager.has([41, 1], (1, 2))])

typejs
characters1332
lines33

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(["Prueba 1", errors_manager.has(0)]);
console.log(["Prueba 2", errors_manager.has("A")]);
console.log(["Prueba 3", errors_manager.has([0, 0])]);

console.log(["Prueba 4", errors_manager.has(105)]);
console.log(["Prueba 5", errors_manager.has("pB")]);
console.log(["Prueba 6", errors_manager.has([41, 1])]);

console.log(["Prueba 7", errors_manager.has(105, 5)]);
console.log(["Prueba 8", errors_manager.has("pB", 5)]);
console.log(["Prueba 9", errors_manager.has([41, 1], 5)]);

console.log(["Prueba 10", errors_manager.has(105, 4)]);
console.log(["Prueba 11", errors_manager.has("pB", 4)]);
console.log(["Prueba 12", errors_manager.has([41, 1], 4)]);

console.log(["Prueba 13", errors_manager.has(105, [5, 6])]);
console.log(["Prueba 14", errors_manager.has("pB", [5, 6])]);
console.log(["Prueba 15", errors_manager.has([41, 1], [5, 6])]);

console.log(["Prueba 16", errors_manager.has(105, [4, 5, 6])]);
console.log(["Prueba 17", errors_manager.has("pB", [4, 5, 6])]);
console.log(["Prueba 18", errors_manager.has([41, 1], [4, 5, 6])]);

console.log(["Prueba 19", errors_manager.has(105, [1, 2])]);
console.log(["Prueba 20", errors_manager.has("pB", [1, 2])]);
console.log(["Prueba 121", errors_manager.has([41, 1], [1, 2])]);

La respuesta a estos ejemplos sería:

Prueba	Python	JavaScript
1	False	false
2	False	false
3	False	false
4	True	true
5	True	true
6	True	true
7	True	true
8	True	true
9	True	true
10	False	false
11	False	false
12	False	false
13	True	true
14	True	true
15	True	true
16	True	true
17	True	true
18	True	true
19	False	false
20	False	false
21	False	false
Prueba	Python	JavaScript

Cuando se especifican los Bits, éstos han de cumplirse en todos los casos.

manual/has_range.w.md

has_range

ErrorsManager.has_range

BooleanobjectpublicErrorsManager.has_rangeRequiredInteger|String|Array<Integer>codeRequiredInteger_fromInteger_to

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer\|String\|Array<Integer>
_from	True	False	Integer
_to	False	False	Integer
Name	Required	Nullable	Typed	Default Value

El método has_range es un método objeto que verifica si hay error o no en un rango de bits del código dado o no.

typepy
characters846
lines23

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()

print(("Prueba 1", errors_manager.has_range(105, 2, 6)))
print(("Prueba 2", errors_manager.has_range("pB", 2, 6)))
print(("Prueba 3", errors_manager.has_range([41, 1], 2, 6)))

print(("Prueba 4", errors_manager.has_range(105, 1, 2)))
print(("Prueba 5", errors_manager.has_range("pB", 1, 2)))
print(("Prueba 6", errors_manager.has_range([41, 1], 1, 2)))

print(("Prueba 7", errors_manager.has_range(105, 4)))
print(("Prueba 8", errors_manager.has_range("pB", 4)))
print(("Prueba 9", errors_manager.has_range([41, 1], 4)))

print(("Prueba 10", errors_manager.has_range(105, 0, 2)))
print(("Prueba 11", errors_manager.has_range("pB", 0, 2)))
print(("Prueba 12", errors_manager.has_range([41, 1], 0, 2)))

typejs
characters876
lines21

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

console.log(("Prueba 1", errors_manager.has_range(105, 2, 6)));
console.log(("Prueba 2", errors_manager.has_range("pB", 2, 6)));
console.log(("Prueba 3", errors_manager.has_range([41, 1], 2, 6)));

console.log(("Prueba 4", errors_manager.has_range(105, 1, 2)));
console.log(("Prueba 5", errors_manager.has_range("pB", 1, 2)));
console.log(("Prueba 6", errors_manager.has_range([41, 1], 1, 2)));

console.log(("Prueba 7", errors_manager.has_range(105, 4)));
console.log(("Prueba 8", errors_manager.has_range("pB", 4)));
console.log(("Prueba 9", errors_manager.has_range([41, 1], 4)));

console.log(("Prueba 10", errors_manager.has_range(105, 0, 2)));
console.log(("Prueba 11", errors_manager.has_range("pB", 0, 2)));
console.log(("Prueba 12", errors_manager.has_range([41, 1], 0, 2)));

La respuesta a estos ejemplos sería:

Prueba	Python	JavaScript
1	True	true
2	True	true
3	True	true
4	False	false
5	False	false
6	False	false
7	False	false
8	False	false
9	False	false
10	True	true
11	True	true
12	True	true
Prueba	Python	JavaScript

El atributo _from es obligatorio, sin embargo, el atributo _to es opcional. Cuando _to no está definido se entiende que es hasta el último Bit.

manual/compact.w.md

compact

ErrorsManager.compact

IntegerobjectpublicErrorsManager.compactRequiredIntegercode

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer
Name	Required	Nullable	Typed	Default Value

ErrorsManager.compact

StringobjectpublicErrorsManager.compactRequiredStringcode

Name	Required	Nullable	Typed	Default Value
code	True	False	String
Name	Required	Nullable	Typed	Default Value

ErrorsManager.compact

Array<Integer>objectpublicErrorsManager.compactRequiredArray<Integer>code

Name	Required	Nullable	Typed	Default Value
code	True	False	Array<Integer>
Name	Required	Nullable	Typed	Default Value

El método compact es un método objeto que elimina los ceros a la izquierda del código de error en formao Array o String. Cuando a éste se le envía el formato Integer, éste retornará el mismo pues los valores numéricos enteros no tienen dicha propiedad.

typepy
characters474
lines20

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()
value:int|str|list[int]

for i, value in enumerate((105, "pBAA", [41, 1, 0, 0])):

    compacted:int|str|list[int] = errors_manager.compact(value)

    print([
        "Prueba " + str(i), 
        value, 
        errors_manager.to_array_binary(value), 
        compacted, 
        errors_manager.to_array_binary(compacted)
    ])

typejs
characters436
lines20

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager();

[105, "pBAA", [41, 1, 0, 0]].forEach((value, i) => {

    /** @type {number|String|Array.<number>} */
    const compacted = errors_manager.compact(value);

    console.log([
        "Prueba " + i, 
        value, 
        errors_manager.to_array_binary(value), 
        compacted, 
        errors_manager.to_array_binary(compacted)
    ]);

});

El resultado de estas pruebas son los siguientes:

Prueba	Valor	Binario	Compactado	Binario compactado
0	105	["101001", "000001"]	105	["101001", "000001"]
1	pBAA	["101001", "000001", "000000", "000000"]	pB	["101001", "000001"]
2	[41, 1, 0, 0]	["101001", "000001", "000000", "000000"]	[41, 1]	["101001", "000001"]
Prueba	Valor	Binario	Compactado	Binario compactado

Los binarios aquí representados están en base al método objeto de pruebas to_array_binary, y es posible que no se espere dicho binario del valor dado por su orden, pero es el método que se usa para hacer las comprobaciones pertinentes.

Los valores compactados lo único que hacen es simplificar el valor a la mínima unidad como valor, en el caso de los String como caracteres; y en el caso de los Array como enteros, motivo por el cual, cuando salen los binarios compactados salen con ceros a la izquierda en el último bloque binario, sin embargo, podemos ver que lo que son bloques completamente 0 se eliminarán.

manual/bitwise.w.md

bitwise

ErrorsManager.bitwise

IntegerobjectpublicErrorsManager.bitwiseRequiredIntegercodeRequiredIntegerbits

Name	Required	Nullable	Typed	Default Value
code	True	False	Integer
bits	True	False	Integer
Name	Required	Nullable	Typed	Default Value

ErrorsManager.bitwise

StringobjectpublicErrorsManager.bitwiseRequiredStringcodeRequiredIntegerbits

Name	Required	Nullable	Typed	Default Value
code	True	False	String
bits	True	False	Integer
Name	Required	Nullable	Typed	Default Value

ErrorsManager.bitwise

Array<Integer>objectpublicErrorsManager.bitwiseRequiredArray<Integer>codeRequiredIntegerbits

Name	Required	Nullable	Typed	Default Value
code	True	False	Array<Integer>
bits	True	False	Integer
Name	Required	Nullable	Typed	Default Value

El método bitwise es un método objeto nos permite hacer desplazamiento de Bit en el código de error tantos Bits como queramos, siendo el número de Bits positivo hacia la izquierda, creando los Bits requeridos; y siendo el número de Bits negativo hacia la derecha, eliminando consigo ese número de Bits por ese lado.

typepy
characters585
lines25

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from Assets.ErrorsManager import ErrorsManager

errors_manager:ErrorsManager = ErrorsManager()
options:tuple[int] = (-10, -5, -3, -1, 0, 1, 3, 5, 10)
value:int|str|list[int]

for i, value in enumerate((105, "pB", [41, 1])):

    bits:int

    for bits in options:

        new_value:int|str|list[int] = errors_manager.bitwise(value, bits)

        print((
            value, 
            errors_manager.to_array_binary(value), 
            bits, 
            new_value, 
            errors_manager.to_array_binary(new_value)
        ))

typejs
characters538
lines22

"use strict";

/** @type {ErrorsManager} */
const errors_manager = new ErrorsManager(), 
      /** @type {Array.<number>} */
      options = [-10, -5, -3, -1, 0, 1, 3, 5, 10];

[105, "pB", [41, 1]].forEach((value, i) => options.forEach(bits => {

    /** @type {number|String|Array.<number>} */
    const new_value = errors_manager.bitwise(value, bits);

    console.log([
        value, 
        errors_manager.to_array_binary(value), 
        bits, 
        new_value, 
        errors_manager.to_array_binary(new_value)
    ]);

}));

El resultado de estas pruebas son los siguientes:

Valor	Binario	Bits	Desplazado	Binario desplazado
105	["101001", "000001"]	-10	0	["000000"]
105	["101001", "000001"]	-5	3	["000011"]
105	["101001", "000001"]	-3	13	["001101"]
105	["101001", "000001"]	-1	52	["110100"]
105	["101001", "000001"]	0	105	["101001", "000001"]
105	["101001", "000001"]	1	210	["010010", "000011"]
105	["101001", "000001"]	3	840	["001000", "001101"]
105	["101001", "000001"]	5	3360	["100000", "110100"]
105	["101001", "000001"]	10	107520	["000000", "010000", "011010"]
pB	["101001", "000001"]	-10	A	["000000"]
pB	["101001", "000001"]	-5	DA	["000011", "000000"]
pB	["101001", "000001"]	-3	NA	["001101", "000000"]
pB	["101001", "000001"]	-1	0A	["110100", "000000"]
pB	["101001", "000001"]	0	pB	["101001", "000001"]
pB	["101001", "000001"]	1	SD	["010010", "000011"]
pB	["101001", "000001"]	3	IN	["001000", "001101"]
pB	["101001", "000001"]	5	g0	["100000", "110100"]
pB	["101001", "000001"]	10	AQa	["000000", "010000", "011010"]
[41, 1]	["101001", "000001"]	-10	[0]	["000000"]
[41, 1]	["101001", "000001"]	-5	[3, 0]	["000011", "000000"]
[41, 1]	["101001", "000001"]	-3	[13, 0]	["001101", "000000"]
[41, 1]	["101001", "000001"]	-1	[52, 0]	["110100", "000000"]
[41, 1]	["101001", "000001"]	0	[41, 1]	["101001", "000001"]
[41, 1]	["101001", "000001"]	1	[18, 3]	["010010", "000011"]
[41, 1]	["101001", "000001"]	3	[8, 13]	["001000", "001101"]
[41, 1]	["101001", "000001"]	5	[32, 52]	["100000", "110100"]
[41, 1]	["101001", "000001"]	10	[0, 16, 26]	["000000", "010000", "011010"]
Valor	Binario	Bits	Desplazado	Binario desplazado

manual/set.w.md

set

ErrorsManager.set

StringobjectpublicErrorsManager.setRequiredStringcodeRequiredIntegererrorIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	String
error	True	False	Integer
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

El método set es un método objeto que nos permite realizar dos acciones:

Establecer un valor numérico a nuestro código de error en formato String actual en una posición específica.
Y también nos permite resetear Bits del código de error a 0.

Ambas funciones de establecer valor y resetear a cero son mezclables, es decir, cuando se establece un valor, éste se une mediante "OR" al código actual desde la posición que se le determine, por tanto, si lo que se quiere es substituir Bits lo que hay que hacer es pasar a cero los Bits que se crean que vayan a ser alterados.

Es importante destacar que en lenguajes de tipados flexibles como JavaScript, esta función puede cubrir no sólo códigos de error en formato numérico entero sino también en String y Array, y es el motivo por el cual se puede encontrar este método como unificado en dichos entornos. Para este motivo tendríamos la siguiente estructura de método.

ErrorsManager.set

StringobjectpublicErrorsManager.setRequired(String|Integer|Array<Integer>)codeRequired(String|Integer|Array<Integer>)errorIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	(String\|Integer\|Array<Integer>)
error	True	False	(String\|Integer\|Array<Integer>)
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

Para lenguajes rígidos como los SQL, C#, etc. Para poder integrar otro código de error String es necesario llamar al método "join" en vez de a éste, en los lenguajes flexibles puede hacerse uso de ambos.

manual/join.w.md

join

ErrorsManager.set

StringobjectpublicErrorsManager.setRequiredStringcodeRequiredstringerrorIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	String
error	True	False	string
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

El método join es un método objeto que nos permite realizar dos acciones:

Unir dos códigos de error en formato String, el segundo sobre el primero en la posición dada.
Y también nos permite resetear Bits del código de error a 0.

Ambas funciones de unir códigos y resetear a cero son mezclables, es decir, cuando se une un segundo código de error en formato String, éste se une mediante "OR" al código actual desde la posición que se le determine, por tanto, si lo que se quiere es substituir Bits lo que hay que hacer es pasar a cero los Bits que se crean que vayan a ser alterados.

Es importante destacar que en lenguajes de tipados flexibles como JavaScript, esta función puede cubrir no sólo códigos de error en formato numérico String sino también en Integer y Array, y es el motivo por el cual se puede encontrar este método como unificado en dichos entornos. Para este motivo tendríamos la siguiente estructura de método.

ErrorsManager.join

StringobjectpublicErrorsManager.joinRequired(String|Integer|Array<Integer>)codeRequired(String|Integer|Array<Integer>)errorIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	(String\|Integer\|Array<Integer>)
error	True	False	(String\|Integer\|Array<Integer>)
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

Para lenguajes rígidos como los SQL, C#, etc. Para poder integrar otro código de error Integer es necesario llamar al método "set" en vez de a éste, en los lenguajes flexibles puede hacerse uso de ambos.

manual/set_blocks.w.md

set_blocks

ErrorsManager.set_blocks

StringobjectpublicErrorsManager.set_blocksRequiredStringcodeRequiredArray.<Integer>blocksIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	String
blocks	True	False	Array.<Integer>
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

El método set_blocks es un método objeto que nos permite realizar dos acciones:

Establecer uno o más códigos de error en formato Integer sobre otro en formato String ya dado.
Y también nos permite resetear Bits del código de error a 0.

Es importante destacar que en lenguajes de tipados flexibles como JavaScript, esta función puede cubrir no sólo códigos de error en formato numérico entero sino también en String y Array, y es el motivo por el cual se puede encontrar este método como unificado en dichos entornos. Para este motivo tendríamos la siguiente estructura de método.

ErrorsManager.set

StringobjectpublicErrorsManager.setRequired(String|Integer|Array<Integer>)codeRequired(String|Integer|Array<Integer>)errorIntegerbit0Integerlength00

Name	Required	Nullable	Typed	Default Value
code	True	False	(String\|Integer\|Array<Integer>)
error	True	False	(String\|Integer\|Array<Integer>)
bit	False	False	Integer	0
length	False	False	Integer	0
Name	Required	Nullable	Typed	Default Value

Para lenguajes rígidos como los SQL, C#, etc. Para poder integrar otro código de error String es necesario llamar al método "join" en vez de a éste, en los lenguajes flexibles puede hacerse uso de ambos.

manual/slice.w.md

doc/es/faq.w.md

F.A.Q.

En este apartado se responderán a las preguntas más frecuentes que se puedan realizar en el entorno cercano de este proyecto.

¿Por qué la realización de este proyecto pudiendo gestionar los errores mediante matrices, enviando consigo los textos descriptivos de cada uno de los errores? En teoría, las diferentes capas de una aplicación podrían estar desarrolladas en distintos entornos de desarrollo, por ejemplo, no es lo mismo trabajar procedimientos almacenados desde una base de datos que controladores en el servidor o métodos en el cliente. Para poder compatibilizar todos estos entornos cuando entre ellos consumen servicios expuestos, éstos han de conocer las posibles respuestas y consigo, los distintos mensajes de error que se devuelvan, por tanto, para ahorrar ancho de banda, ya sea a nivel local, de red o Internet, es mejor, en estos casos concretos, enviar un código que defina y especifique todo antes que toda aquella información al respecto que puede ser bastante. Al no existir un sistema unificado para dicho fin con las características de longitud y eficiencia deseada, por lo menos, desde el conocimiento de Srx00, pues éste decidió crear esta librería.

¿Por qué este trabajo está público y gratuito? Esta librería es una librería que sí o sí iba a desarrollar Srx00 para los fines de los distintos proyectos que desarrolla. Al no tener un modelo de negocio y no estar sujeto a clientes, éste quedará libre y gratuito, dentro de los términos y condiciones de la licencia Creative Commons BY-NC-SA 4.0. Ésto permite no sólo compartir con la comunidad, sino también currículum y una forma de extender el conocimiento de existencia de este tipo de proyectos de Srx00.

¿Por qué la licencia Creative Commons de Atribución, No Comercial y que se Permite Compartir, CC-BY-NC-SA 4.0? Porque Srx00 quiere compartir con la comunidad este trabajo, sin embargo, una de las condiciones más importantes es reconocer la autoría original, lo que ofrece Currículum y conocimiento del trabajo del o los autores, además de no permitir la comercialización de dicho proyecto, lo que no impide que éste pueda estar en un proyecto comercial siempre que lo que se venda no sea este proyecto. Las licencias como MIT o GPL no cumplen con dichas espectativas y Srx00 tiene la filosofía de que todo trabajo ha de ser reconocido a su autor aunque éste no lo requiera o precise pues es su trabajo.

Al ser un proyecto CC-BY-NC-SA 4.0, el cual tiene como condición No Comercial. ¿Podría integrar este proyecto en un proyecto personal de caracter privado y comercial? Sí, siempre que éste reconozca la autoría de este proyecto y que no sea éste la base de negocio económico de dicho proyecto, es decir, si se integra para gestionar los errores del proyecto o cualquier otra cosa que ayude o facilite el trabajo del mismo pero la base económica del proyecto sea otra cosa agena a eso se permite perfectamente el uso y manipulación del mismo.

doc/es/bugs.w.md

Bugs

En esta sección se listarán los bugs encontrados en la librería y el estado en el que se encuentran para su reparación por parte de los desarrolladores.

doc/es/targets.w.md

Objetvos

Para ver el estado del proyecto con respecto a lo que sería el objetivo final, tenemos lo siguiente:

doc/es/opinions.w.md

Opiniones y comentarios

Esta sección va dedicada a publicar las opiniones y comentarios de usuarios cercanos a los desarrolladores del proyecto para que halla una visión externa a éste, aprobechando la confianza en éstos tanto para lo bueno como para lo malo.

Srx00
Quería agradecer personalmente a todos aquellos que me han dado una opinión y/o comentario acerca de este proyecto. Lo valoro mucho pues sea como crítica para aprender como apoyo a continuar con este tipo de trabajos, me son realmente importantes. ¡Muchas gracias!

Srx00
Como opinión personal, es un proyecto raro, que le da mayor complejidad a la aplicación en desarrollo como cuando le metes cualquier librería que añade una nueva funcionalidad, sin embargo, es cierto que si lo vemos desde el punto de vista de la gestión de errores, creo, a nivel personal, por mi experiencia, que éste puede ser una herramienta fuerte para gestionar los errores tanto a nivel local como entre plataformas o diferentes entornos del lenguaje dentro de un mismo proyecto, sin embargo, creo de vital importancia destacar que si se puede omitir el uso de dichas funciones, por ejemplo, para aquellos errores que contengan menos de 28 verificaciones, ahorraría tanto coste de dificultad como coste de proceso. Al ser una herramienta compatible directamente con enteros, es una forma de darle eficiencia a tu proyecto y no rompería mucho la estructura de funcionamiento con esta librería en la medida de lo posible.

doc/es/donates.w.md

Donaciones

Este proyecto es plenamente gratuito pues es un proyecto orientado a complementar otros proyectos de los mismos desarrolladores. No tiene ningún plan de ingresos ni pasivos ni activos más allá de lo que se expone en este título. Si alguien quisiere colaborar en que este proyecto no sólo esté abierto por requisitos de los autores, sino también cara un mantenimiento hacia terceros, a continuación presentamos unas direcciones de Cryptoactivos donde se podrá donar sin ninguna cuantía mínima establecida.

Bitcoin o BTC: bc1qypwl4063lhcjx7zmktqrs7n7s3dypwn5nr6h9u
Litecoin o LTC: ltc1qlqmy4pzl9f2kmqrgn8prfkjrndnnqw770j77ey
Dogecoin o DOGE: DA8dwyPzs9KL3mZWQh1feJztPhq8dn7QRq
Dash: Xp8EnKd6PdhiLiibPhb9joQHqKcb2LvDMn
Faircoin o FAIR: fLG4irvJt1xt67kPDTjEbNinXW3vUFvKzQ

Mientras no halla ninguna condición de recursos que impida el mantenimiento gratuito de este servicio, éste permanecerá mantenido y público independientemente de los ingresos obtenidos a partir de los donativos.

Los usuarios que colaboren y quieran ser referenciados, éstos serán referenciados en este apartado mediante un Quote de comentario de usuario con el Nick y avatar correspondiente, pero sólo en caso de que ellos quieran aparecer aquí.

Se mantendrá informados a los usuarios de todo aquel donativo dado y la cantidad económica adquirida, y será publicado su uso y tenencia para que halla constancia pública del uso que se le dé a dichos recursos.

Srx00
Quería agredecer de forma persona aquellas aportaciones que serán bien recibidas y valoradas para este proyecto, ya sea como valor simbólico como de mantenimiento. Así, que desde el desarrollo y como desarrollador de este proyecto, muchas gracias a todos aquellos que ponen su granito de arena para este proyecto y por lo tanto, en pro de todos. Muchas gracias, de verdad.

Balance

A continuación se mostrará una tabla de balance con respecto a las cantidades y usos dados.

Activo	Cantidad	Motivo	Usuario	Cantidad total actual
BTC	0 BTC	Inicio del contador de unidades de BTC.		0 BTC
LTC	0 LTC	Inicio del contador de unidades de LTC.		0 LTC
DOGE	0 DOGE	Inicio del contador de unidades de DOGE.		0 DOGE
DASH	0 DASH	Inicio del contador de unidades de DASH.		0 DASH
FAIR	0 FAIR	Inicio del contador de unidades de FAIR.		0 FAIR
Activo	Cantidad	Motivo	Usuario	Cantidad total actual

Cómputo total actual en tenencia.

Activo	Cantidad	Número de Operaciones
BTC	0 BTC	0
LTC	0 LTC	0
DOGE	0 DOGE	0
DASH	0 DASH	0
FAIR	0 FAIR	0
Activo	Cantidad	Número de Operaciones

Donantes

A continuación, los comentarios de los donantes.