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();
}
}
void campusSeguro::actualizarEstYHippie(Conj<Posicion> c)
{
Posicion posActual;
Conj<Posicion>::Iterador it = c.CrearIt();
while( it.HaySiguiente() )
{
posActual = it.Siguiente();
if( posConvertibleAHippie(posActual,_campus) && esEstudiante(posActual) )
{
grilla.Obtener(posActual).id = 2;
(_estudiantes).Borrar( grilla.Obtener(posActual).tag );
(_hippies).Definir( grilla.Obtener(posActual).tag, posActual );
}
else
{
if( posConvertibleAEstudiante(posActual,_campus) && esHippie(posActual) )
{
grilla.Obtener(posActual).id = 1;
(_hippies).Borrar( grilla.Obtener(posActual).tag );
(_estudiantes).Definir( grilla.Obtener(posActual).tag , posActual );
}
}
}
it.Avanzar();
}
//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;
}
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();
}
bool Registro::CoincideAlguno(const Conj<String> cc, const Registro r2) const{
bool b = false;
typename Conj<String>::const_Iterador it1 = cc.CrearIt();
while(it1.HaySiguiente() && !b){
if(Obtener(it1.Siguiente()) == r2.Obtener(it1.Siguiente()) ){
b = true;
}
it1.Avanzar();
}
return b;
}
void Driver::AgregarComputadora(const Computadora& ip, const Conj<Interfaz>& ci) {
Compu c(ip);
Conj<Interfaz>::const_Iterador it = ci.CrearIt();
while(it.HaySiguiente()) {
c.AgInterfaz(it.Siguiente());
it.Avanzar();
}
this->red->AgCompu(c);
}
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);
}
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<Registro_tp3>::const_Iterador BaseDeDatos::generarVistaJoin(string t1, string t2, string campo) {
assert( _nombreATabla.def(t1) && _nombreATabla.def(t2) );
assert( _nombreATabla.obtener(t1).claves().Pertenece(campo) );
assert( _nombreATabla.obtener(t2).claves().Pertenece(campo) );
tupBdd aux;
aux.campoJoin = campo;
aux.cambiosT1 = Lista<tupInterna>();
aux.cambiosT2 = Lista<tupInterna>();
_hayJoin.obtener(t1).definir(t2, aux);
_registrosDelJoin.obtener(t1).definir(t2, Conj<Registro_tp3>());
Tabla tabla1 = _nombreATabla.obtener(t1);
Tabla tabla2 = _nombreATabla.obtener(t2);
if (tabla1.tipoCampo(campo)) {
_joinPorCampoNat.obtener(t1).definir(t2, diccNat < Conj<Registro_tp3>::Iterador>());
Conj<Registro_tp3> regsMergeados = combinarRegistros(t1, t2, campo);
Conj<Registro_tp3>::Iterador it = regsMergeados.CrearIt();
while (it.HaySiguiente()) {
Dato d = it.Siguiente().obtener(campo);
Conj<Registro_tp3>::Iterador iter = _registrosDelJoin.obtener(t1).obtener(t2).AgregarRapido(it.Siguiente());
unsigned int n = d.dame_valorNat();
_joinPorCampoNat.obtener(t1).obtener(t2).definir(n, iter);
it.Avanzar();
}
} else {
_joinPorCampoString.obtener(t1).definir(t2, diccString < Conj<Registro_tp3>::Iterador>());
Conj<Registro_tp3> regsMergeados = combinarRegistros(t1, t2, campo);
Conj<Registro_tp3>::Iterador it = regsMergeados.CrearIt();
while (it.HaySiguiente()) {
Dato d = it.Siguiente().obtener(campo);
Conj<Registro_tp3>::Iterador iter = _registrosDelJoin.obtener(t1).obtener(t2).AgregarRapido(it.Siguiente());
string s = d.dame_valorStr();
_joinPorCampoString.obtener(t1).obtener(t2).definir(s, iter);
it.Avanzar();
}
}
Conj<Registro_tp3>::const_Iterador res = _registrosDelJoin.obtener(t1).obtener(t2).CrearIt();
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);
}
Registro Registro::CopiarCampos(const Conj<String> cc, const Registro r2) const{
Conj<String>::const_Iterador it = cc.CrearIt();
Registro res(*this);
while(it.HaySiguiente()){
if (Def(it.Siguiente())){
res.DefinirLento(it.Siguiente(), r2.Obtener(it.Siguiente()));
}else{
res.Definir(it.Siguiente(), r2.Obtener(it.Siguiente()));
}
it.Avanzar();
}
return res;
}
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;
}
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;
}
void campusSeguro::matarHippies(Conj<Posicion> c)
{
Posicion posActual;
Conj<Posicion>::Iterador it = c.CrearIt();
while( it.HaySiguiente() )
{
posActual = it.Siguiente();
if( posCapturable(posActual,_campus) && esHippie(posActual) )
{
grilla.Obtener(posActual).id = 4;
(_hippies).Borrar( grilla.Obtener(posActual).tag );
}
it.Avanzar();
}
}
bool campusSeguro::posCapturable(Posicion p,campus c)
{
Conj<Posicion> vecinos = c.Vecinos(p);
Conj<Posicion>::Iterador it = vecinos.CrearIt();
Nat cantOcupados = 0;
Nat cantAgentes = 0;
while( it.HaySiguiente() )
{
Posicion posVec = it.Siguiente();
if( (grilla.Obtener(posVec)).id != 4 ){cantOcupados=cantOcupados + 1;}
if( (grilla.Obtener(posVec)).id == 3 ){cantAgentes=cantAgentes + 1;}
it.Avanzar();
}
return (cantAgentes > 0 && cantOcupados == vecinos.Cardinal());
}
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;
}
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;
}
void Driver::crearTabla(const NombreTabla& nombre, const aed2::Conj<Columna>& columnas, const aed2::Conj<NombreCampo>& claves)
{
modulos::Registro r;
Conj<Columna> c = columnas;
typename Conj<Columna>::Iterador it = c.CrearIt();
while(it.HaySiguiente()){
if(it.Siguiente().tipo == NAT){
modulos::Dato d(4);
r.Definir(it.Siguiente().nombre, d);
}else{
modulos::Dato d("brownie");
r.Definir(it.Siguiente().nombre, d);
}
it.Avanzar();
}
modulos::Tabla t(nombre, claves, r);
b.AgregarTabla(t);
//assert(false);
}
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);
}
void campusSeguro::actualizarVecinos(Posicion p)
{
Conj<Posicion> vec = _campus.Vecinos(p);
Conj<Posicion>::Iterador itVecinos = vec.CrearIt();
actualizarDatosAgentes(vec, p);
while( itVecinos.HaySiguiente() )
{
Posicion vec1 = itVecinos.Siguiente();
Conj<Posicion> vecinosDeVecino = DameCampus().Vecinos(vec1);
Conj<Posicion>::const_Iterador itVecinosVec = vecinosDeVecino.CrearIt();
while( itVecinosVec.HaySiguiente() )
{
if( posConvertibleAEstudiante(vec1,_campus) && esHippie(vec1) )
{
Nombre name = grilla.Obtener(vec1).tag ;
(_estudiantes).Definir(name,vec1 );
(_hippies).Borrar( name );
}
else
{
if( posCapturable(vec1,_campus) && esHippie(vec1) )
{
Nombre name = grilla.Obtener(vec1).tag ;
(_hippies).Borrar( name );
grilla.Obtener(vec1).id = 4;
grilla.Obtener(vec1).tag = "";
grilla.Obtener(vec1).placa = 0 ;
diccHash<Agente,Datos>::Iterador itVacioHash;
grilla.Obtener(vec1).datosAgente =itVacioHash;
Conj<Posicion>::Iterador itVecVec = (_campus.Vecinos(vec1)).CrearIt() ;
while( itVecVec.HaySiguiente() )
{
Posicion posVec= itVecVec.Siguiente();
if( esAgente(posVec) )
{
diccHash<Agente,Datos>::Iterador itH = grilla.Obtener(posVec).datosAgente;
itH.SiguienteSignificado().hippiesAtrapados++;
actualizarMasVigilante(itH,posVec);
}
itVecVec.Avanzar();
}
}
else
{
if( posCapturable(vec1,_campus) && esEstudiante(vec1) )
{
Nombre name = grilla.Obtener(vec1).tag ;
Conj<Posicion> VecinosDe_vecinosDeVecino = DameCampus().Vecinos(vec1);
Conj<Posicion>::Iterador itVecVec = VecinosDe_vecinosDeVecino.CrearIt();
while( itVecVec.HaySiguiente() )
{
Posicion posVec = itVecVec.Siguiente();
if( esAgente(posVec) )
{
//diccHash<Agente,Datos>::Iterador itH = grilla.Obtener(posVec).datosAgente;
//itH.SiguienteSignificado().Sanciones++;
Agente ac = grilla.Obtener(posVec).placa;
datosAgentes.Obtener(ac).Sanciones ++;
//Nat san = itH.SiguienteSignificado().Sanciones;
//ConjsEqu<Agente>::Iterador itMSanciones = itH.SiguienteSignificado().claseConMismasSanciones;
//itMSanciones.ItActualizarElem(san);
}
itVecVec.Avanzar();
}
}
}
}
itVecinosVec.Avanzar();
}
itVecinos.Avanzar();
}
}