J
Ich habe die (vermutlich) relevanten Codestellen rausgesucht die die Objekte im Vektor manipulieren, alle anderen stellen die auf den verdächtigen Vektor zugreifen sind const deklariert.
Der Vektor heißt layer und besteht aus Zeigern aus ptr to Town obj.
Die Town Klasse
//Die Konstruktoren
Town::Town(int id,int capa,
std::vector<int> buddies) throw(err):
ID(id),
start_capacity(capa),
left_over_capacity(capa),
partner_towns(buddies),
partner_towns_partied(),
partner_towns_partying(){
}
Town::Town(const Town* to_copy,int host,
int guest,bool forward) throw(err):
ID(to_copy->get_id()),
start_capacity(to_copy->get_start_capacity()),
partner_towns(to_copy->get_partner_towns()),
partner_towns_partied(
to_copy->get_partner_towns_partied()
),
partner_towns_partying(
to_copy->get_partner_towns_partying()
),
left_over_capacity(to_copy->get_cur_capacity()){
if(ID == host && forward) {
//logger::Infolog("Got one");
this->left_over_capacity -= 1;
//logger::Infolog("Kapacity down to " + utility::int_to_string(left_over_capacity) );
partner_towns_partied.push_back(guest);
}
if(ID == guest && forward) {
partner_towns_partying.push_back(host);
}
if(ID == host && !forward) {
this->left_over_capacity += 1;
for(std::vector<int>::iterator iter = partner_towns_partied.begin();
iter != partner_towns_partied.end();
++iter) {
if(*iter == guest) {
partner_towns_partied.erase(iter);
break;
}
}
}
if(ID == guest && !forward) {
for(std::vector<int>::iterator iter = partner_towns_partied.begin();
iter != partner_towns_partied.end();
++iter) {
if(*iter == host) {
partner_towns_partied.erase(iter);
break;
}
}
}
}
Die Wrapper-Klasse die ich um den Vektor mit den Town Objekten gemacht habe heißt Solution_Stack
//Der Konstruktor
Solution_Stack::Solution_Stack(std::vector<City*> parsed) throw(err) {
std::vector<Town*> beginners;
for(int i = 0; i != parsed.size(); ++i)
id_name.push_back( std::pair<std::string,int>(parsed[i]->get_name(),i) );
for(int i = 0; i != parsed.size(); ++i) {
std::vector<int> buddies;
for(int x = 0; x != parsed[i]->get_friends()->size(); ++x)
buddies.push_back(name_to_id(
(*parsed[i]->get_friends())[x]
)
);
beginners.push_back(new Town(i,
(int)parsed[i]->get_capacity(),
buddies
)
);
}
layer = beginners;
}
Die Methode die den Inhalt des Vektor verändern
void Solution_Stack::execute_order(int host,int guest) throw(err) {
rlimit limit;
getrlimit(RLIMIT_STACK,&limit);
std::cout << "rlim_cur ist :" << limit.rlim_cur << std::endl;
std::cout << "rlim_max ist :" << limit.rlim_max << std::endl;
static short counter = 1;
logger::Infolog("execute order " + utility::int_to_string(counter) +
" - host: " + id_to_name(host) +
"/guest: " + id_to_name(guest));
++counter;
order_layer.push(new std::pair<int,int>(host,guest) );
std::vector<Town*> next_layer;
const std::vector<Town*>* current_layer = this->get_towns();
for(int i = 0; i != current_layer->size(); ++i)
next_layer.push_back(new Town( (*current_layer)[i],host,guest,true));
for(int i = 0; i != current_layer->size();++i) {
//std::cout << i << std::endl;
delete (*current_layer)[i];
}
layer = next_layer;
check_vec();
}
void Solution_Stack::redo_last_order() throw(err) {
logger::Infolog("redoing last order");
//layers.pop_back();
const std::vector<Town*>* current_layer = this->get_towns();
std::vector<Town*> next_layer;
next_layer.resize( current_layer->size() + 1 );
//layers.push_back(next_layer);
for(int i = 0; i != current_layer->size(); ++i)
next_layer.push_back(new Town( (*current_layer)[i],
(*order_layer.top()).first,
(*order_layer.top()).second,
false)
);
for(int i = 0; i != layer.size(); ++i)
delete layer[i];
layer = next_layer;
order_layer.pop();
if(order_layer.empty()) {
throw err("problem seems unsolveable, killed last remaining layer");
}
check_vec();
}
Die Methoden die auf den vector zugreifen
const std::vector<Town*>* Solution_Stack::get_towns_by_capacity() {
std::sort(layer.begin(),layer.end(),&Town::compare_by_capacity);
check_vec();
return &layer;
}
const std::vector<Town*>* Solution_Stack::get_towns_by_index() {
std::sort(layer.begin(),layer.end(), &Town::compare_by_index);
check_vec();
return &layer;
}
std::vector<int> Solution_Stack::get_partners_of_by_index_inv(int id) {
//gehe alle Städte durch
for(int i = 0; i != layer.size(); ++i) {
//und finde die entsprechende Stadt
if(layer[i]->get_id() == id) {
std::vector<Town*> buddies;
for(int x = 0;
x != layer[i]->get_partner_towns().size();
++x){
for(int p = 0; p != layer.size(); ++p) {
if(layer[p]->get_id() ==
layer[i]->get_partner_towns()[x])
buddies.push_back(layer[p]);
}
}
//mysort(&buddies,&Town::compare_by_index_inv);
for(int p = 0; p != buddies.size(); ++p)
std::cout << buddies[p] << std::endl;
std::sort(buddies.begin(),buddies.end(),&Town::compare_by_index_inv);
std::vector<int> ret;
for(int x = 0; x != buddies.size(); ++x)
ret.push_back(buddies[x]->get_id());
check_vec();
return ret;
}
}
}
