// --------------------------------------------------------------------------------------------
// archivo  : xsstring.h
// objetivo : header de funciones para manejo de cadenas
// --------------------------------------------------------------------------------------------

#ifndef __xsString_H__
#define __xsString_H__

// Incluyo la librería xsEasy
#include "xsEasyC.h"

// Se Incluyen librerías de c
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "ctype.h"
#include <stdbool.h>

// Constantes
#define JUSTIFICAR_IZQ       'I'      // Justificar a la Izquierda
#define JUSTIFICAR_DER       'D'      // Justificar a la Derecha
#define JUSTIFICAR_CEN       'C'      // Justificar al Centro
#define TODOS_CARACTERES     -1       // Todos los caracteres

// Objetivo : Convierte una Cadena a Doble
// Retorna  : El valor doble
//            En caso de error, retorna 0 y es puesto el indicador de error
Doble cadenaADoble(Caracter* cadena);

// Objetivo : Convierte una Cadena a Entero
// Retorna  : El valor Entero
//            En caso de error es puesto el indicador de error
Entero cadenaAEntero(Caracter* cadena);

// Objetivo : Convierte una Cadena a Entero Largo
// Retorna  : El valor Entero Largo
//            En caso de error es puesto el indicador de error
Largo Entero cadenaAEnteroLargo(Caracter* cadena);

// Objetivo : Convierte una Cadena a Flotante
// Retorna  : El valor Flotante
//            En caso de error es puesto el indicador de error
Flotante cadenaAFlotante(Caracter* cadena);


// Objetivo : Agregar una cadena a otra
// Retorna  : Nada
Vacio cadenaAgregar(Caracter *cadena,     // Cadena en que se va a obtener la longitud
		            Caracter *agregar);   // Cadena a agregar jaor cpp

// Objetivo : Asignar un texto a una cadena
// Retorna  : Nada
Vacio cadenaAsignar(Caracter *cadena,     // Cadena en que se va a obtener la longitud
			        Constante Caracter *texto);     // texto a asignar jaor cpp

// Objetivo : Asignar n caracteres de una cadena a otra			 
// Retorna  : Nada
Vacio cadenaAsignarN(Caracter *cadena,       // Cadena en que se va a obtener la longitud
			         Caracter *texto,        // texto a asignar
			         Entero    ncaracteres); // N Caracteres

			       
// Objetivo : comparar 2 cadenas
// Retorna  : diferencia en ASCII
Entero cadenaComparar(Caracter *cadena1,     // Cadena1 a comparar
		              Constante Caracter *cadena2,     // Cadena2 a comparar			 
			          Logico    exacto);     // Indica si la comparación es exacta
			 
// Objetivo : comparar 2 cadenas únicamente N caracteres
// diferencia en ASCII
Entero cadenaCompararN(Caracter *cadena1,     // Cadena1 a comparar
		               Constante Caracter *cadena2,     // Cadena2 a comparar			 
			           Entero    cuantos,     // Cuantos caracteres a comparar
			           Logico    exacto);     // Indica si la comparación es exacta

// Objetivo    : Verifica si una cadena existe en otra
// Retorna     : La posición en la que encuentra la cadena
Entero cadenaContiene(Caracter *cadena,    // Cadena en la Cual se Busca
                      Caracter *buscar,    // Texto a Buscar
                      Logico    exacto);   // Indica si será búsqueda exacta es decir cama<>Cama

// Objetivo    : Verifica si en una cadena existe algún caracter de la segunda cadena
// Retorna     : La posición en la que encuentra el caracter
Entero cadenaContieneAlguno(Caracter *cadena,        // Cadena en la Cual se Busca
                            Caracter *caracteres);   // Cadena a Buscar
			   			   
