ErrorsManager

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
NameRequiredNullableTypedDefault Value
alphabetTrueTrueString
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
valueTrueTrueAny
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1Truetrue
2Truetrue
3Truetrue
4Falsefalse
5Falsefalse
6Falsefalse
7Falsefalse
8Falsefalse
9Falsefalse
10Falsefalse
11Falsefalse
12Falsefalse
13Falsefalse
14Falsefalse
15Falsefalse
16Falsefalse
PruebaPythonJavaScript
manual/is_integer.w.md

is_integer

ErrorsManager.is_integer
BooleanstaticpublicErrorsManager.is_integerRequiredNullishAnyvalue
NameRequiredNullableTypedDefault Value
valueTrueTrueAny
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1Falsefalse
2Falsefalse
3Falsefalse
4Truetrue
5Truetrue
6Falsefalse
7Falsefalse
8Falsefalse
9Falsefalse
10Falsefalse
11Falsefalse
12Falsefalse
13Falsefalse
14Falsefalse
15Falsefalse
16Falsefalse
PruebaPythonJavaScript
manual/is_array.w.md

is_array

ErrorsManager.is_array
BooleanstaticpublicErrorsManager.is_arrayRequiredNullishAnyvalue
NameRequiredNullableTypedDefault Value
valueTrueTrueAny
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1Falsefalse
2Falsefalse
3Falsefalse
4Falsefalse
5Falsefalse
6Falsefalse
7Falsefalse
8Falsefalse
9Falsefalse
10Falsefalse
11Truetrue
12Truetrue
13Falsefalse
14Falsefalse
15Truetrue
16Truetrue
PruebaPythonJavaScript
manual/type.w.md

type

ErrorsManager.type
StringstaticpublicErrorsManager.typeRequiredNullishAnyvalue
NameRequiredNullableTypedDefault Value
valueTrueTrueAny
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1stringstring
2stringstring
3unknownunknown
4integerinteger
5integerinteger
6unknownunknown
7unknownunknown
8unknownunknown
9unknownunknown
10unknownunknown
11arrayarray
12arrayarray
13unknownunknown
14unknownunknown
15arrayarray
16arrayarray
PruebaPythonJavaScript
manual/process.w.md

process

ErrorsManager.process
Array<Array<Integer, String>>objectpublicErrorsManager.processRequiredInteger|String|Array<Integer>codeRequiredArray<String>messages
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
messagesTrueFalseArray<String>
NameRequiredNullableTypedDefault 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:

iBitMensaje
00error_message_0
33error_message_3
55error_message_5
66error_message_6
iBitMensaje

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

ByteStringArrayBinario
0p41101001
1B1000001
ByteStringArrayBinario

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:

BitValorMensaje
01error_message_0
10
20
31error_message_3
40
51error_message_5
61error_message_6
70
80
90
100
110
BitValorMensaje
manual/bits.w.md

bits

ErrorsManager.bits
integerobjectpublicErrorsManager.bitsRequiredInteger|String|Array<Integer>code
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
lengthFalseFalseInteger
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
lengthFalseFalseInteger
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeFalseTrueAny
NameRequiredNullableTypedDefault 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:

PruebaPythonJavascript
1105
2pB
3[41, 1]
4Nonenull
5errors_manager[ErrorsManager]
6Truetrue
PruebaPythonJavascript
manual/has.w.md

has

ErrorsManager.has
BooleanobjectpublicErrorsManager.hasRequiredInteger|String|Array<Integer>codeInteger|Array<Integer>bits
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
bitsFalseFalseInteger|Array<Integer>
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1Falsefalse
2Falsefalse
3Falsefalse
4Truetrue
5Truetrue
6Truetrue
7Truetrue
8Truetrue
9Truetrue
10Falsefalse
11Falsefalse
12Falsefalse
13Truetrue
14Truetrue
15Truetrue
16Truetrue
17Truetrue
18Truetrue
19Falsefalse
20Falsefalse
21Falsefalse
PruebaPythonJavaScript
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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger|String|Array<Integer>
_fromTrueFalseInteger
_toFalseFalseInteger
NameRequiredNullableTypedDefault 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:

