// Lanzador de excepciones
 
struct Excepcion
{
       string Mensaje; // Mensaje de error
       unsigned int Error; // Codigo de excepcion (los codigos se guardan en el header AMC CODIGOS_DE_ERROR.hpp
 
       Excepcion(string Texto,unsigned int ErroR) : Mensaje(Texto),Error(ErroR) {} // Contructor
};
 
void CopiarArchivos(ifstream &Lectura,ofstream &Escritura,unsigned long long Tamanyo_Archivo)
{
    char* Cosa; // Buffer para leer
    unsigned int Tamanyo_Lectura; // Variable que designa el tamaño de cada lectura
    unsigned long long Contador = 0;  // Variable auxiliar, se utiliza para contabilizar el progueso obtenido y calcular un porcentaje
    unsigned short Porcentaje = 0; // Porcentaje actual
    unsigned long long Limite; // Valor auxiliar correspondiente al 1% del tamanyo del archivo. Se utiliza para saber cuando hay que aumentar el porcentaje en 1
    unsigned long long Offset = 0; // Variable que contiene la posicion del archivo actual
 
	if (!Lectura)
		throw Excepcion("ERROR AL COPIAR ARCHIVOS, ARCHIVO DE ORIGEN NO ENCONTRADO",ARCHIVO_NO_ENCONTRADO);
 
	// Si el tamanyo del archivo es inferior al buffer máximo permitido. Se leera el archivo del tirón
 
    if (Tamanyo_Archivo < 5242880)
            Tamanyo_Lectura = Tamanyo_Archivo;
    else
             Tamanyo_Lectura = 5242880; // Si no, se dejará en el máximo valor
 
	/* Asignamos la memoria al buffer, si no se puede satisfacer la operación se intentará asignar un buffer menor,
	si el tamaño del buffer llega a 1. La propia función de asignar memoria lanza una excepción que termina el programa */
 
	while (!AsignarMemoria(Cosa,Tamanyo_Lectura))
	{
		Tamanyo_Lectura /=2;
	}
 
	/* Decidimos si vamos a mostrar el porcentaje o no, para aumentar el rendimiento. Solo se mostrará
			si su tamaño es superior a 5 MB */
 
    if (Tamanyo_Archivo >  5242880)
	     Limite = Tamanyo_Archivo/100;
    else
             Limite = 0; // Desactivado
 
 
	while (Offset != Tamanyo_Archivo) // Mientras la posicion del archivo no llegue a su tamaño
          {
               // Leemos y escribimos
 
               Lectura.read(Cosa,Tamanyo_Lectura);
               Escritura.write(Cosa,Tamanyo_Lectura);
 
			   Offset += Tamanyo_Lectura; // Aumentamos el progueso del archivo
 
			   // Si el muestreo de porcentaje está activado...
 
               if (Limite != 0)
               { 
				   Contador += Tamanyo_Lectura; // Aumentamos el medidor
 
				   if (Contador >= Limite) // Si el medidor supera el 1% del archivo
				   {
					  Porcentaje++; // Aumentamos el porcentaje
					  cout<<Porcentaje<<"%"<<endl; // Lo mostramos por pantalla
					  Contador = 0; // Reseteamos el medidor
				   }
               }
 
			   // Antes de repetir el bucle, comprobaremos si en la proxima lectura desbordaremos el archivo
 
               if ((Tamanyo_Archivo - Offset) < Tamanyo_Lectura)
               {
				  // Si así es, hacemos una lectura con lo que nos quede del archivo
 
                  Lectura.read(Cosa,Tamanyo_Archivo - Offset);
                  Escritura.write(Cosa,Tamanyo_Archivo - Offset);
 
				  // Situamos el indicador de posición al final del archivo
 
                  Offset = Tamanyo_Archivo;
               }
 
         }
 
      delete[] Cosa; //Borramos la memoria dinámica usada
}
 
/* Asigna el buffer de lectura, devuelve verdadero si tuvo exito.
 
Si no tuvo exito, devuelve falso por si se quiere modificar. Si no se puede modificar más, se lanza una excepción */
 
inline bool AsignarMemoria(char* &Cosa,unsigned int Lectura)
{
	try
	{
		Cosa = new char[Lectura]; // Asignamos el buffer
		return true; // Hemos conseguido asignar el buffer con exito
	}
	catch(...) // Si ocurrió alguna excepción
	{
		if (Lectura > 1) // Se devolverá "falso" para indicar que no se pudo asignar la memoria y asi dar una oportunidad para asignar un buffer menor
			return false;
		else // Si el tamaño del buffer no puede disminuir más, se lanza una excepción.
			throw Excepcion("Error inesperado en la memoria",MEMORIA_NO_DISPONIBLE);
	}
}