// Objetivo    : Verifica la ultima posición en que existe una cadena en otra
// Retorna     : La posición en la que encuentra la cadena
Entero cadenaContieneUltima(Caracter *cadena,       // Cadena en la Cual se Busca
                            Caracter *buscar,       // Cadena a Buscar
                            Logico    exacto,       // Indica si será búsqueda exacta es decir
				            Entero   *ocurrencias); // Cuenta cuantas ocurrencias encontró;


// Objetivo : Eliminar los espacios, tab y cualquier caracter no imprimible en la cadena
// Retorna  : La Cadena con los Caracteres eliminados
Caracter *cadenaDepurar(Caracter *cadena); // Cadena que se va a depurar

// Objetivo : Eliminar los espacios, tab y cualquier caracter no imprimible a la derecha
// Retorna  : La Cadena con los Caracteres eliminados
Caracter *cadenaDepurarDerecha(Caracter *cadena); // Cadena que se va a depurar

// Objetivo : Eliminar los espacios, tab y cualquier caracter no imprimible a la izquierda
// Retorna  : La Cadena con los Caracteres eliminados a la izquierda
Caracter *cadenaDepurarIzquierda(Caracter *cadena); // Cadena que se va a depurar
					 
					 
// Objetivo    : Obtiene la Parte Derecha de una Cadena
// Retorna     : La Cadena con la parte Derecha
Caracter *cadenaDerecha(Caracter  *cadena,   // Cadena de la que se obtendrá la parte Derecha
                        Entero   longitud);  // Longitud obtener de la parte derecha
					 
					 
// Objetivo : Eliminar un Caracter de la Cadena
// Retorna  : La Cadena con los Caracteres eliminados
Caracter *cadenaEliminar(Caracter *cadena,              // Cadena que se va a analizar
                         Caracter  caracter,            // Caracter a Eliminar
                         Logico  exacto,                // Si considera mayusculas-minusculas
                         Entero  *eliminaciones);       // Cuantas Eliminaciones se Realizaron

						 
// Objetivo    : Verifica si una cadena es un numero y puede tener decimales
// Retorna     : VERDAD/FALSO
Logico cadenaEsDecimal(Caracter *cadena);   


// Objetivo    : Verifica si una cadena es un entero
// Retorna     : VERDAD/FALSO
Logico cadenaEsEntero(Caracter *cadena);   


// Objetivo    : Verifica si una cadena es un fecha válida
// Retorna     : VERDAD/FALSO
Logico cadenaEsFecha(Caracter *cadena);   

// Objetivo    : Verifica si una cadena es un fecha hora válida
// Retorna     : VERDAD/FALSO
Logico cadenaEsFechaHora(Caracter *cadena);   

// Objetivo    : Verifica si una cadena es una hora válida
// Retorna     : VERDAD/FALSO
Logico cadenaEsHora(Caracter *cadena);   


// Objetivo : comparar 2 cadenas
// Retorna  : VERDAD/FALSO iguale
Logico cadenaIguales(Caracter *cadena1,     // Cadena1 a comparar
		             Caracter *cadena2,     // Cadena2 a comparar			 
			         Logico    exacto);     // Indica si la comparación es exacta

// Objetivo : Verifica si una cadena inicia con la subcadena indicada
// Retorna  : VERDAD/FALSO
Logico cadenaIniciaCon(Caracter *cadena,   // Cadena en que se va a buscar
                       Caracter *texto,    // Texto para verificar si inicia con el
			           Logico    exacto);  // Para indicar si será exacta la validación

// Objetivo    : Verifica si una cadena inicia con algun caracter de la segunda cadena
// Retorna     : Cuantos caracteres encontró al inicio
Entero cadenaIniciaCuenta(Caracter *cadena,        // Cadena en la Cual se Busca
                          Caracter *caracteres);   // Cadena a Buscar			 
				 
// Objetivo    : Obtiene la Cadena Invertida
// Retorna     : La Cadena Invertida
Caracter *cadenaInvertir(Caracter  *cadena);   // Cadena de la que se obtiene Invertida


