Método que entrega a partir de su valor (texto) el código que corresponde
@author Esteban De La Fuente Rubio, DeLaF (esteban[at]sasco.cl)
@version 2016-07-26
179236
public static function getCodigo($tag, $valor)
    {
        if (self::$tablasInvertidas===null) {
            self::$tablasInvertidas = self::getTablasInvertidas();
        }
        $valor = strtoupper($valor);
        return isset(self::$tablasInvertidas[$tag][$valor]) ? self::$tablasInvertidas[$tag][$valor] : $valor;
    }
225458
public function toValue() {
    $text = $this->getText();
    $quote_char = $text[0];
    $text = substr($text, 1, -1);
    if ($quote_char === '"') {
      $rules = array(
        preg_quote('\\\\') => '\\',
        preg_quote('\n') => "\n",
        preg_quote('\t') => "\t",
        preg_quote('\"') => '"',
        preg_quote('\$') => '$',
        preg_quote('\r') => "\r",
        preg_quote('\v') => "\v",
        preg_quote('\f') => "\f",
        preg_quote('\e') => "\e",
        '\\\\[0-7]{1,3}' => '__octal__',
        '\\\\x[0-9A-Fa-f]{1,2}' => '__hex__',
      );
    }
    else {
      $rules = array(
        preg_quote('\\\\') => '\\',
        preg_quote("\\'") => "'"
      );
    }
    $replacements = array_values($rules);
    $regex = '@(' . implode(')|(', array_keys($rules)) . ')@';
    return preg_replace_callback($regex, function ($matches) use ($replacements) {
      // find the first non-empty element (but skipping $matches[0]) using a quick for loop
      for ($i = 1; '' === $matches[$i]; ++$i);

      $match = $matches[0];
      $replacement = $replacements[$i - 1];
      if ($replacement === '__octal__') {
        $replacement = chr(octdec(substr($match, 1)));
      }
      elseif ($replacement === '__hex__') {
        $replacement = chr(hexdec(substr($match, 2)));
      }
      return $replacement;
    }, $text);
  }
47456
def ConsultarTipoActividadRepresentado(self, sep="||"):
        ""
        try:
            ret = self.client.tipoActividadRepresentadoConsultar(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['tipoActividadReturn']
            self.__analizar_errores(ret)
            array = ret.get('tiposActividad', [])
            self.Excepcion = self.Traceback = ""
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigoDescripcion']['codigo'], 
                     it['codigoDescripcion']['descripcion']) 
               for it in array]
        except Exception:
            ex = utils.exception_info()
            self.Excepcion = ex['msg']
            self.Traceback = ex['tb']
            if sep:
                return ["ERROR"]
