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

	Lista<Compu>& Red::Concatenar(const Lista<Compu>& camino1, const Lista<Compu>& camino2) const {
		Lista<Compu>* res = new Lista<Compu>;
		Lista<Compu>::const_Iterador it1 = camino1.CrearIt();
		Lista<Compu>::const_Iterador it2 = camino2.CrearIt();
		while( it1.HaySiguiente() ) {
			res->AgregarAtras(it1.Siguiente());
			it1.Avanzar();
		}
		while( it2.HaySiguiente() ) {
			res->AgregarAtras(it2.Siguiente());
			it2.Avanzar();
		}
		return *res;
	}

LinkLinkIt::itPunLinks LinkLinkIt::linksOrdenadosPorAccesos(Categoria categoria) {
        int id = _acat->idAC(categoria);
        Fecha n = 1;
        itPunLinks itParaFecha = itPunLinks(_arrayCatLinks[id-1], n);
        Fecha fecha = itParaFecha.ultFecha();
        itPunLinks itOrdSegunF = itPunLinks(_arrayCatLinks[id-1], fecha);
        Lista<DatosLink*> listaOrdenada = Lista<DatosLink*>();
        itPunLinks itMax;

        if (!(itOrdSegunF.estaOrdenada(fecha)))
        {
            while(_arrayCatLinks[id-1].Longitud() != 0)
            {
                itMax = itPunLinks(_arrayCatLinks[id-1], fecha);
                itMax = itMax.BuscarMax(fecha);
                listaOrdenada.AgregarAtras(itMax.Siguiente());
                itMax.EliminarSiguiente();
            }
            _arrayCatLinks.Definir(id-1, listaOrdenada);

        }

       return itPunLinks(_arrayCatLinks[id-1], fecha);

}

void datosLinkConDatos(){
    ArbolCategorias::DatosCat* dc = new ArbolCategorias::DatosCat();
    String l = "link";
    Lista<LinkLinkIt::Acceso> la = Lista<LinkLinkIt::Acceso>();
    LinkLinkIt::DatosLink* dl = new LinkLinkIt::DatosLink(l, dc, la, 0);
    ASSERT_EQ(dl->dameCatDLink() == * dc, true);
    ASSERT_EQ(dl->dameAccesos() == la, true);
    ASSERT_EQ(dl->dameCantAccesos(), 0);
    ASSERT_EQ(dl->dameLink(),l);
    LinkLinkIt::DatosLink* dl2 = new LinkLinkIt::DatosLink(l, dc, la, 0);
    LinkLinkIt::DatosLink* dl3 = new LinkLinkIt::DatosLink(l, dc, la, 3);
    Lista<LinkLinkIt::Acceso> lb = Lista<LinkLinkIt::Acceso>();
    LinkLinkIt::Acceso* ac = new LinkLinkIt::Acceso(3,4);
    lb.AgregarAtras(*ac);
    LinkLinkIt::DatosLink* dl4 = new LinkLinkIt::DatosLink(l, dc, lb, 0);
    ASSERT_EQ(*dl == *dl2,true);
    ASSERT_EQ(*dl == *dl3,false);
    ASSERT_EQ(*dl == *dl4,false);
    Categoria cat = "cat2";
    Conj<ArbolCategorias::DatosCat*> conj1 = Conj<ArbolCategorias::DatosCat*>();
    ArbolCategorias::DatosCat* dc2 = new ArbolCategorias::DatosCat(cat, 2, 3, conj1 , NULL);
    LinkLinkIt::DatosLink* dl5 = new LinkLinkIt::DatosLink(l, dc2, lb, 0);
    ASSERT_EQ(*dl == *dl5, false);
    delete dc;
    delete dc2;
    delete dl;
    delete dl2;
    delete dl3;
    delete dl4;
    delete dl5;
    delete ac;
}

	void Red::ActualizarCaminos(const Compu& pc1, const Compu& pc2) {
		Conj<Lista<Compu> >& caminos = this->caminos;
		Conj<Lista<Compu> >& caminosQueEmpiezanConpc1 = CaminosQueEmpiezanConPcx(caminos, pc1);
		Conj<Lista<Compu> >& caminosQueEmpiezanConpc2 = CaminosQueEmpiezanConPcx(caminos, pc2);

		if(caminosQueEmpiezanConpc1.EsVacio()) {
			Lista<Compu> aux;
			aux.AgregarAtras(pc1);
			caminos.AgregarRapido( aux );
			caminosQueEmpiezanConpc1.AgregarRapido( aux );
		}

		if(caminosQueEmpiezanConpc2.EsVacio()) {
			Lista<Compu> aux;
			aux.AgregarAtras(pc2);
			caminos.AgregarRapido( aux );
			caminosQueEmpiezanConpc2.AgregarRapido( aux );
		}

		Conj<Lista<Compu> >& caminosQueTerminanConpc1 = CaminosQueTerminanConPcx(caminos, pc1);
		Conj<Lista<Compu> >::Iterador itCaminosQueEmpiezanConpc2 = caminosQueEmpiezanConpc2.CrearIt();
		Conj<Lista<Compu> >::Iterador itCaminosQueTerminanConpc1 = caminosQueTerminanConpc1.CrearIt();

		while(itCaminosQueTerminanConpc1.HaySiguiente()) {
			while(itCaminosQueEmpiezanConpc2.HaySiguiente()) {
				if(!HayInterseccionDeCaminos(itCaminosQueTerminanConpc1.Siguiente(), itCaminosQueEmpiezanConpc2.Siguiente())) {
					Lista<Compu>& nuevoCamino = Concatenar( itCaminosQueTerminanConpc1.Siguiente(), itCaminosQueEmpiezanConpc2.Siguiente() );
					Lista<Compu> copiaNuevoCamino(nuevoCamino);
					Lista<Compu>& nuevoCaminoInvertido = Reverso( copiaNuevoCamino );
					caminos.AgregarRapido(nuevoCamino);
					caminos.AgregarRapido(nuevoCaminoInvertido);
					delete &nuevoCaminoInvertido;
					delete &nuevoCamino;
				}
				itCaminosQueEmpiezanConpc2.Avanzar();
			}
			itCaminosQueEmpiezanConpc2 = caminosQueEmpiezanConpc2.CrearIt();
			itCaminosQueTerminanConpc1.Avanzar();
		}

		delete &caminosQueEmpiezanConpc1;
		delete &caminosQueEmpiezanConpc2;
		delete &caminosQueTerminanConpc1;
	}