// Objetivo    : Obtiene la Parte Izquierda de una Cadena
// Retorna     : La Cadena con la parte izquierda
Caracter *cadenaIzquierda(Caracter *cadena,   // Cadena de la que se obtendrá la parte izquierda
                          Entero   longitud); // Longitud a obtener de la parte izquierda
				 
				 
					 
// Objetivo : Justificar una cadena a la Derecha o Izquierda
// Retorna  : La Cadena Justificada
Caracter *cadenaJustificar(Caracter *cadena,    // Cadena a Justificar
                           Entero    longitud,  // Longitud a Justificar
                           Caracter  lado,      // Lado a Justificar; I=Izquierda; D=Derecha: C=Centro
                           Caracter  caracter); // Caracter usado para justificar

// Objetivo : Obtener la longitud de una Cadena
// Retorna  : Longitud de la Cadena
Entero cadenaLongitud(Caracter *cadena);   // Cadena en que se va a obtener la longitud

// Objetivo    : Convierte a Mayúsculas una Cadena
// Retorna     : La Cadena Convertida en Mayusculas
Caracter *cadenaMayusculas(Caracter *cadena);   // Cadena a Convertir


// Objetivo    : Convierte a Minúsculas una Cadena
// Retorna     : La Cadena Convertida en Minúsculas
Caracter *cadenaMinusculas(Caracter *cadena);   // Cadena a Convertir

// Objetivo    : Reemplazar subcadena por otra en todas las ocurrencia que haya
// Retorna     : La cadena con los reemplazos realizados
Caracter *cadenaReemplazar(Caracter *cadena,       // La cadena en donde se sustituye
                           Caracter *buscar,       // El texto a buscar
				           Caracter *nuevo);       // El texto nuevo a colocar

// Objetivo    : Reemplazar en una cadena un caracter por otro
// Retorna     : El numero de reeemplazos que realizó
Entero cadenaReemplazarCaracter(Caracter *cadena,             // La cadena en donde se sustituye
                                Entero   caracterReemplazar,  // El Caracter a Reemplazar
				                Caracter caracterNuevo);      // El Caracter nuevo
						   

// Objetivo    : Cambiar una subcadena por otra las N veces que se indique
// Retorna     : La cadena con los cambios realizados y cuantas ocurrencias hubo
Caracter *cadenaReemplazarN(Caracter *cadena,        // La cadena en donde se sustituye
                            Caracter *buscar,        // El texto a buscar
			                Caracter *nuevo,         // El texto nuevo a colocar
			                Entero    cambios,       // Cuantas cambios hacer
			                Entero   *ocurrencias);  // Cuenta cuantas ocurrencias encontró;


// Objetivo    : Sustituir una subcadena por otra
// Retorna     : La cadena con la susticuciones realizada y cuantas Ocurrencias hubo
Caracter *cadenaReemplazarO(Caracter *cadena,        // La cadena en donde se sustituye
                            Caracter *buscar,        // El texto a buscar
				            Caracter *nuevo,         // El texto nuevo a colocar
				            Entero   *ocurrencias);  // Cuenta cuantas ocurrencias encontró;
				          

// Objetivo    : Obtiene una subcadena
// Retorna     : La SubCadena
Caracter *cadenaSubCadena(Caracter *cadena,     // Cadena de la Cual se Obtiene la Subcadena
                          Entero    desde,      // Posicion Inicial para obtener SubCadena
                          Entero    hasta);     // Posicion Final de la SubCadena

				   			  		                                              
// Objetivo : Verifica si una cadena finaliza con la subcadena indicada
// Retorna  : VERDAD/FALSO
Logico cadenaTerminaCon(Caracter *cadena,   // Cadena en que se va a buscar
                        Caracter *texto,    // Texto para verificar si inicia con el
			            Logico    exacto);  // Para indicar si será exacta la validación

// fin de la Definición del Archivo
#endif