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;
}
Lista<Compu>& Red::Reverso(const Lista<Compu>& camino) const {
Lista<Compu>* arr = new Lista<Compu>();
Lista<Compu>::const_Iterador it = camino.CrearItUlt();
while( it.HayAnterior() ) {
arr->AgregarAtras(it.Anterior());
it.Retroceder();
}
return *arr;
}
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;
}