PruebaPythonJavaScript
1Truetrue
2Truetrue
3Truetrue
4Falsefalse
5Falsefalse
6Falsefalse
7Falsefalse
8Falsefalse
9Falsefalse
10Truetrue
11Truetrue
12Truetrue
PruebaPythonJavaScript
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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger
NameRequiredNullableTypedDefault Value
ErrorsManager.compact
StringobjectpublicErrorsManager.compactRequiredStringcode
NameRequiredNullableTypedDefault Value
codeTrueFalseString
NameRequiredNullableTypedDefault Value
ErrorsManager.compact
Array<Integer>objectpublicErrorsManager.compactRequiredArray<Integer>code
NameRequiredNullableTypedDefault Value
codeTrueFalseArray<Integer>
NameRequiredNullableTypedDefault 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:

PruebaValorBinarioCompactadoBinario compactado
0105["101001", "000001"]105["101001", "000001"]
1pBAA["101001", "000001", "000000", "000000"]pB["101001", "000001"]
2[41, 1, 0, 0]["101001", "000001", "000000", "000000"][41, 1]["101001", "000001"]
PruebaValorBinarioCompactadoBinario 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
NameRequiredNullableTypedDefault Value
codeTrueFalseInteger
bitsTrueFalseInteger
NameRequiredNullableTypedDefault Value
ErrorsManager.bitwise
StringobjectpublicErrorsManager.bitwiseRequiredStringcodeRequiredIntegerbits
NameRequiredNullableTypedDefault Value
codeTrueFalseString
bitsTrueFalseInteger
NameRequiredNullableTypedDefault Value
ErrorsManager.bitwise
Array<Integer>objectpublicErrorsManager.bitwiseRequiredArray<Integer>codeRequiredIntegerbits
NameRequiredNullableTypedDefault Value
codeTrueFalseArray<Integer>
bitsTrueFalseInteger
NameRequiredNullableTypedDefault 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:

ValorBinarioBitsDesplazadoBinario desplazado
105["101001", "000001"]-100["000000"]
105["101001", "000001"]-53["000011"]
105["101001", "000001"]-313["001101"]
105["101001", "000001"]-152["110100"]
105["101001", "000001"]0105["101001", "000001"]
105["101001", "000001"]1210["010010", "000011"]
105["101001", "000001"]3840["001000", "001101"]
105["101001", "000001"]53360["100000", "110100"]
105["101001", "000001"]10107520["000000", "010000", "011010"]
pB["101001", "000001"]-10A["000000"]
pB["101001", "000001"]-5DA["000011", "000000"]
pB["101001", "000001"]-3NA["001101", "000000"]
pB["101001", "000001"]-10A["110100", "000000"]
pB["101001", "000001"]0pB["101001", "000001"]
pB["101001", "000001"]1SD["010010", "000011"]
pB["101001", "000001"]3IN["001000", "001101"]
pB["101001", "000001"]5g0["100000", "110100"]
pB["101001", "000001"]10AQa["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"]
ValorBinarioBitsDesplazadoBinario desplazado
manual/set.w.md

set

ErrorsManager.set
StringobjectpublicErrorsManager.setRequiredStringcodeRequiredIntegererrorIntegerbit0Integerlength00
NameRequiredNullableTypedDefault Value
codeTrueFalseString
errorTrueFalseInteger
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalse(String|Integer|Array<Integer>)
errorTrueFalse(String|Integer|Array<Integer>)
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseString
errorTrueFalsestring
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalse(String|Integer|Array<Integer>)
errorTrueFalse(String|Integer|Array<Integer>)
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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
NameRequiredNullableTypedDefault Value
codeTrueFalseString
blocksTrueFalseArray.<Integer>
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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.

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
NameRequiredNullableTypedDefault Value
codeTrueFalse(String|Integer|Array<Integer>)
errorTrueFalse(String|Integer|Array<Integer>)
bitFalseFalseInteger0
lengthFalseFalseInteger0
NameRequiredNullableTypedDefault 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