Esempio n. 1
0
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();
    }
}
Esempio n. 2
0
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();
}
Esempio n. 3
0
//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;
}
Esempio n. 4
0
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();
}
Esempio n. 5
0
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;
}
Esempio n. 6
0
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);
}
Esempio n. 7
0
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);
}
Esempio n. 8
0
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);
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
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);
}
Esempio n. 11
0
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;
}
Esempio n. 12
0
File: red.cpp Progetto: julifgo/tp3
	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;
	}
Esempio n. 13
0
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;
}
Esempio n. 14
0
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;
}
Esempio n. 15
0
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();
    }
}
Esempio n. 16
0
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());
}
Esempio n. 17
0
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;
}
Esempio n. 18
0
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;
}
Esempio n. 19
0
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);
}
Esempio n. 20
0
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);
}
Esempio n. 21
0
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();
 }
}