/// <summary> /// Genera una nueva jornada en el gimnasio con la clase dada. /// </summary> /// <param name="g">Gimnasio donde se genera la jornada.</param> /// <param name="clase">Clase de la jornada.</param> /// <returns>Gimnasio con la jornada generada.</returns> public static Gimnasio operator +(Gimnasio g, Gimnasio.EClases clase) { Jornada jornada = new Jornada(clase, (g == clase)); foreach (Alumno alumno in g._alumnos) { if (alumno == clase) { jornada += alumno; } } g._jornada.Add(jornada); return(g); }
/// <summary> /// Sobrecarga + en el cual se agrega una clase a una universidad /// </summary> /// <param name="g">Universidad </param> /// <param name="clase">clase a agregar en la universidad</param> /// <returns>Universidad con la clase agregada</returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor p = (g == clase); Jornada j = new Jornada(clase, p); foreach (Alumno item in g.alumnos) { if (item == clase) { j += item; } } g.Jornadas.Add(j); return(g); }
/// <summary> /// Al agregar una clase a un Universidad se deberá generar y agregar una nueva Jornada indicando la ///clase, un Profesor que pueda darla(según su atributo ClasesDelDia) y la lista de alumnos que la ///toman(todos los que coincidan en su campo ClaseQueToma). /// </summary> /// <param name="g">Universidad</param> /// <param name="clase">EClases</param> /// <returns>Universidad con la clase agregada</returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor profesor = (g == clase); Jornada jornada = new Jornada(clase, profesor); foreach (Alumno unAlumno in g.alumnos) { if (unAlumno == clase) { jornada += unAlumno; } } g.jornada.Add(jornada); return(g); }
public static Gimnasio operator +(Gimnasio g, EClases clase) { Instructor i = g == clase; Jornada j = new Jornada(clase, i); foreach (Alumno a in g._alumnos) { if (a == clase) { j += a; } } g._jornada.Add(j); return(g); }
/// <summary> /// Sobrecarga del operador + "Crea una jornada de la clase y la agrega al gimnasio" /// </summary> /// <param name="g">Gimnasio</param> /// <param name="clase">EClase</param> /// <returns>Gimnasio con la nueva clase cargada</returns> public static Gimnasio operator +(Gimnasio g, EClases clase) { if (!object.Equals(g, null)) { Jornada j = new Jornada(clase, (g == clase)); for (int i = 0; i < g._alumnos.Count; i++) { if (g._alumnos[i] == clase) { j = j + g._alumnos[i]; g._jornadas.Add(j); } } } return(g); }
/// <summary> /// Método static /// encargado de configurar el path y el nombre de archivo donde se /// guardaran los datos de una jornada /// </summary> /// <param name="jornada"></param> Tipo Jornada /// <returns> bool, si se guardaro el archivo retorna true, de lo contrario false </returns> public static bool Guardar(Jornada jornada) { string miPath = string.Format("{0}{1}", Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments), "\\jornada.txt"); if (!(jornada is null)) { Texto texto = new Texto(); if (texto.Guardar(miPath, jornada.ToString())) { return(true); } } return(false); }
/// <summary> /// Agrega una jornada a la universidad /// </summary> /// <param name="g">Universidad</param> /// <param name="clase">Clase</param> /// <returns>Universidad con nueva jornada</returns> public static Universidad operator +(Universidad g, Universidad.EClases clase) { Profesor profesorDisponible = (g == clase); Jornada jornada = new Jornada(clase, profesorDisponible); foreach (Alumno a in g.alumnos) { if (a == clase) { jornada.Alumnos.Add(a); } } g.jornada.Add(jornada); return(g); }
/// <summary> /// Agrega una Jornada a la lista de jornadas de la Universidad si, y solo si, hay un profesor disponible para la Jornada /// </summary> /// <param name="g">Universidad a la que se agrega la Jornada</param> /// <param name="clase">EClase que indica la materia de la jornada que se agrega</param> /// <returns></returns> public static Universidad operator +(Universidad g, EClases clase) { Jornada j = new Jornada(clase, (g == clase)); foreach (Alumno a in g.alumnos) { if (a == clase) { j.Alumnos.Add(a); } } g.jornadas.Add(j); return(g); }
/*Al agregar una clase a un Gimnasio se deberá generar y agregar * una nueva jornada indicando la clase, un instructor que pueda darla * (según su atributo ClasesDelDia) y la lista de Alumnos que la toman * (todos los que coincidadn en su campo ClaseQueToma) */ public static Gimnasio operator +(Gimnasio g, EClases clase) { //Creo y agrego la nuevaJornada a la lista _jornadas Jornada nuevaJornada = new Jornada(clase, g == clase); g._jornadas.Add(nuevaJornada); foreach (Alumno item in g._alumnos) { if (item == clase) { nuevaJornada += item; } } return(g); }
/// <summary> /// Guarda los datos de una jornada en un archivo de texto. /// </summary> /// <param name="jornada">Jornada a guarda.</param> /// <returns></returns> public static bool Guardar(Jornada jornada) { try { Texto txt = new Texto(); return(txt.guardar(FILE_NAME, jornada.ToString())); } catch (ArchivosException e) { throw e; } catch (Exception e) { throw new ArchivosException(e); } }
/// <summary> /// sobrecarga del operador + entre una universidad y una clase /// </summary> /// <param name="g">univercidad</param> /// <param name="clase">clase</param> /// <returns>retorna la univercidad con la clase agregada</returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor profesor = g == clase; Jornada jornada = new Jornada(clase, profesor); foreach (Alumno alumnosEnUnivercidad in g.Alumnos) { if (alumnosEnUnivercidad == clase) { jornada += alumnosEnUnivercidad; } } g.Jornadas.Add(jornada); return(g); }
/// <summary> /// Guarda una jornada en un archivo de texto /// </summary> /// <param name="jornada"></param> /// <returns>True si puede guardar la jornada</returns> public static bool Guardar(Jornada jornada) { bool retorno = false; IArchivo <string> archivosTexto = new Texto(); string ruta = AppDomain.CurrentDomain.BaseDirectory + "Jornada.txt"; try { retorno = archivosTexto.Guardar(ruta, jornada.ToString()); } catch (ArchivosException e) { throw e; } return(retorno); }
public static bool Guardar(Jornada j) { Texto guardado = new Texto(); bool retorno = false; string path = AppDomain.CurrentDomain.BaseDirectory; if (guardado.Guardar(AppDomain.CurrentDomain.BaseDirectory + "jornada.txt", j.ToString())) { retorno = true; } else { retorno = false; } return(retorno); }
/// <summary> /// Sobrecarga del operador +. Se creara un objeto del tipo Jornada, se le asignara un profesor capaz de dar la clase y los /// inscriptos en la misma /// </summary> /// <param name="u">Objeto del tipo Universidad</param> /// <param name="clase">Objeto del tipo Universidad.EClases</param> /// <returns>retorna u</returns> public static Universidad operator +(Universidad u, Universidad.EClases clase) { Profesor p = u == clase; Jornada j = new Jornada(clase, p); foreach (Alumno item in u.Alumnos) { if (item == clase) { j += item; } } u.Jornada.Add(j); return(u); }
/// <summary> /// Metodo que guarda los datos de la Jornada en un archivo de texto /// </summary> /// <param name="jornada"></param> /// <returns>true si pudo guarda , false si no pudo</returns> public static bool Guardar(Jornada jornada) { bool retorno = false; try { StreamWriter text = new StreamWriter(@"C:\Users\Mariano\Downloads\jornada.txt"); text.Write(jornada.ToString()); text.Close(); retorno = true; } catch (Exception) { throw new ArchivosException("Error al guardar el archivo"); } return(retorno); }
/// <summary> /// Operador /// </summary> /// <param name="u"></param> /// <param name="clase"></param> /// <returns></returns> public static Universidad operator +(Universidad u, Universidad.EClases clase) { Profesor profesor = (u == clase); Jornada jornada = new Jornada(clase, profesor); foreach (Alumno item in u.Alumnos) { if (item == clase) { jornada = jornada + item; } } u.Jornadas.Add(jornada); return(u); }
/// <summary> /// Guardar de clase guardará los datos de la Jornada en un archivo de texto. /// Archivo se crea en el escritorio de la pc que lo ejecuta /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static bool Guardar(Jornada jornada) { bool banderita = false; try { Texto t = new Archivo.Texto(); banderita = t.Guardar(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt", jornada.ToString()); } catch (Exception e) { throw new ArchivosException(e); } return(banderita); }
/// <summary> /// Agrega una nueva jornada a la universidad con un nuevo profesor y añade los alumnos que toman esa clase. /// </summary> /// <param name="g">universidad recibida</param> /// <param name="clase">clase recibida</param> /// <returns>Retorna la universidad.</returns> public static Universidad operator +(Universidad g, EClases clase) { if (!(g is null)) { Profesor profe = (g == clase); Jornada jornada = new Jornada(clase, profe); foreach (Alumno alumno in g.alumnos) { if (alumno == clase) { jornada.Alumnos.Add(alumno); } } g.jornada.Add(jornada); } return(g); }
/// <summary> /// Sobrecarga método "+" entre universidad y clase. Agrega una clase nueva a la universidad /// asignandole un profesor y al menos un alumno. /// </summary> /// <param name="g"></param> /// <param name="clase"></param> /// <returns>Retorna la universidad.</returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor p = new Profesor(); bool flagProfesor = false; bool flagAlumno = false; //Recorrer lista de profesores para obtener uno que pueda dictar esa clase. foreach (Profesor auxProfesor in g.profesores) { //Sobrecarga == obtiene un profesor que pueda dictar dicha clase. if (auxProfesor == clase) { //Asigno en variable "p" el profesor que va a ser titular en la jornada. p = auxProfesor; flagProfesor = true; break; } } //Nueva jornada con profesor y clase. Jornada j = new Jornada(clase, p); //Recorrer lista de alumnos para obetener los que matcheen entre clase // y el atributo claseQueToma de alumno. foreach (Alumno auxAlumno in g.alumnos) { if (auxAlumno == j.Clase) { flagAlumno = true; //Agregar al alumno a la jornada. j += auxAlumno; } } //Si fue asignado algun profesor y fue agregado al menos un alumno, agrego la jornada. if (flagAlumno && flagProfesor) { g.jornada.Add(j); } else { throw new SinProfesorException(); } return(g); }
/// <summary> /// Agrega una clase a una nueva jornada, la cual es agregada a la lista de jornadas de una universidad. /// </summary> /// <param name="gim">Universidad donse se agregará la clase.</param> /// <param name="clase">Clase a agregar.</param> /// <returns>Universidad con la nueva jornada que contiene la clase agregada.</returns> public static Universidad operator +(Universidad gim, EClases clase) { Universidad auxUniversidad; auxUniversidad = gim; Jornada jornada = new Jornada(clase, auxUniversidad == clase); for (int i = 0; i < auxUniversidad._alumnos.Count; i++) { if (auxUniversidad._alumnos[i] == clase) { jornada += auxUniversidad._alumnos[i]; } } auxUniversidad._jornada.Add(jornada); return(auxUniversidad); }
/// <summary> /// Sobrecarga del operador + (Universidad / Enumerado EClases) /// </summary> /// <param name="g"></param> Tipo Universidad /// <param name="clase"></param> Tipo Enumerado EClases /// <returns> Universidad que contendra una nueva jornada si existen profesores /// para una clase determinada (EClases) /// de lo contrario devolvera la misma Universidad pasada como parámetro </returns> public static Universidad operator +(Universidad g, EClases clase) { Profesor auxProfesor = (g == clase); if (!(auxProfesor is null)) { Jornada auxJornada = new Jornada(clase, auxProfesor); foreach (Alumno item in g.Alumnos) { if (item == clase) { auxJornada += item; } } g.Jornadas.Add(auxJornada); } return(g); }
/// <summary> /// Leer de clase retornará los datos de la Jornada como texto /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static string Leer(Jornada jornada) { string datos; string archivo; bool s = false; try { Texto t = new Archivo.Texto(); archivo = Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory) + "\\Jornada.txt"; s = t.Leer(archivo, out datos);; } catch (Exception e) { throw new ArchivosException(e); } return(datos); }
/// <summary> /// Sobrecarga del operador + "Crea una jornada de la clase y la agrega al gimnasio" /// </summary> /// <param name="g">Gimnasio</param> /// <param name="clase">EClase</param> /// <returns>Gimnasio con la nueva clase cargada</returns> public static Gimnasio operator +(Gimnasio g, EClases clase) { if (!object.Equals(g, null)) { Instructor instructor = (g == clase); if (instructor != null) { Jornada jornadaAgregar = new Jornada(clase, instructor); for (int i = 0; i < g._alumnos.Count; i++) { if (g._alumnos[i] == clase) { jornadaAgregar += g._alumnos[i]; } } g._jornadas.Add(jornadaAgregar); } } return(g); }
public static Universidad operator +(Universidad g, EClases clase) { Profesor profAux = (g == clase); Jornada jornada = new Jornada(clase, profAux); bool flag = false; for (int i = 0; i < g.alumnos.Count; i++) { if (g.alumnos[i] == clase) { jornada += g.alumnos[i]; flag = true; } } if (flag == true) { g.jornada.Add(jornada); } return(g); }
public static Universidad operator +(Universidad g, EClases clase) { try { Jornada j = new Jornada(clase, g == clase); g.Jornadas.Add(j); foreach (Alumno a in g.Alumnos) { if (a == clase) { j.Alumnos.Add(a); } } return(g); } catch (Exception e) { throw e; } }
public static Gimnasio operator +(Gimnasio g, EClases clase) { //foreach (Instructor item in g._instructores) //{ // if ( item == clase) // Jornada j = new Jornada(clase,item); //} Jornada j = new Jornada(clase, (g == clase)); foreach (Alumno item in g._alumnos) { if (item == clase) { j = j + item;//sobrecargas jornada + alumno } } g._jornada.Add(j);//agrego la jornada return(g); }
/// <summary> /// Guarda en el archivo Jornada.txt los datos de la Jornada como texto. /// El archivo se encontrara en EntidadesInstanciables/bin/Debug/ /// </summary> /// <param name="jornada">Jornada que se desea guardar.</param> /// <returns> /// true si se pudo guardar. Si no puede guardar lanzara una excepcion ArchivosException. /// false si no. /// </returns> public static bool Guardar(Jornada jornada) { /* * Sigo pensando que tiene errores el TP, por ej esta funcion nunca va a devolver false, por lo tanto * no tiene sentido que devuelva un bool. Sin embargo Es la forma en la que mas sentido le encontre * segun el constructor de la clase ArchivosException y segun los metodos de las clases Texto y Xml que devuelven bool. */ bool b = false; try { Archivos.Texto objTexto = new Archivos.Texto(); b = objTexto.guardar("Jornada.txt", jornada.ToString()); } catch (Exception e) { throw new ArchivosException(e); } return(b); }
// METODOS GUARDAR Y LEER /// <summary> /// Guarda los datos de la jornada dentro de un archivo. /// </summary> /// <param name="jornada"></param> /// <returns></returns> public static bool Guardar(Jornada jornada) { bool retorno = false; try { Texto t = new Texto(); if (t.Guardar("jornada.txt", jornada.ToString())) { retorno = true; } } catch (ArchivosException e) { Console.WriteLine(e.Message.ToString()); } return(retorno); }
/// <summary> /// Agrega una jornada al gimnasio si hay un instructor que pueda dar la clase /// </summary> /// <param name="g">Gimnasio</param> /// <param name="clase">Clase a agregar a la jornada</param> /// <returns></returns> public static Gimnasio operator +(Gimnasio g, EClases clase) { try { Jornada j = new Jornada(clase, g == clase); foreach (Alumno item in g._alumnos) { if (item == clase) { j += item; } } g._jornada.Add(j); return(g); } catch (SinInstructorException e) { throw e; } }
/// <summary> /// agrega una nueva jornada a la universidad validando que halla un profesor que puedar dar dicha clase y agregando alumnos a la jornada que esten anotados en dicha clase /// </summary> /// <returns>retorna una universidad con la jornada cargada si estuvo todo bien o la universidad sin la jornada por no haber un profesor que de dicha clase</returns> public static Universidad operator +(Universidad g, EClases clase) { int bandera = 0; Profesor aux = (g == clase); Jornada jornada = new Jornada(clase, aux); for (int i = 0; i < g.alumnos.Count; i++) { if (g.alumnos[i] == clase) { jornada += g.alumnos[i]; bandera = 1; } } if (bandera == 1) { g.Jornadas.Add(jornada); } return(g); }