//Posicion campusSeguro::proxPosicion(Posicion p,Conj<Posicion>::Iterador itPos)
Posicion campusSeguro::proxPosicion(Posicion p,DiccPalabra<Posicion>::itDiccP itPos)
{
Posicion posMasCerca=itPos.SiguienteSignificado();
Nat distActual = _campus.Distancia(p,posMasCerca);
while( itPos.HaySiguiente() )
{
if( _campus.Distancia(p,itPos.SiguienteSignificado()) < distActual )
{
posMasCerca=itPos.SiguienteSignificado();
distActual=_campus.Distancia(p,posMasCerca);
}
itPos.Avanzar();
}
Conj<Posicion> vecinos = _campus.Vecinos(p);
Conj<Posicion>::Iterador itVecinos = vecinos.CrearIt();
Posicion sigPos = p;
while( itVecinos.HaySiguiente() )
{
Posicion vec = itVecinos.Siguiente();
if( _campus.Distancia(vec,posMasCerca) < _campus.Distancia(p,posMasCerca) && (grilla.Obtener(vec)).id==4 ) // la grilla el campo id es de DatosPos
{
sigPos=vec;
}
itVecinos.Avanzar();
}
return sigPos;
}
void test_inspeccion_con_empate() {
Conj<Estacion> es;
es.Agregar("Belgrano");
es.Agregar("Retiro");
Driver d(es);
d.AgregarSenda("Belgrano","Retiro","ca");
Conj<Caracteristica> cs1;
cs1.Agregar("cb");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Belgrano");
d.Entrar(cs1,"Retiro");
ASSERT_EQ(d.CantidadRobotsActivos(),4);
d.Mover(0, "Retiro");
d.Mover(1, "Retiro");
d.Mover(2, "Retiro");
d.Inspeccion("Retiro"); // debe volar un solo RUR del conj {0,1,2}
ASSERT_EQ(d.CantidadRobotsActivos(),3);
infoRobots info = getDatosRobotsActivos(d);
// Chequeo que los que quedan están ok
// Alguno de los primeros RURs tuvo que desaparecer
ASSERT(!(info.estaciones.Definido(0) && info.estaciones.Definido(1) && info.estaciones.Definido(2)));
ASSERT_EQ(info.estaciones.Significado(3),"Retiro");
ASSERT_EQ(info.infracciones.Significado(3),0);
}
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 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;
}
void test_restriccion() {
Rest rojo("rojo");
Rest amarillo("Amarillo");
Rest verde("VERDE");
Rest res1((rojo.OR(amarillo)).AND(verde.NOT()));
// Rest res1("(rojo | Amarillo) & !VERDE");
Conj<Caracteristica> carac;
carac.Agregar("Amarillo");
// ASSERT(res1 -> Verifica(carac));
ASSERT(res1.Verifica(carac));
Rest coso("Coso");
Rest noCoso(coso.NOT());
Rest res2 = res1.AND(noCoso);
carac.Agregar("Coso");
ASSERT(res1.Verifica(carac));
ASSERT(!res2.Verifica(carac));
Conj<Caracteristica> carac2;
carac2.Agregar("Coso");
Rest siCoso = noCoso.NOT();
ASSERT(siCoso.Verifica(carac2));
}
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<unsigned int> Planta::verOrdenes() const{
Conj<unsigned int> res;
Secu<ordtars>::const_iterador it = this->terminadas.crearIt();
while (it.hayMas()){
res.agregar(it.actual().orden);
it.avanzar();
}
return res;
}
Conj<Posicion> Campus::IngresosMasCercanos(Posicion pos) {
Conj<Posicion> conjunto = Conj<Posicion>();
Posicion superior = Posicion(pos.x, 0);
Posicion inferior = Posicion(pos.x, Filas()-1);
if (Distancia(pos, superior) <= Distancia(pos, inferior))
conjunto.Agregar(superior);
if (Distancia(pos, superior) >= Distancia(pos, inferior))
conjunto.Agregar(inferior);
return conjunto;
}
Conj<Compu> Red::Computadoras(){
vector<string> vec = vecinos.claves();
Conj<Compu> con;
for(unsigned int i = 0; i<vec.size(); i++){
con.Agregar(vec[i]);
}
return con;
}
const Interfaz Driver::IesimaInterfazDe(const Computadora& c, Nat i) const {
assert(i < dameCompu(c).Interfaces().Cardinal());
//cout<<"Interfaces de la compu: "<<dameCompu(c).Interfaces()<<endl;
Conj<dcnet::Interfaz> conj = dameCompu(c).Interfaces();
Conj<dcnet::Interfaz>::Iterador it = conj.CrearIt();
while(i-- > 0) {
it.Avanzar();
}
return it.Siguiente();
}
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<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;
}
void campusSeguro::actualizarDatosAgentes(Conj<Posicion> c)
{
Posicion posActual;
Conj<Posicion>::Iterador it = c.CrearIt();
while( it.HaySiguiente() )
{
posActual=it.Siguiente();
if( posCapturable(posActual,_campus) )
{
Conj<Posicion> vecinosDePosActual = _campus.Vecinos(posActual);
Conj<Posicion>::Iterador itVec = vecinosDePosActual.CrearIt();
while( itVec.HaySiguiente())
{
Posicion vecActual = itVec.Siguiente();
if( esAgente(vecActual) && esHippie(posActual) )
{
diccHash<Agente,Datos>::Iterador datosVec = grilla.Obtener(vecActual).datosAgente;
datosVec.SiguienteSignificado().hippiesAtrapados++;
Nat cantAtrapadosVec = datosVec.SiguienteSignificado().hippiesAtrapados;
if(cantAtrapadosVec > _masVigilante.cantAtrapados )
{
(_masVigilante).agente = datosVec.SiguienteClave();
(_masVigilante).cantAtrapados = cantAtrapadosVec;
}
if( (cantAtrapadosVec == (_masVigilante).cantAtrapados) && ( datosVec.SiguienteClave()< (_masVigilante).agente) )
{
(_masVigilante).agente = datosVec.SiguienteClave();
(_masVigilante).cantAtrapados = cantAtrapadosVec;
}
}
if( esAgente(vecActual) && esEstudiante(posActual) )
{
//diccHash<Agente,Datos>::Iterador datosVec = grilla.Obtener(vecActual).datosAgente;
//datosVec.SiguienteSignificado().Sanciones++;
//Nat vecSancionesActual = datosVec.SiguienteSignificado().Sanciones;
Agente ac = grilla.Obtener(posActual).placa;
datosAgentes.Obtener(ac).Sanciones ++;
//Nat vecSancionesActual = datosAgentes.Obtener(ac).Sanciones;
//datosAgentes.Obtener(ac).claseConMismasSanciones.ItActualizarElem(vecSancionesActual);
//datosVec.SiguienteSignificado().claseConMismasSanciones.ItActualizarElem(vecSancionesActual); // CREOOO QUE ES DE CONJEQU
(KSanciones).buffer = false;
}
itVec.Avanzar();
}
}
it.Avanzar();
}
}
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<Compu> Red::Vecinos(Compu c){
DiccString<unsigned int> * x = vecinos.obtener(c);
vector<string> vec = x->claves();
Conj<Compu> con;
for(unsigned int i = 0; i<vec.size(); i++){
con.Agregar(vec[i]);
}
return con;
}
Conj<unsigned int> Planta::ordenesFinalizadas() const{
Conj<unsigned int> res;
Secu<ordtars>::const_iterador it = this->terminadas.crearIt();
while (it.hayMas()){
if (terminoOrden(it.actual().tareas, this->wkf.cantidadTareas())){
res.agregar(it.actual().orden);
}
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;
}
bool Driver::tieneIndiceString(const NombreTabla& tabla) const
{
const Conj<String> indices = b.DameTabla(tabla).Indices();
typename Conj<String>::const_Iterador it = indices.CrearIt();
bool res= false;
while(it.HaySiguiente() && !res){
res = !(b.DameTabla(tabla).TipoCampo(it.Siguiente()));
it.Avanzar();
}
return res;
//assert(false);
}
Conj<Lista<Compu> > Red::CaminosMinimos(Compu c1, Compu c2){
Nat k = 1;
Nat n = Computadoras().Cardinal();
Conj<Lista<Compu> > x = CaminosDeLargoN(c1, c2, k);
while(k<n && x.EsVacio()){
k++;
x = CaminosDeLargoN(c1,c2, k);
}
return x;
}
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;
}
aed2::Conj<Driver::Registro> Driver::vistaJoin(const NombreTabla& tabla1, const NombreTabla& tabla2)
{
Conj<Driver::Registro> res;
Conj<modulos::Registro> cr = b.VistaJoin(tabla1,tabla2).Siguiente().Registros();
typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
while(itr.HaySiguiente()){
res.Agregar(RNRS(itr.Siguiente()));
itr.Avanzar();
}
return res;
//assert(false);
}
/**
* Ejemplo de caso de test, con llamadas a las rutinas de aserción
* definidas en mini_test.h
*/
void test_ciudad_simple()
{
Conj<Estacion> estaciones;
estaciones.Agregar("Belgrano");
estaciones.Agregar("Retiro");
estaciones.Agregar("Martinez");
Driver caba(estaciones);
caba.AgregarSenda("Belgrano", "Retiro", "(trenDePasajeros | trenDeCarga) & !trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Retiro", "trenDeLaAlegria");
caba.AgregarSenda("Martinez", "Belgrano", "trenDePasajeros");
Conj<Caracteristica> r1, r2, r3;
r1.Agregar("trenDePasajeros");
r2.Agregar("trenDeCarga");
r3.Agregar("trenDeLaAlegria");
caba.Entrar(r1,"Belgrano"); // RUR 0
caba.Entrar(r2,"Retiro"); // RUR 1
caba.Entrar(r3,"Martinez"); // RUR 2
ASSERT_EQ(caba.CantidadEstaciones(), 3);
ASSERT_EQ(caba.CantidadRobotsActivos(), 3);
ASSERT_EQ(caba.CantidadDeSendasParaEstacion("Belgrano"), 2);
caba.Mover(0,"Retiro"); // RUR 0: 0 infracciones
caba.Mover(0,"Martinez"); // RUR 0: 1 infracciones
caba.Mover(1,"Belgrano"); // RUR 1: 0 infracciones
caba.Mover(1,"Martinez"); // RUR 1: 1 infracciones
caba.Mover(2,"Belgrano"); // RUR 2: 1 infracciones
caba.Mover(2,"Retiro"); // RUR 2: 2 infracciones
Dicc<RUR,Nat> infraccionesRobots;
// Chequeo infracciones iterando los robots
for (Nat i = 0; i< caba.CantidadRobotsActivos(); ++i)
infraccionesRobots.Definir(caba.IesimoRobotActivo(i),caba.CantInfraccionesIesimoRobotActivo(i));
ASSERT_EQ(infraccionesRobots.Significado(0), 1);
ASSERT_EQ(infraccionesRobots.Significado(1), 1);
ASSERT_EQ(infraccionesRobots.Significado(2), 2);
ASSERT_EQ(caba.ElMasInfractor(),2);
// Vuela un robot
caba.Inspeccion("Retiro");
ASSERT_EQ(caba.CantidadRobotsActivos(),2);
}
Interfaz Red::Max(const Conj<Interfaz>& conj) const {
assert(conj.Cardinal() > 0);
Conj<Interfaz>::const_Iterador it = conj.CrearIt();
Interfaz max = it.Siguiente();
while (it.HaySiguiente()){
if(max <= it.Siguiente()){
max = it.Siguiente();
}
it.Avanzar();
}
return max;
}
bool campusSeguro::posConvertibleAEstudiante(Posicion p,campus c)
{
Conj<Posicion> vecinos = c.Vecinos(p);
Conj<Posicion>::Iterador it = vecinos.CrearIt();
Nat cantEstudiantes = 0;
while( it.HaySiguiente() )
{
Posicion posVec = it.Siguiente();
if( (grilla.Obtener(posVec)).id==1 ) {cantEstudiantes=cantEstudiantes+1;}
it.Avanzar();
}
return cantEstudiantes==4;
}
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;
}
aed2::Conj<Driver::Registro> Driver::buscar(const NombreTabla& tabla, const aed2::Driver::Registro& criterio) const
{
Conj<Driver::Registro> res;
modulos::Registro crit = RSRN(criterio);
Conj<modulos::Registro> cr = b.DameTabla(tabla).BuscarT(crit);
typename Conj<modulos::Registro>::Iterador itr = cr.CrearIt();
while(itr.HaySiguiente()){
res.Agregar(RNRS(itr.Siguiente()));
itr.Avanzar();
}
return res;
//assert(false);
}
Arreglo<Posicion> Campus::DeConjAArreglo(Conj<Posicion> c) {
Arreglo<Posicion> arreglo = Arreglo<Posicion>(c.Cardinal());
Conj<Posicion>::Iterador itConjunto = c.CrearIt();
Nat i = 0;
while (itConjunto.HaySiguiente()) {
// Copiar lo siguiente..
if (itConjunto.Siguiente() != Posicion(-1, -1)) {
arreglo.Definir(i, itConjunto.Siguiente());
}
++i;
itConjunto.Avanzar();
}
return arreglo;
}