void DCNet::CrearPaquete( ::Paquete p){
    CompuDCNet *compudcnet = diccCompusDCNet.obtener(p.origen.ip);

    Conj< ::Paquete>::Iterador itPaq = compudcnet->conjPaquetes.AgregarRapido(p);

    Lista<Compu> recorr;
    recorr.AgregarAtras(p.origen);

    PaqueteDCNet paqDCNet;
    paqDCNet.it = itPaq;
    paqDCNet.recorrido = recorr;

    Lista<PaqueteDCNet>::Iterador itPaqDCNet = listaPaquetesDCNet.AgregarAtras(paqDCNet);

    compudcnet->diccPaquetesDCNet.Definir(p.id, itPaqDCNet); // aca rompe


    compudcnet->colaPaquetesDCNet.Encolar(p.prioridad, itPaqDCNet);
}

const Paquete Driver::IesimoEnEsperaEn(const Computadora& c, const Nat i){
       ConjLog<dcnet::Paquete*>* paquetesEnEspera = dcnet->EnEspera(c);
       assert(i < paquetesEnEspera->Cardinal());
     //  ConjLog<dcnet::Paquete*>* paquetes = new ConjLog<dcnet::Paquete*>(*paquetesEnEspera); //TODO. Asegurarse que esto este haciendo una copia.
       Nat j = 0;
       Lista<dcnet::Paquete*> listaPaq;
       while(j<i){
            dcnet::Paquete* paq = paquetesEnEspera->Minimo();
            cout<<paq->Id()<<endl;
            listaPaq.AgregarAtras(paq);
            paquetesEnEspera->Borrar(paq);
            j++;
       }
       dcnet::Paquete paqReturn = *paquetesEnEspera->Minimo();
       for (Nat i = 0; i < listaPaq.Longitud(); i++){
        cout<<listaPaq.operator [](i)->Id()<<endl;
    	   paquetesEnEspera->Definir(listaPaq.operator [](i));
       }
       return paqReturn.Id();
}

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