/// <summary>
/// Exporta el contenido de un DataSet a un archivo CSV.
/// </summary>
/// <param name="dataSet">DataSet a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <returns>Resultado de la exportacion</returns>
/// <param name = "filename"></param>
public static void ToCSV(this DataSet dataSet, Delimitador delimitador, string filename)
{
var dataToExport = new StringBuilder();
var sw = new StreamWriter(filename);
foreach (DataTable dtExport in dataSet.Tables)
{
var headerToExport = new StringBuilder();
foreach (DataColumn dCol in dtExport.Columns)
{
headerToExport.Append((char)34 + dCol.ColumnName + (char)34 + (char)delimitador);
}
headerToExport.Remove(headerToExport.Length - 1, 1);
headerToExport.Append(Environment.NewLine);
dataToExport.Append(headerToExport);
var bodyToExport = new StringBuilder();
foreach (DataRow dRow in dtExport.Rows)
{
foreach (object obj in dRow.ItemArray)
{
bodyToExport.Append(obj.ToString() + (char)delimitador);
}
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
}
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
}
sw.Write(dataToExport);
sw.Close();
}
public TablaDelimitador()
{
palabras = new Delimitador[6];
// public String delimitador;
// public int valor;
palabras[0] = new Delimitador(",", 50);
palabras[1] = new Delimitador(".", 51);
palabras[2] = new Delimitador("(", 52);
palabras[3] = new Delimitador(")", 53);
palabras[4] = new Delimitador("'", 54);
palabras[5] = new Delimitador(";", 55);
}
/// <summary>
/// Exporta el contenido de la primer tabla del DataSet a un archivo CSV realizando corte y control
/// </summary>
/// <param name="dataSet">DataSet que contiene la tabla a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <param name="colControl">Columna a utilizar para el corte y control</param>
/// <param name="ColValor">Columna que representa los datos a presentar en forma horizontal para cada corte realizado</param>
/// <returns>Resultado de la exportacion</returns>
/// <remarks>
/// El primer conjunto de datos representa el nombre de las columnas, salvo para la columna control que se corresponde con el nombre de la columna de la tabla.
/// Cada corte debe contene la misma cantida de renglones para que se corresponde con las columnas al realizar el pivoteo.
/// </remarks>
public static Boolean CSVPivot(DataSet dataSet, Delimitador delimitador, int colControl, int ColValor)
{
StringBuilder dataToExport = new StringBuilder();
DataTable dtExport = dataSet.Tables[0];
StringBuilder bodyToExport = new StringBuilder();
//Inicializo la variable de control
object control = dtExport.Rows[0].ItemArray[colControl];
//Agrego el primer objeto del control a renglon a exportar
bodyToExport.Append(dtExport.Columns[colControl].ColumnName + (char)delimitador);
foreach (DataRow dRow in dtExport.Rows)
{
//Cuando cambia la variable de control
if (!dRow.ItemArray[colControl].Equals(control))
{
//Agrego al cuerpo del archivo el renglon generado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
dataToExport.Append(bodyToExport);
//Reninicalizo las variables de control para el nuevo corte
bodyToExport = new StringBuilder();
control = dRow.ItemArray[colControl];
bodyToExport.Append(control.ToString() + (char)delimitador);
}
//Siempre agrego el valor de la columna valor al renglon a exportar
bodyToExport.Append(dRow[ColValor].ToString() + (char)delimitador);
}
//Agrego al cuerpo del archivo el ultimo renglon exportado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
//Finalizo la composicion del archivo
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Planilla de Calculo (*.csv)|*.csv";
saveFileDialog.FileName = dataSet.DataSetName;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
StreamWriter sw = new StreamWriter(saveFileDialog.FileName);
sw.Write(dataToExport);
sw.Close();
MessageBox.Show("Reporte exportado con exito" + Environment.NewLine + saveFileDialog.FileName);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Exporta el contenido de un DataSet a un archivo CSV.
/// </summary>
/// <param name="dataSet">DataSet a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <returns>Resultado de la exportacion</returns>
public static Boolean CSV(DataSet dataSet, Delimitador delimitador)
{
StringBuilder dataToExport = new StringBuilder();
foreach (DataTable dtExport in dataSet.Tables)
{
StringBuilder headerToExport = new StringBuilder();
foreach (DataColumn dCol in dtExport.Columns)
{
headerToExport.Append((char)34 + dCol.ColumnName + (char)34 + (char)delimitador);
}
headerToExport.Remove(headerToExport.Length - 1, 1);
headerToExport.Append(Environment.NewLine);
dataToExport.Append(headerToExport);
StringBuilder bodyToExport = new StringBuilder();
foreach (DataRow dRow in dtExport.Rows)
{
foreach (object obj in dRow.ItemArray)
{
bodyToExport.Append(obj.ToString() + (char)delimitador);
}
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
}
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
}
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Planilla de Calculo (*.csv)|*.csv";
saveFileDialog.FileName = dataSet.DataSetName;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
StreamWriter sw = new StreamWriter(saveFileDialog.FileName);
sw.Write(dataToExport);
sw.Close();
MessageBox.Show("Reporte exportado con exito" + Environment.NewLine + saveFileDialog.FileName);
return(true);
}
else
{
return(false);
}
}
/// <summary>
/// Exporta el contenido de la primer tabla del DataSet a un archivo CSV realizando corte y control
/// </summary>
/// <param name="dataSet">DataSet que contiene la tabla a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <param name = "filename"></param>
/// <param name="colControl">Columna a utilizar para el corte y control</param>
/// <param name="ColValor">Columna que representa los datos a presentar en forma horizontal para cada corte realizado</param>
/// <returns>Resultado de la exportacion</returns>
/// <remarks>
/// El primer conjunto de datos representa el nombre de las columnas, salvo para la columna control que se corresponde con el nombre de la columna de la tabla.
/// Cada corte debe contene la misma cantida de renglones para que se corresponde con las columnas al realizar el pivoteo.
/// </remarks>
public static void ToCSVPivot(this DataSet dataSet, Delimitador delimitador, string filename, int colControl, int ColValor)
{
var dataToExport = new StringBuilder();
DataTable dtExport = dataSet.Tables [0];
var bodyToExport = new StringBuilder();
var sw = new StreamWriter(filename);
//Inicializo la variable de control
object control = dtExport.Rows [0].ItemArray [colControl];
//Agrego el primer objeto del control a renglon a exportar
bodyToExport.Append(dtExport.Columns [colControl].ColumnName + (char)delimitador);
foreach (DataRow dRow in dtExport.Rows)
{
//Cuando cambia la variable de control
if (!dRow.ItemArray [colControl].Equals(control))
{
//Agrego al cuerpo del archivo el renglon generado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
dataToExport.Append(bodyToExport);
//Reninicalizo las variables de control para el nuevo corte
bodyToExport = new StringBuilder();
control = dRow.ItemArray [colControl];
bodyToExport.Append(control.ToString() + (char)delimitador);
}
//Siempre agrego el valor de la columna valor al renglon a exportar
bodyToExport.Append(dRow [ColValor].ToString() + (char)delimitador);
}
//Agrego al cuerpo del archivo el ultimo renglon exportado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
//Finalizo la composicion del archivo
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
sw.Write(dataToExport);
sw.Close();
}
/// <summary>
/// Exporta el contenido de un DataSet a un archivo CSV.
/// </summary>
/// <param name="dataSet">DataSet a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <returns>Resultado de la exportacion</returns>
public static Boolean CSV(DataSet dataSet, Delimitador delimitador)
{
StringBuilder dataToExport = new StringBuilder();
foreach (DataTable dtExport in dataSet.Tables)
{
StringBuilder headerToExport = new StringBuilder();
foreach (DataColumn dCol in dtExport.Columns)
headerToExport.Append((char)34 + dCol.ColumnName + (char)34 + (char)delimitador);
headerToExport.Remove(headerToExport.Length - 1, 1);
headerToExport.Append(Environment.NewLine);
dataToExport.Append(headerToExport);
StringBuilder bodyToExport = new StringBuilder();
foreach (DataRow dRow in dtExport.Rows)
{
foreach (object obj in dRow.ItemArray)
bodyToExport.Append(obj.ToString() + (char)delimitador);
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
}
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
}
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Planilla de Calculo (*.csv)|*.csv";
saveFileDialog.FileName = dataSet.DataSetName;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
StreamWriter sw = new StreamWriter(saveFileDialog.FileName);
sw.Write(dataToExport);
sw.Close();
MessageBox.Show("Reporte exportado con exito" + Environment.NewLine + saveFileDialog.FileName);
return true;
}
else
{ return false; }
}
public TablaLexica(String[] palabras, int[] lineas, TablaIdentificador tablaI, TablaConstante tablaC)
{
this.palabras = new Token[palabras.Length];
//this.palabras[0].reiniciar();
Token.sNumero = 1;
// Creando todos los TOKENS
for (int x = 0; x < palabras.Length; x++)
{
//Regex.IsMatch(palabra, @"\d+")
if (palabras[x] != null && !Regex.IsMatch(palabras[x], @"((\W|^)\s+(\W|$))"))
{
if (palabras[x] != null && Regex.IsMatch(palabras[x], @regexT1))
{ // Tipo 1 - Reservadas
Reservada apuntador = this.darReservada(palabras[x]);
if (apuntador != null)
{
this.palabras[x] = new Token(lineas[x], palabras[x], 1, apuntador.valor);
}
}
else if (palabras[x] != null && Regex.IsMatch(palabras[x], @regexT6))
{ // Tipo 6 - Cosntantes
Constante apuntador = this.darConstante(palabras[x], tablaC);
if (apuntador != null)
{
this.palabras[x] = new Token(lineas[x], "Constante", 6, apuntador.valor);
}
}
else if (palabras[x] != null && Regex.IsMatch(palabras[x], regexT5))
{ // Tipo 5 - Delimitadores
Delimitador apuntador = this.darDelimitador(palabras[x]);
if (apuntador != null)
{
this.palabras[x] = new Token(lineas[x], palabras[x], 5, apuntador.valor);
}
}
else if (palabras[x] != null && Regex.IsMatch(palabras[x], @regexT4))
{ // Tipo 4 - Identificador
Identificador apuntador = this.darIdentificador(palabras[x], tablaI);
if (apuntador != null)
{
this.palabras[x] = new Token(lineas[x], palabras[x], 4, apuntador.valor);
}
}
else if (palabras[x] != null && Regex.IsMatch(palabras[x], @regexT7))
{ // Tipo 7 - Operadores
Operador apuntador = this.darOperador(palabras[x]);
this.palabras[x] = new Token(lineas[x], palabras[x], 7, apuntador.valor);
}
else if (palabras[x] != null && Regex.IsMatch(palabras[x], @regexT8))
{ // Tipo 8 - Relacionales
Relacional apuntador = this.darRelacional(palabras[x]);
this.palabras[x] = new Token(lineas[x], palabras[x], 8, apuntador.valor);
}
else
{ // Error
this.lError = lineas[x];
this.error = true;
this.pError = palabras[x];
x = palabras.Length;
}
}
}
}
/// <summary>
/// Exporta el contenido de la primer tabla del DataSet a un archivo CSV realizando corte y control
/// </summary>
/// <param name="dataSet">DataSet que contiene la tabla a exportar</param>
/// <param name="delimitador">Delimitador de celda a utilizar</param>
/// <param name="colControl">Columna a utilizar para el corte y control</param>
/// <param name="ColValor">Columna que representa los datos a presentar en forma horizontal para cada corte realizado</param>
/// <returns>Resultado de la exportacion</returns>
/// <remarks>
/// El primer conjunto de datos representa el nombre de las columnas, salvo para la columna control que se corresponde con el nombre de la columna de la tabla.
/// Cada corte debe contene la misma cantida de renglones para que se corresponde con las columnas al realizar el pivoteo.
/// </remarks>
public static Boolean CSVPivot(DataSet dataSet, Delimitador delimitador, int colControl, int ColValor)
{
StringBuilder dataToExport = new StringBuilder();
DataTable dtExport = dataSet.Tables[0];
StringBuilder bodyToExport = new StringBuilder();
//Inicializo la variable de control
object control = dtExport.Rows[0].ItemArray[colControl];
//Agrego el primer objeto del control a renglon a exportar
bodyToExport.Append(dtExport.Columns[colControl].ColumnName + (char)delimitador);
foreach (DataRow dRow in dtExport.Rows)
{
//Cuando cambia la variable de control
if (!dRow.ItemArray[colControl].Equals(control))
{
//Agrego al cuerpo del archivo el renglon generado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
bodyToExport.Append(Environment.NewLine);
dataToExport.Append(bodyToExport);
//Reninicalizo las variables de control para el nuevo corte
bodyToExport = new StringBuilder();
control = dRow.ItemArray[colControl];
bodyToExport.Append(control.ToString() + (char)delimitador);
}
//Siempre agrego el valor de la columna valor al renglon a exportar
bodyToExport.Append(dRow[ColValor].ToString() + (char)delimitador);
}
//Agrego al cuerpo del archivo el ultimo renglon exportado
bodyToExport.Remove(bodyToExport.Length - 1, 1);
//Finalizo la composicion del archivo
dataToExport.Append(bodyToExport);
dataToExport.Append(Environment.NewLine);
dataToExport.Append(Environment.NewLine);
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "Planilla de Calculo (*.csv)|*.csv";
saveFileDialog.FileName = dataSet.DataSetName;
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
StreamWriter sw = new StreamWriter(saveFileDialog.FileName);
sw.Write(dataToExport);
sw.Close();
MessageBox.Show("Reporte exportado con exito" + Environment.NewLine + saveFileDialog.FileName);
return true;
}
else
{ return false; }
}
public void Calcular()
{
Queue <Entrada> finalExpresion = new Queue <Entrada>();
Stack <Operacion> stack = new Stack <Operacion>();
List <Queue <Entrada> > tempExpresion = new List <Queue <Entrada> >();
List <Stack <Operacion> > tempOperacionesStack = new List <Stack <Operacion> >();
tempExpresion.Add(new Queue <Entrada>());
tempOperacionesStack.Add(new Stack <Operacion>());
int isTemp = 0;
while (Entradas.Count > 0)
{
if (isTemp <= 0)
{
if (Entradas.Peek() is Delimitador)
{
Delimitador del = Entradas.Dequeue() as Delimitador;
if (del.Apertura)
{
isTemp++;
Console.WriteLine($"tem++ {isTemp}");
//Esto fue un arreglo rapido por que no lograba procesar bien las expresiones con muchos (()) , habria que implementar un
//Object pool para estas filas y stacks temporales
tempOperacionesStack.Add(new Stack <Operacion>());
tempExpresion.Add(new Queue <Entrada>());
tempExpresion[isTemp] = new Queue <Entrada>();
tempOperacionesStack[isTemp] = new Stack <Operacion>();
continue;
}
}
else if (Entradas.Peek() is Numero)
{
finalExpresion.Enqueue(Entradas.Dequeue());
continue;
}
else if (Entradas.Peek() is Operacion)
{
Operacion operacion = Entradas.Dequeue() as Operacion;
if (stack.Count <= 0)
{
stack.Push(operacion);
continue;
}
bool operacionInsertada = false;
while (!operacionInsertada)
{
if (stack.Count <= 0)
{
stack.Push(operacion);
operacionInsertada = true;
continue;
}
if (stack.Peek().Orden < operacion.Orden)
{
stack.Push(operacion);
operacionInsertada = true;
continue;
}
if (stack.Peek().Orden >= operacion.Orden)
{
finalExpresion.Enqueue(stack.Pop());
}
}
}
}
else
{
if (Entradas.Peek() is Delimitador)
{
Delimitador del = Entradas.Dequeue() as Delimitador;
if (del.Apertura)
{
isTemp++;
tempOperacionesStack.Add(new Stack <Operacion>());
tempExpresion.Add(new Queue <Entrada>());
tempExpresion[isTemp] = new Queue <Entrada>();
tempOperacionesStack[isTemp] = new Stack <Operacion>();
Console.WriteLine($"tem++ {isTemp}");
var y = tempOperacionesStack[isTemp].Count;
for (int i = 0; i < y; i++)
{
tempExpresion[isTemp].Enqueue(tempOperacionesStack[isTemp].Pop());
}
Numero num = CalcularExpresionPostFix(tempExpresion[isTemp]);
tempExpresion[isTemp].Enqueue(num);
continue;
}
else
{
Console.WriteLine($"isTemp-- {isTemp}");
var x = tempOperacionesStack[isTemp].Count;
for (int i = 0; i < x; i++)
{
tempExpresion[isTemp].Enqueue(tempOperacionesStack[isTemp].Pop());
}
tempExpresion[isTemp].Enqueue(CalcularExpresionPostFix(tempExpresion[isTemp]));
isTemp--;
if (isTemp <= 0)
{
while (tempExpresion[isTemp + 1].Count > 0)
{
finalExpresion.Enqueue(tempExpresion[isTemp + 1].Dequeue());
}
}
else
{
while (tempExpresion[isTemp + 1].Count > 0)
{
tempExpresion[isTemp].Enqueue(tempExpresion[isTemp + 1].Dequeue());
}
}
//aqui temp va al definitivo?
continue;
}
}
else if (Entradas.Peek() is Numero)
{
tempExpresion[isTemp].Enqueue(Entradas.Dequeue());
continue;
}
else if (Entradas.Peek() is Operacion)
{
Operacion operacion = Entradas.Dequeue() as Operacion;
if (tempOperacionesStack[isTemp].Count <= 0)
{
tempOperacionesStack[isTemp].Push(operacion);
continue;
}
bool operacionInsertada = false;
while (!operacionInsertada)
{
if (tempOperacionesStack[isTemp].Count <= 0)
{
tempOperacionesStack[isTemp].Push(operacion);
operacionInsertada = true;
continue;
}
if (tempOperacionesStack[isTemp].Peek().Orden < operacion.Orden)
{
tempOperacionesStack[isTemp].Push(operacion);
operacionInsertada = true;
continue;
}
if (tempOperacionesStack[isTemp].Peek().Orden >= operacion.Orden)
{
tempExpresion[isTemp].Enqueue(stack.Pop());
}
}
}
}
}
int m = stack.Count;
for (int i = 0; i < m; i++)
{
finalExpresion.Enqueue(stack.Pop());
}
#region testExpresion
Queue <Entrada> textFila = new Queue <Entrada>();
Entrada entrada;
string messegeText = "";
while (finalExpresion.Count > 0)
{
entrada = finalExpresion.Dequeue();
messegeText += entrada.Symbol();
textFila.Enqueue(entrada);
}
;
Console.WriteLine(messegeText);
while (textFila.Count > 0)
{
entrada = textFila.Dequeue();
finalExpresion.Enqueue(entrada);
}
;
#endregion
CurrentValor = CalcularExpresionPostFix(finalExpresion);
Console.WriteLine("Valor calculado: " + CurrentValor.Valor.ToString());
UpdatedCalculator();
}