1297288
def ConsultarTributos(self, sep="||"):
        ""
        ret = self.client.consultarTributos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('tributo', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
1248280
def ConsultarMotivos(self, sep="||"):
        ""
        ret = self.client.consultarMotivos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('motivo', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
174976
public function getText()
    {
        $retorno = '';
        foreach ($this->meta as $key => $value) {
            $retorno .= $this->$key;
        }
        RemessaAbstract::$retorno[] = $retorno;
        if ($this->children) {
            // percorre todos objetos filhos
            foreach ($this->children as $child) {
                $child->getText();
            }
        }
    }
1249047
def ordenar! 
			cambio = true
			while cambio
				cambio = false
				i = @inicio
				i_1 = @inicio[:sig]
				while i_1 != nil
					if(i[:valor] > i_1[:valor])
						i[:valor], i_1[:valor] = i_1[:valor], i[:valor]
						cambio = true
					end
					i = i_1
					i_1 = i_1[:sig]
				end
			end
		end
291256
def ConsultarBonificacionesPenalizaciones(self, sep="||"):
        ""
        ret = self.client.consultarBonificacionesPenalizaciones(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        self.XmlResponse = self.client.xml_response
        array = ret.get('tipo', [])
        if sep is None:
            # sin separador, devuelve un diccionario con clave cod_variadedad
            # y valor: {"descripcion": ds_variedad, "clases": lista_clases}
            # siendo lista_clases = [{'codigo': ..., 'descripcion': ...}]
            return dict([(it['codigo'], {'descripcion': it['descripcion'], 
                                         'subtipo': it['subtipo']}) 
                         for it in array])
        else:
            # con separador, devuelve una lista de strings:
            # || cod.variedad || desc.variedad || desc.clase || cod.clase ||
            ret = []
            for it in array:
                for subtipo in it['subtipo']:
                    ret.append(
                        ("%s %%s %s %%s %s %%s %s %%s %s %%s %s %%s %s" % 
                            (sep, sep, sep, sep, sep, sep, sep)) %
                        (it['codigo'], it['descripcion'], 
                         subtipo['descripcion'], subtipo['codigo'],
                         subtipo['valor'], subtipo['signo']) 
                        )
            return ret
582102
public function setDataFromPost() {
    // Recorremos el arreglo $data
    foreach ($this->data as $key => $value) {
      // Si existe la llave en $_POST entonces asignamos su valor
      // a $data
      if (isset($_POST[$key])) {
        $this->data[$key] = $_POST[$key];
      }
    }
  }
824780
public function enviar()
    {
        if ($this->enviado) {
            return false;
        }

        http_response_code($this->estadoHttp);

        // Enviamos cabeceras
        foreach ($this->cabeceras as $cabecera => $valores) {
            foreach ($valores as $valor) {
                header($cabecera . ': ' . $valor, false);
            }
        }

        if (!empty($this->contenido)) {
            echo $this->contenido;
        }

        return $this->enviado = true;
    }
933768
public function convertir()
    {
        $n_str = (string)$this->numero_entero;//Convierte el número entero a cadena

        if ($this->numero_entero == 0) {
            $letras = $this->simple[0] . " " . $this->moneda;
        }

        //Numero < 1000
        elseif ($this->numero_entero < 1000) {
            $n = $this->numero_entero;
            $n_txt = $this->menor_mil($n);
            $letras = $n_txt . " " . $this->moneda;
        }

        //Numero {1000 < n < 1,000,000}
        elseif ($this->numero_entero < 1000000) {
            $m = 0;
            $long_n = strlen($n_str);//cuenta el número de caracteres
            $f = 1;

            //Separa los miles para ser evaluados con la función menor_mil
            for ($k = $long_n; $k > 3; $k--) {
                $m += ($n_str[$k-4] * $f);    //recupera la posicion 0,1,2 y Multiplica por 1,10,y 100
                $f *= 10;
            }

            //Miles que pasan a funcion menor_mil para ser evaluadas
            $miles_txt = $this->menor_mil($m);

            $n = $this->numero_entero - $m * 1000;//Elimina los miles

            $n_txt = $this->menor_mil($n);//Unidades, Decenas y Centenas a ser evaluadas
            $letras = $miles_txt . $this->miles . $n_txt . " " . $this->moneda;
        }

        //número mayor o igual a 1,000,000
        else {
            $long_n = strlen($n_str);//cuenta el número de caracteres
            $f = 1;
            $mm = 0;
            for ($k = $long_n; $k > 6; $k--) {
                $mm += ($n_str[$k-7] * $f);    //Recupera la posición 0,1,2 del array u la Multiplica por 1,10,y 100 respectivamente
                $f *= 10;
            }

            if ($mm == 1) {
                $this->millones = $this->millon;
            }
            $millones_txt = $this->menor_mil($mm);

            $f=1;
            $m = 0;
            //Separa los miles para ser evaluados con la función menor_mil
            for ($k = $long_n; $k > $long_n - 3; $k--) {
                $m += ($n_str[$k-4] * $f);    //Multiplica por 1,10,y 100
                $f *= 10;
            }

            //Miles que pasan a funcion menor_mil para ser evaluadas
            $miles_txt = $this->menor_mil($m);
            $n = $this->numero_entero - $m*1000 - $mm*1000000;//Elimina los miles y millones
            $n_txt = $this->menor_mil($n);//Unidades, Decenas y Centenas a ser evaluadas
            $letras = $millones_txt . $this->millones . $miles_txt . $this->miles . $n_txt . " " . $this->moneda;
        }

        //Evaluación de decimales
        //Si no tiene decimal
        if (strchr($this->numero, ".") == "") {
            return ("(" . $letras . " 00/100)");
        } else {
            $dec = strchr($this->numero, ".");
            if (empty($dec[2])) {
                $d = $dec['1'] . '0';
            } else {
                $d = $dec['1'] . (integer)$dec['2'];
            }
            return ("(" . $letras . " " . $d . "/100)");
        }
    }
1241153
def verifica(ver_list, res_dict, difs):
    ""
    for k, v in ver_list.items():
        # normalizo a float para poder comparar numericamente:
        if isinstance(v, (Decimal, int, long)):
            v = float(v)
        if isinstance(res_dict.get(k), (Decimal, int, long)):
            res_dict[k] = float(res_dict[k])
        if isinstance(v, list):
            # verifico que ambas listas tengan la misma cantidad de elementos:
            if v and not k in res_dict and v:
                difs.append("falta tag %s: %s %s" % (k, repr(v), repr(res_dict.get(k))))
            elif len(res_dict.get(k, []))!=len(v or []):
                difs.append("tag %s len !=: %s %s" % (k, repr(v), repr(res_dict.get(k))))
            else:
                # ordeno las listas para poder compararlas si vienen mezcladas
                rl = sorted(res_dict.get(k, []))
                # comparo los elementos uno a uno:
                for i, vl in enumerate(sorted(v)):
                    verifica(vl, rl[i], difs)
        elif isinstance(v, dict):
            # comparo recursivamente los elementos:
            verifica(v, res_dict.get(k, {}), difs)
        elif res_dict.get(k) is None or v is None:
            # alguno de los dos es nulo, verifico si ambos lo son o faltan
            if v=="":
                v = None
            r = res_dict.get(k)
            if r=="":
                r = None
            if not (r is None and v is None):
                difs.append("%s: nil %s!=%s" % (k, repr(v), repr(r)))
        elif type(res_dict.get(k)) == type(v):
            # tipos iguales, los comparo directamente
            if res_dict.get(k) != v:
                difs.append("%s: %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        elif isinstance(v, float) or isinstance(res_dict.get(k), float):
            # comparar numericamente
            if float(res_dict.get(k)) != float(v):
                difs.append("%s: %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        elif unicode(res_dict.get(k)) != unicode(v):
            # tipos diferentes, comparo la representación  
            difs.append("%s: str %s!=%s" % (k, repr(v), repr(res_dict.get(k))))
        else:
            pass
74720
public static function prepare_attr_value ($text) {
		if (is_array($text)) {
			/** @noinspection ForeachSourceInspection */
			foreach ($text as &$t) {
				$t = static::prepare_attr_value($t);
			}
			return $text;
		}
		return strtr(
			$text,
			[
				'&'  => '&amp;',
				'"'  => '&quot;',
				'\'' => '&apos;',
				'<'  => '&lt;',
				'>'  => '&gt;'
			]
		);
	}
728125
function(input) {

			// Nos deshacemos del caracter final `:` para su validación

			var size = (input = _toString(input)).length;

			input = (input.substr(size-1, 1) === ':') ? input.substr(0, input.length-1) : input;

			// Si el protocolo es correcto añadimos `:` al final del mismo
			// si no lo es devolvemos una cadena vacía

			return Public.normalize.regex_rfc3986_schema.test((input = input.toLowerCase())) ? (input + ':') : '';

		}
554122
def ConsultarGastos(self, sep="||"):
        ""
        ret = self.client.consultarGastos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('gasto', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]
47492
public function getCodigoNome()
    {
        $codigo = (int) $this->getCodigo();

        $table = array(
             2 => 'Entrada Confirmada',
             3 => 'Entrada Rejeitada',
             4 => 'Transferência de Carteira/Entrada',
             5 => 'Transferência de Carteira/Baixa',
             6 => 'Liquidação',
             9 => 'Baixa',
            12 => 'Confirmação Recebimento Instrução de Abatimento',
            13 => 'Confirmação Recebimento Instrução de Cancelamento Abatimento',
            14 => 'Confirmação Recebimento Instrução Alteração de Vencimento',
            17 => 'Liquidação Após Baixa ou Liquidação Título Não Registrado',
            19 => 'Confirmação Recebimento Instrução de Protesto',
            20 => 'Confirmação Recebimento Instrução de Sustação/Cancelamento de Protesto',
            23 => 'Remessa a Cartório (Aponte em Cartório)',
            24 => 'Retirada de Cartório e Manutenção em Carteira',
            25 => 'Protestado e Baixado (Baixa por Ter Sido Protestado)',
            26 => 'Instrução Rejeitada',
            27 => 'Confirmação do Pedido de Alteração de Outros Dados',
            28 => 'Débito de Tarifas/Custas',
            30 => 'Alteração de Dados Rejeitada',
            36 => 'Confirmação de envio de e-mail/SMS',
            37 => 'Envio de e-mail/SMS rejeitado',
            43 => 'Estorno de Protesto/Sustação',
            44 => 'Estorno de Baixa/Liquidação',
            45 => 'Alteração de dados',
            51 => 'Título DDA reconhecido pelo sacado',
            52 => 'Título DDA não reconhecido pelo sacado',
            53 => 'Título DDA recusado pela CIP',
        );

        if (array_key_exists($codigo, $table)) {
            return $table[$codigo];
        } else {
            return 'Desconhecido';
        }
    }
29367
def ConsultarOtrosImpuestos(self, sep="||"):
        ""
        ret = self.client.consultarOtrosImpuestos(
                        auth={
                            'token': self.Token, 'sign': self.Sign,
                            'cuit': self.Cuit, },
                            )['respuesta']
        self.__analizar_errores(ret)
        array = ret.get('otroImpuesto', [])
        if sep is None:
            return dict([(it['codigo'], it['descripcion']) for it in array])
        else:
            return [("%s %%s %s %%s %s" % (sep, sep, sep)) %
                    (it['codigo'], it['descripcion']) for it in array]