C++ Lista::CrearIt方法代码示例

	bool Red::HayInterseccionDeCaminos(const Lista<Compu>& camino1,const Lista<Compu>& camino2) const {
		bool hay = false;
		Lista<Compu>::const_Iterador it1 = camino1.CrearIt();
		Lista<Compu>::const_Iterador it2 = camino2.CrearIt();
		while( it1.HaySiguiente() && !hay ) {
			while( it2.HaySiguiente() && !hay ) {
				hay = (it1.Siguiente() == it2.Siguiente());
				it2.Avanzar();
			}
			it1.Avanzar();
		}
		return hay;
	}

void BaseDeDatos::Borrar(Registro_tp3 cr, string t) {
    assert(_nombreATabla.def(t));

    Tabla& tabla = _nombreATabla.obtener(t);

    class Lista<struct tupString<Dato> >::const_Iterador criterio = cr.vistaDicc();
    //std::cout << "Criterio: " << criterio.Siguiente().clave << " / " << criterio.Siguiente().significado << std::endl;
    //std::cout << "TABLA:" << tabla << std::endl;
    Lista<Registro_tp3> borrados = tabla.buscar(criterio.Siguiente().clave, criterio.Siguiente().significado);
    tabla.borrarRegistro(cr);
    Tabla tabMax = _nombreATabla.obtener(*_tablaMasAccedida);
    if (tabla.cantidadDeAccesos() > tabMax.cantidadDeAccesos()) {
        delete _tablaMasAccedida;
        _tablaMasAccedida = new string(t);
    }
    class Lista<struct tupString<tupBdd > >::const_Iterador iter = _hayJoin.obtener(t).vistaDicc();
    while (iter.HaySiguiente()) {
      Lista<Registro_tp3>::const_Iterador itBorrados = borrados.CrearIt();
      while (itBorrados.HaySiguiente()){
          tupInterna tup;
          tup.reg = itBorrados.Siguiente();
          tup.agregar = false;
          //MOD
          _hayJoin.obtener(t).obtener(iter.Siguiente().clave).cambiosT1.AgregarAtras(tup);
          //iter.Siguiente().significado.cambiosT1.AgregarAdelante(tup);
          itBorrados.Avanzar();
      }
      iter.Avanzar();
    }
    Conj<string>::Iterador iterTablas =_tablas.CrearIt();
    while (iterTablas.HaySiguiente()) {
      if (_hayJoin.obtener(iterTablas.Siguiente()).def(t)) {
      Lista<Registro_tp3>::const_Iterador itBorrados = borrados.CrearIt();
      while (itBorrados.HaySiguiente()) {
            tupBdd& cambios = _hayJoin.obtener(iterTablas.Siguiente()).obtener(t);
            tupInterna tup;
            tup.reg = itBorrados.Siguiente();
            tup.agregar = false;
            cambios.cambiosT2.AgregarAtras(tup);
            itBorrados.Avanzar();
        }
      }
      iterTablas.Avanzar();
    }
}

	//otras operaciones privadas
	bool Red::Esta (const Lista<Compu>& compus, const Compu& c) const {
		bool pertence = false;
		Lista<Compu>::const_Iterador it = compus.CrearIt();
		while(it.HaySiguiente() && !pertence) {
			pertence = ( it.Siguiente() == c );
			it.Avanzar();
		}
		return pertence;
	}

const Computadora Driver::IesimoNodoRecorridoPor(const Paquete& p, const Nat i) const{
    assert(i<CantidadNodosRecorridosPor(p));
    Lista<Compu> recorrido = this->dcnet->CaminoRecorrido(p);
    Lista<Compu>::Iterador it = recorrido.CrearIt();
    Nat j = i;
    while(j-- > 0) {
        it.Avanzar();
    }
    return it.Siguiente().Ip();
}

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;
}

LinkLinkIt::itPunLinks::itPunLinks(Lista<DatosLink*> &ldl, Fecha& f){
    _itLista = ldl.CrearIt();
    _fecha = f;
}