public ActionResult Create(HttpPostedFileBase jsonFile)
{
try
{
// TODO: Add insert logic here
if (Path.GetFileName(jsonFile.FileName).EndsWith(".json"))
{
jsonFile.SaveAs(Server.MapPath("~/JSONFiles" + Path.GetFileName(jsonFile.FileName)));
StreamReader sr = new StreamReader(Server.MapPath("~/JSONFiles" + Path.GetFileName(jsonFile.FileName)));
string data = sr.ReadToEnd();
ArbolBinarioBusqueda <int> entero = new ArbolBinarioBusqueda <int>();
entero._raiz = JsonConvert.DeserializeObject <Nodo <int> >(data);
entero.Pre(entero._raiz);
List <int> aux = entero.PreList;
for (int i = 0; i < aux.Count; i++)
{
Entero e = new Entero();
e.valor = aux[i];
Nodo <Entero> nodo = new Nodo <Entero>(e, CompararEntero);
db.ENTEROS.Insertar(nodo);
}
}
else
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public ActionResult DeleteEntero(int num)
{
Entero ent = new Entero {
valor = num
};
return(View(ent));
}
public void asignar_en_recorrido(Nodo <int> actual)
{
Entero ent = new Entero();
ent.valor = actual.valor;
Nodo <Entero> nd_insertar = new Nodo <Entero>(ent, comparador_enteros);
db.AB.Insertar(nd_insertar);
}
public ActionResult Create(HttpPostedFileBase postedFile)
{
if (postedFile != null)
{
string filepath = string.Empty;
string path = Server.MapPath("~/Uploads/");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
filepath = path + Path.GetFileName(postedFile.FileName);
string extension = Path.GetExtension(postedFile.FileName);
postedFile.SaveAs(filepath);
string csvData = System.IO.File.ReadAllText(filepath);
try
{
db.EnterosCargados.raiz = JsonConvert.DeserializeObject <Nodo <int> >(csvData);
ViewBag.Message = "Archivo Cargado de manera exitosa";
db.EnterosCargados.PreOrden(RecorrerEnteroAux);
foreach (var item in db.aux1)
{
Entero a = new Entero();
a.valor = item;
Nodo <Entero> x = new Nodo <Entero>(a, CompararEntero);
db.EnterosCargados1.Insertar(x);
}
db.EnterosCargados1.FuncionObtenerLlave = ObtenerClave;
db.EnterosCargados1.FuncionCompararLlave = CompInt;
db.EnterosCargados1.PreOrden(RecorrerEnteroIn);
db.EnterosCargados1.PostOrden(RecorrerEnteroPos);
db.EnterosCargados1.PreOrden(RecorrerEnteroPre);
bool tipoArbol = db.EnterosCargados1.ValidacionArbolDegenerado(db.EnterosCargados1.raiz);
if (tipoArbol == true)
{
ViewBag.Tipo = "Arbol equilibrado";
}
else
{
ViewBag.Tipo = "Arbol Degenerado";
}
}
catch (Exception e)
{
ViewBag.Message = "Dato erroneo.";
}
}
return(View());
}
// GET: Entero/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Entero entero_buscado = db.datos.Find(x => x.valor == id);
if (entero_buscado == null)
{
return(HttpNotFound());
}
return(View(entero_buscado));
}
// GET: Entero/Delete/5
public ActionResult Delete(int id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Entero cg = db.listaEnteros.Find(x => x.valor == id);
if (cg == null)
{
return(HttpNotFound());
}
return(View(cg));
}
public ActionResult DeleteEntero(int num, FormCollection collection)
{
try
{
// TODO: Add delete logic here
Entero entero = new Entero
{
valor = num
};
Data <Entero> .instance.Arbol.removeNodo(entero, Entero.CompareByValor);
return(RedirectToAction("IndexEntero"));
}
catch
{
return(View());
}
}
public ActionResult Create([Bind(Include = "valor")] Entero entero)
{
try
{
// TODO: Add insert logic here
Nodo <Entero> nuevo_entero = new Nodo <Entero>(entero, null);
nuevo_entero.valor = entero;
db.datos.Clear();
db.AB.Insertar(nuevo_entero);
db.AB.EnOrden(asignar_comparacion);
db.AB.EnOrden(pasar_a_lista);
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public Form1()
{
InitializeComponent();
DatosPrimitivo DatoPrimitivoCadena = new DatosPrimitivo("", rTxtCodigo);
Comentario Comentario = new Comentario("", rTxtCodigo);
OperadorLogic operadorLogico = new OperadorLogic("", rTxtCodigo);
OperadorAritmetico operadorAritmetico = new OperadorAritmetico("", rTxtCodigo);
PalabrasReservadas reservadas = new PalabrasReservadas("", rTxtCodigo);
OperadorRelacion opeRelacion = new OperadorRelacion("", rTxtCodigo);
Entero enteroo = new Entero("", rTxtCodigo);
boolean Booleano = new boolean("", rTxtCodigo);
analizador = new AnalizadorTexto();
this.Datocadena = DatoPrimitivoCadena;
this.comentario = Comentario;
this.logico = operadorLogico;
this.operadorAritmetico1 = operadorAritmetico;
this.opeRelacion = opeRelacion;
this.enteroo = enteroo;
this.reservadas = reservadas;
this.Booleano = Booleano;
}
/// <summary>
/// Establece un automata donde contenedremos todas las gramaticas clases que se establecieron
/// </summary>
public Lenguaje()
{
//Establecemos una lista de las gramaticas que contiene el automata
gramaticas[0] = new And();
gramaticas[1] = new Boolean_();
gramaticas[2] = new Cadena();
gramaticas[3] = new Chart();
gramaticas[4] = new Colon();
gramaticas[5] = new ComentarioUnaLinea();
gramaticas[6] = new ComentarioVariasLineas();
gramaticas[7] = new Comparacion();
gramaticas[8] = new Decimal_();
gramaticas[9] = new Desde();
gramaticas[10] = new Diferente();
gramaticas[11] = new Disminuir();
gramaticas[12] = new Division();
gramaticas[13] = new Entero();
gramaticas[14] = new Hacer();
gramaticas[15] = new Hasta();
gramaticas[16] = new Igual();
gramaticas[17] = new Incrementar();
gramaticas[18] = new Incremento();
gramaticas[19] = new Mayor();
gramaticas[20] = new MayorIgual();
gramaticas[21] = new Menor();
gramaticas[22] = new MenorIgual();
gramaticas[23] = new Mientras();
gramaticas[24] = new Multiplicacion();
gramaticas[25] = new Negacion();
gramaticas[26] = new Or();
gramaticas[27] = new ParentesisAbrir();
gramaticas[28] = new ParentesisCerrar();
gramaticas[29] = new Resta();
gramaticas[30] = new Si();
gramaticas[31] = new Sino();
gramaticas[32] = new Sino_Si();
gramaticas[33] = new Suma();
}
public ActionResult Delete(int id, FormCollection collection)
{
try
{
// TODO: Add delete logic here
Entero cg = db.listaEnteros.Find(x => x.valor == id);
db.arbolEnteros.Eliminar2(cg.valor);
db.listaEnterosEnOrden.Clear();
db.listaEnterosPostOrden.Clear();
db.listaEnterosPreOrden.Clear();
db.arbolEnteros.EnOrden(RecorrerEnteroIn);
db.arbolEnteros.PostOrden(RecorrerEnteroPost);
db.arbolEnteros.PreOrden(RecorrerEnteroPre);
return(RedirectToAction("Create"));
}
catch
{
return(View());
}
}
public ActionResult Create([Bind(Include = "valor")] Entero num)
{
try
{
// TODO: Add insert logic here
Nodo <Entero> nuevo = new Nodo <Entero>(num, CompararEntero);
db.arbolEnteros.Insertar(nuevo);
db.listaEnteros.Add(num);
bool tipoArbol = db.arbolEnteros.ValidacionArbolDegenerado(db.arbolEnteros.raiz);
if (tipoArbol == true)
{
ViewBag.Tipo = "Arbol equilibrado";
}
else
{
ViewBag.Tipo = "Arbol Degenerado";
}
//Recorridos
db.listaEnterosEnOrden = new List <Entero>();
db.listaEnterosPreOrden = new List <Entero>();
db.listaEnterosPostOrden = new List <Entero>();
db.arbolEnteros.EnOrden(RecorrerEnteroIn);
db.arbolEnteros.PreOrden(RecorrerEnteroPre);
db.arbolEnteros.PostOrden(RecorrerEnteroPost);
db.arbolEnteros.FuncionObtenerLlave = ObtenerClave;
db.arbolEnteros.FuncionCompararLlave = CompInt;
return(RedirectToAction("Index"));
}
catch
{
return(View());
}
}
public override int GetHashCode()
{
return(Entero.GetHashCode() + Cadena.GetHashCode());
}
private int ObtenerClave(Entero dato)
{
return(dato.valor);
}
//Imprime Contenido
public void Imprime()
{
Console.Write("Cadena: " + Cadena + " Caracter: " + Caracter.ToString());
Console.Write(" Entero: " + Entero.ToString() + " Real: " + NumReal.ToString());
Console.WriteLine(" Número de hijos: " + Hijos.Count + "\r\n");
}
public ActionResult IndexEntero(string submitButton)
{
switch (submitButton)
{
case "PreOrden":
Data <Entero> .instance.orden = 1;
break;
case "InOrden":
Data <Entero> .instance.orden = 0;
break;
case "PostOrden":
Data <Entero> .instance.orden = 2;
break;
case "Validacion":
Data <Entero> .instance.orden = 3;
break;
}
if (Data <Entero> .instance.orden == 0)
{
Data <Entero> .instance.lista.Clear();
Data <Entero> .instance.Arbol.MostrarInOrden(ref Data <Entero> .instance.lista);
}
else if (Data <Entero> .instance.orden == 1)
{
Data <Entero> .instance.lista.Clear();
Data <Entero> .instance.Arbol.MostrarPreOrden(ref Data <Entero> .instance.lista);
}
else if (Data <Entero> .instance.orden == 2)
{
Data <Entero> .instance.lista.Clear();
Data <Entero> .instance.Arbol.MostrarPostOrden(ref Data <Entero> .instance.lista);
}
else
{
Data <Entero> .instance.lista.Clear();
Entero ent = Data <Entero> .instance.Arbol.Equilibrio();
string equilibrio = "";
if (ent == null)
{
equilibrio = "esta equilibrado";
}
else
{
equilibrio = "no esta equilibrado";
}
string deg = Data <Entero> .instance.Arbol.degenerado() ? "es degenerado" : "no es degenerado";
if (ent == null)
{
Data <Entero> .instance.Arbol.MostrarInOrden(ref Data <Entero> .instance.lista);
}
else
{
Data <Entero> .instance.lista.Add(Data <Entero> .instance.Arbol.Equilibrio());
}
TempData["alertMessage"] = "El arbol " + equilibrio + " y " + deg;
}
return(View(Data <Entero> .instance.lista));
}
//Imprime Contenido
public void Imprime()
{
Console.Write("Cadena: " + Cadena + " Caracter: " + Caracter.ToString());
Console.WriteLine(" Entero: " + Entero.ToString() + " Real: " + NumReal.ToString());
}
public int comparador_enteros(Entero actual, Entero nuevo)
{
return(actual.valor.CompareTo(nuevo.valor));
}
public static int CompararEntero(Entero actual, Entero nuevo)
{
return(actual.valor.CompareTo(nuevo.valor));
}
public Tipo Type()
{
if (currentToken.Tipo == TipoToken.TK_CHAR)
{
Caracter C = new Caracter();
currentToken = lex.NextToken();
return C;
}
else if (currentToken.Tipo == TipoToken.TK_BOOL)
{
Booleano B = new Booleano();
currentToken = lex.NextToken();
return B;
}
else if (currentToken.Tipo == TipoToken.TK_STRING)
{
Cadena C = new Cadena();
currentToken = lex.NextToken();
return C;
}
else if (currentToken.Tipo == TipoToken.TK_FLOAT)
{
Flotante F = new Flotante();
currentToken = lex.NextToken();
return F;
}
else if (currentToken.Tipo == TipoToken.TK_INT)
{
Entero C = new Entero();
currentToken = lex.NextToken();
return C;
}
else if (currentToken.Tipo == TipoToken.TK_VOID)
{
Voids V = new Voids();
currentToken = lex.NextToken();
return V;
}
return null;
}
