Conj<Posicion> campus::Vecinos(Posicion p)
{// retorna vecinos validos dentro dela grilla,no importa si estan ocupados.
Posicion posArriba;//( p.x ,p.y-1);
posArriba.x = p.x;
posArriba.y = p.y-1;
Posicion posAbajo;//( p.x,p.y+1);
posAbajo.x = p.x;
posAbajo.y = p.y+1;
Posicion posDer;//(p.x+1,p.y);
posDer.x = p.x+1;
posDer.y = p.y;
Posicion posIzq;//(p.x-1,p.y);
posIzq.x = p.x-1;
posIzq.y = p.y;
Conj<Posicion> res;
// Agrego las posiciones validas:
if (Valida(posArriba)){ res.AgregarRapido(posArriba); }
if (Valida(posAbajo)) { res.AgregarRapido(posAbajo); }
if (Valida(posDer)) { res.AgregarRapido(posDer); }
if (Valida(posIzq)) { res.AgregarRapido(posIzq); }
return res;
}
Conj<Posicion> campus::IngresosCercanos(Posicion p)
{
Conj<Posicion> res;
Posicion posIngresoFilaUno;//(p.x,0); // ACA LA PRIMER FILA ES LA 0 (CAPAZ HAY QUE MODIFICARLO)
posIngresoFilaUno.x = p.x;
posIngresoFilaUno.y = 0;
Posicion posIngresoUltimaFila;//(p.x,Filas()-1); // LA ULTIMA FILA ES LA CANTIDAD DE FILAS - 1 (CAPAZ HAY QUE MODIFICARLO)
posIngresoUltimaFila.x = p.x;
posIngresoUltimaFila.y = Filas()-1;
if( Distancia(p,posIngresoFilaUno) < Distancia(p,posIngresoUltimaFila) ) // caso <
{
res.AgregarRapido(posIngresoFilaUno);
}
else
{
if( Distancia(p,posIngresoFilaUno) > Distancia(p,posIngresoUltimaFila) ) // caso >
{
res.AgregarRapido(posIngresoUltimaFila);
}
else
{//caso ==
res.AgregarRapido(posIngresoFilaUno);
res.AgregarRapido(posIngresoUltimaFila);
}
}
return res;
}
Conj<Posicion> Campus::Vecinos(Posicion pos) {
Conj<Posicion> conjPosiciones = Conj<Posicion>();
if (PosValida(ProxPosicion(pos, abajo))) {
conjPosiciones.AgregarRapido(ProxPosicion(pos, abajo));
} else {
conjPosiciones.AgregarRapido(Posicion(-1, -1));
}
if (PosValida(ProxPosicion(pos, arriba))) {
conjPosiciones.AgregarRapido(ProxPosicion(pos, arriba));
} else {
conjPosiciones.AgregarRapido(Posicion(-1, -1));
}
if (PosValida(ProxPosicion(pos, der))) {
conjPosiciones.AgregarRapido(ProxPosicion(pos, der));
} else {
conjPosiciones.AgregarRapido(Posicion(-1, -1));
}
if (PosValida(ProxPosicion(pos, izq))) {
conjPosiciones.AgregarRapido(ProxPosicion(pos, izq));
} else {
conjPosiciones.AgregarRapido(Posicion(-1, -1));
}
return conjPosiciones;
}
Conj<Registro_tp3> BaseDeDatos::busquedaCriterio(Registro_tp3 crit, string t) const {
assert( _nombreATabla.def(t) );
Tabla & tabla = _nombreATabla.obtener(t);
bool termine = false;
Conj<Registro_tp3> res;
class Lista<struct tupString<Dato> >::const_Iterador itCrit = crit.vistaDicc();
while (itCrit.HaySiguiente() && !termine) {
string campoCrit = itCrit.Siguiente().clave;
if (! tabla.campos().Pertenece(campoCrit) ) {
termine = true;
}
itCrit.Avanzar();
}
Conj<string> indices = tabla.indices();
Conj<string>::Iterador itIndices = indices.CrearIt();
while (itIndices.HaySiguiente() && !termine) {
if (crit.def(itIndices.Siguiente())) {
string campoIndice = itIndices.Siguiente();
Dato valorCampo = crit.obtener(campoIndice);
Lista<Registro_tp3> coincis = tabla.buscar(campoIndice, valorCampo);
Lista<Registro_tp3>::const_Iterador itCoincis = coincis.CrearIt();
while (itCoincis.HaySiguiente()) {
if (coincidenTodosCrit(crit, itCoincis.Siguiente())) {
Dato det = itCoincis.Siguiente().obtener(campoIndice);
res.AgregarRapido(itCoincis.Siguiente());
}
itCoincis.Avanzar();
}
termine = true;
}
itIndices.Avanzar();
}
if (!termine) {
Conj<Registro_tp3>::const_Iterador itRegs = tabla.registros().CrearIt();
while (itRegs.HaySiguiente()) {
if (coincidenTodosCrit(crit, itRegs.Siguiente())){
res.AgregarRapido(itRegs.Siguiente());
}
itRegs.Avanzar();
}
}
return res;
}
Conj<Registro_tp3> BaseDeDatos::combinarRegistros(string t1, string t2, string campo) const {
assert( _nombreATabla.def(t1) && _nombreATabla.def(t2) );
assert( _nombreATabla.obtener(t1).campos().Pertenece(campo) );
assert( _nombreATabla.obtener(t2).campos().Pertenece(campo) );
Tabla tabla1 = _nombreATabla.obtener(t1);
Tabla tabla2 = _nombreATabla.obtener(t2);
Conj<Registro_tp3>::const_Iterador it;
Tabla tablaIt = (tabla1.indices().Pertenece(campo))? tabla2 : tabla1;
Tabla tablaBusq = (tabla1.indices().Pertenece(campo))? tabla1 : tabla2;
it = tablaIt.registros().CrearIt();
Conj<Registro_tp3> res;
while (it.HaySiguiente()) {
Registro_tp3 regMergeado;
Dato d = it.Siguiente().obtener(campo);
Lista<Registro_tp3> coincis = tablaBusq.buscar(campo, d);
if (!coincis.EsVacia()) {
if (tablaBusq.nombre() == t1) {
regMergeado = Merge(coincis.Primero(), it.Siguiente());
} else {
regMergeado = Merge(it.Siguiente(), coincis.Primero());
}
}
Lista<struct tupString<Dato> >::const_Iterador ver_Vacio = regMergeado.vistaDicc();
if (ver_Vacio.HaySiguiente()) res.AgregarRapido(regMergeado);
it.Avanzar();
}
return res;
}
Conj<Gremio> SistemaLaboral::obtenerGremios() const
{
Conj<Gremio> result;
for (Nat i = 0; i < sl.Longitud(); i++)
result.AgregarRapido(sl[i]);
return result;
}
Conj<String> Registro::Campos() const{
Conj<String> res;
typename Dicc<String,Dato>::const_Iterador it = dic.CrearIt();
while (it.HaySiguiente()){
res.AgregarRapido(it.SiguienteClave());
it.Avanzar();
}
return res;
}
Conj<Gremio> Temporada::gremiosNegociando() const{
Conj<Gremio> res;
Conj<Paritaria>::const_Iterador it = this->paritariasAbiertas.CrearIt();
while(it.HaySiguiente()){
Paritaria pa = it.Siguiente();
res.AgregarRapido(pa.obtenerGremio());
it.Avanzar();
}
return res;
}
Conj<Lista<Compu> >& Red::CaminosQueEmpiezanConPcx(const Conj<Lista<Compu> >& caminos, const Compu& pcx) const {
Conj<Lista<Compu> >* res = new Conj<Lista<Compu> >();
Conj<Lista<Compu> >::const_Iterador it = caminos.CrearIt();
while(it.HaySiguiente()) {
if(it.Siguiente()[0] == pcx) {
res->AgregarRapido(it.Siguiente());
}
it.Avanzar();
}
return *res;
}
Conj<Nat> SistemaLaboral::obtenerAliados(const Nat idGremio) const
{
Nat idGrupoTarget = sl[idGremio].obtenerIdGrupo();
Conj<Nat> result;
for (Nat i = 0; i < sl.Longitud(); i++)
if ((i != idGremio) && (sl[i].obtenerIdGrupo() == idGrupoTarget))
result.AgregarRapido(i);
return result;
}
Conj<nat> Temporada::obtenerGremiosConAcuerdos() const{
Conj<nat> res;
for(nat j=0;j<this->acuerdosPorGrupo.Longitud();j++){
Lista<Acuerdo>::const_Iterador acuerdosDeGrupo = this->acuerdosPorGrupo[j].CrearIt();
while(acuerdosDeGrupo.HaySiguiente()){
Acuerdo ac = acuerdosDeGrupo.Siguiente();
res.AgregarRapido(ac.obtenerGremio().obtenerIdGremio());
acuerdosDeGrupo.Avanzar();
}
}
return res;
}
Conj<Lista<Compu> >& Red::CaminosQueTerminanConPcx(const Conj<Lista<Compu> >& caminos, const Compu& pcx) const {
Conj<Lista<Compu> >* res = new Conj<Lista<Compu> >();
Conj<Lista<Compu> >::const_Iterador it = caminos.CrearIt();
while(it.HaySiguiente()) {
Lista<Compu>::const_Iterador itUlt = it.Siguiente().CrearItUlt();
if(itUlt.Anterior() == pcx) {
res->AgregarRapido(it.Siguiente());
}
it.Avanzar();
}
return *res;
}
Conj<String> Registro::DiferenciaSimetrica(const Registro r2) const{
Conj<String> res;
Conj<String> c2(r2.Campos());
typename Conj<String>::Iterador it = c2.CrearIt();
Conj<String> c1(Campos());
while(it.HaySiguiente()){
if(!(c1.Pertenece(it.Siguiente()))){
res.AgregarRapido(it.Siguiente());
}
it.Avanzar();
}
return res;
}
Conj<empresa> Temporada::empresasNegociando() const{
Conj<empresa> res;
Conj<Paritaria>::const_Iterador it = this->paritariasAbiertas.CrearIt();
while(it.HaySiguiente()){
Paritaria pa = it.Siguiente();
Conj<empresa> empresasParitaria = pa.obtenerGremio().obtenerEmpresas();
Conj<empresa>::const_Iterador itEmpresas = empresasParitaria.CrearIt();
while(itEmpresas.HaySiguiente()){
res.AgregarRapido(itEmpresas.Siguiente());
itEmpresas.Avanzar();
}
it.Avanzar();
}
return res;
}
aed2::Conj<Columna> Driver::columnasDeTabla(const NombreTabla& tabla) const
{
Conj<Columna> res;
modulos::Registro r = b.DameTabla(tabla).Columnas();
Conj<String> c = b.DameTabla(tabla).Columnas().Campos();
typename Conj<String>::Iterador it = c.CrearIt();
while(it.HaySiguiente()){
Columna c;
c.nombre = it.Siguiente();
if (r.Obtener(it.Siguiente()).EsNat()){
c.tipo = NAT;
}else{
c.tipo = STR;
}
res.AgregarRapido(c);
it.Avanzar();
}
return res;
//assert(false);
}
Conj<Lista<Compu> > Red::CaminosDeLargoN(Compu c1, Compu c2, Nat n){
Conj<Lista<Compu> > caminos;
if(n == 0){
Lista<Compu> camino;
camino.AgregarAtras(c1);
caminos.AgregarRapido(camino);
} else {
Conj<Compu> vec = this->Vecinos(c1);
Conj<Compu>::Iterador itVecinos(vec);
while(itVecinos.HaySiguiente()){
Compu v = itVecinos.Siguiente();
Conj<Lista<Compu> > cams = this->CaminosDeLargoN(v, c2, n-1);
Conj<Lista<Compu> >::Iterador itCaminos(cams);
while(itCaminos.HaySiguiente()){
Lista<Compu> camino = itCaminos.Siguiente();
if(camino.Ultimo() == c2){
Lista<Compu> camino2 = camino;
camino2.AgregarAdelante(c1);
caminos.Agregar(camino2);
}
itCaminos.Avanzar();
}
itVecinos.Avanzar();
}
}
Conj<Lista<Compu> >::Iterador itCaminos2(caminos);
while(itCaminos2.HaySiguiente()){
if(itCaminos2.Siguiente().Ultimo() != c2){
itCaminos2.EliminarSiguiente();
}
if(itCaminos2.HaySiguiente()) itCaminos2.Avanzar(); //esta linea faltaba en el tp
}
return caminos;
}
void Red::ActualizarCaminosMasCortos(const Compu& pc1, const Compu& pc2) {
Conj<Lista<Compu> >& aux = CaminosQueTerminanConPcx(this->caminos, pc2);
Conj<Lista<Compu> >& caminosRes = CaminosQueEmpiezanConPcx(aux, pc1);
Conj<Lista<Compu> > caminosAAgregar;
Conj<Lista<Compu> >::Iterador itConjCamino = caminosRes.CrearIt();
if(itConjCamino.HaySiguiente()) {
Nat cantidadDeComputadorasEnCaminoMinimo = itConjCamino.Siguiente().Longitud();
while(itConjCamino.HaySiguiente()) {
if(cantidadDeComputadorasEnCaminoMinimo > itConjCamino.Siguiente().Longitud()) {
cantidadDeComputadorasEnCaminoMinimo = itConjCamino.Siguiente().Longitud();
}
itConjCamino.Avanzar();
}
while(itConjCamino.HayAnterior()) {
if(cantidadDeComputadorasEnCaminoMinimo == itConjCamino.Anterior().Longitud()) {
caminosAAgregar.AgregarRapido(itConjCamino.Anterior());
}
itConjCamino.Retroceder();
}
if(this->caminosMasCortos.definido(pc1.Ip())){
this->caminosMasCortos.obtener(pc1.Ip())->definir(pc2.Ip(), caminosAAgregar);
}
else{
DiccString<Conj<Lista<Compu> > > hasta;
hasta.definir( pc2.Ip(), caminosAAgregar );
this->caminosMasCortos.definir( pc1.Ip(), hasta );
}
}
delete &caminosRes;
delete &aux;
}
campusSeguro::campusSeguro(campus c, Dicc<Agente,Posicion> d)
{
campus camp = c;
DiccPalabra<Posicion> estyHip;// creo un DiccTrie vacio.
campusSeguro::DatosPos tup;
tup.id = 4;
tup.tag = "libre";
tup.placa = 0;
Nat cantidadFilas=c.Filas();
Nat cantidadColumnas=c.Columnas();
diccMatriz<campusSeguro::DatosPos> datosMatriz(cantidadFilas,cantidadColumnas,tup);
diccHash<Agente,campusSeguro::Datos> dicc(d.CantClaves()); // creo dicchash de tamaño d.Claves().Cardinal()
diccHash<Agente,campusSeguro::Datos>::Iterador itHashVacio = dicc.CrearIt();
tup.datosAgente = itHashVacio;
ConjsEqu<Agente> equSan; // creo un EqusEqu vacio y lo guardo en la variable equSan.
campusSeguro::DatosSanciones KSan;
Nat i = 0;
Nat j = 0;
while( i < c.Filas() )
{
while( j< c.Columnas())
{
//Posicion pos(i,j); // creo una posicion (i,j).
Posicion p;
p.x = i;
p.y = j;
campusSeguro::DatosPos data; // ESTA VARIABLE NO SE SI VA DENTRO DEL SCOPE DEL WHILE, xq SE BORRA.
if( _campus.Posocupada(p))
{
data.id = 0;
data.tag = "ocupada";
data.placa = 0;
data.datosAgente = itHashVacio;
datosMatriz.Definir(p, data);
}
j++;
}// endwhile
i++;
}// endwhile
Dicc<Agente,Posicion>::Iterador it;
it = d.CrearIt();
while( it.HaySiguiente() )
{
campusSeguro::DatosPos data; // ESTA VARIABLE NO SE SI VA DENTRO DEL SCOPE DEL WHILE, xq SE BORRA.
campusSeguro::Datos dataH;
Posicion pos;
Agente plak;
ConjsEqu<Agente>::Iterador itEqu;
plak = it.SiguienteClave();
pos = it.SiguienteSignificado();
itEqu = equSan.relacionar(0, plak);
dataH.pos = pos;
dataH.Sanciones = 0;
dataH.hippiesAtrapados = 0;
dataH.claseConMismasSanciones = itEqu;
data.id = 3;
data.tag = "agente";
data.placa = plak;
data.datosAgente = dicc.Definir(plak, dataH); // definir retorna un iterador de Dicc.
datosMatriz.Definir(pos, data);
it.Avanzar();
}
Arreglo<TuplaAgYSan> nuevoArreglo(1); // creo array de 1 posicion
KSan.arreglo = nuevoArreglo; // meto el arreglo en el campo arreglo de KSan.
KSan.buffer = false;
KSan.itMenosSanciones = equSan.CrearIt();
// el masvigilante al comienzo de la instancia campusSeguro es cualquier vigilante:
campusSeguro::DatosAgentesyAtrapados elMas;
Dicc<Agente,Posicion>::Iterador itAgts = d.CrearIt();
elMas.agente = itAgts.SiguienteClave();// el primer agente que encuentre.
elMas.cantAtrapados = 0;
// incio la instancia:
_campus = camp;
_estudiantes = estyHip;
_hippies = estyHip;
Conj<Agente> conjuntoDeAgentes; // conjunto vacio que almacenará agentes
Dicc<Agente,Posicion>::Iterador itDiccAgentes = d.CrearIt();
while(itDiccAgentes.HaySiguiente()) // voy llenando el conjunto con los agentes del diccionario.
{
conjuntoDeAgentes.AgregarRapido(itDiccAgentes.SiguienteClave());
itDiccAgentes.Avanzar();
}
_agentes = conjuntoDeAgentes;
datosAgentes = dicc;
grilla = datosMatriz;
_masVigilante = elMas;
equivalenciaSanciones = equSan;
KSanciones = KSan;
Dicc<Agente,Posicion>::Iterador it2;
it2 = d.CrearIt();
} // fin funcion constructora (rastrillaje).
