Mentions légales du service

Skip to content
Snippets Groups Projects
Commit 46219429 authored by ROUZAUD-CORNABAS Jonathan's avatar ROUZAUD-CORNABAS Jonathan
Browse files

Fix memory leak in observer code

parent 61bcdb28
Branches
Tags
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/libaevol/Dna.cpp
+ 38
− 28
View file @ 46219429
......@@ -267,7 +267,7 @@ void Dna::do_small_mutations(void) {
int32_t random_value;
Mutation * mut = NULL;
Mutation* mut = nullptr;
for (int32_t i = nb_mut ; i >= 1 ; i--) {
random_value = _indiv->_mut_prng->random(i);
......@@ -289,8 +289,10 @@ void Dna::do_small_mutations(void) {
}
// Record mutation in tree
if (mut != NULL)
if (mut != NULL) {
_indiv->notifyObservers(MUTATION, mut);
delete mut;
}
}
}
......@@ -329,7 +331,7 @@ void Dna::do_rearrangements(void) {
// Given this position, we know what kind of rearrangement we have drawn.
int32_t random_value;
Mutation * mut = NULL;
Mutation* mut = nullptr;
for (int32_t i = nb_rear ; i >= 1 ; i--) {
random_value = _indiv->_mut_prng->random(i);
......@@ -352,8 +354,10 @@ void Dna::do_rearrangements(void) {
}
// Record rearrangement in tree
if (mut != NULL)
if (mut != NULL) {
_indiv->notifyObservers(MUTATION, mut);
delete mut;
}
}
}
......@@ -368,7 +372,7 @@ void Dna::do_rearrangements_with_align(void)
int32_t nb_pairs; // Number of pairs of sequences we will try to align
int32_t genome_size = _length; // Keep trace of the original length of the genome
Mutation * mut = NULL;
Mutation* mut = nullptr;
VisAVis * alignment = NULL;
//////////////////////////////////////////////////////////////////////////////////////////////////
......@@ -711,8 +715,10 @@ void Dna::do_rearrangements_with_align(void)
//////////////////////////////////////////////////////////////////////////////////////////
// 6) If there was a rearrangement, we either save its record in the tree or delete it. //
//////////////////////////////////////////////////////////////////////////////////////////
if (mut != NULL)
if (mut != NULL) {
_indiv->notifyObservers(MUTATION, mut);
delete mut;
}
}
}
......@@ -721,19 +727,23 @@ void Dna::do_transfer(int32_t parent_id) {
if (_indiv->get_mut_prng()->random() < _indiv->get_HT_ins_rate()) {
mut = do_ins_HT(parent_id);
if (mut != nullptr)
if (mut != nullptr) {
_indiv->notifyObservers(MUTATION, mut);
delete mut;
}
}
if (_indiv->get_mut_prng()->random() < _indiv->get_HT_repl_rate()) {
mut = do_repl_HT(parent_id);
if (mut != nullptr)
if (mut != nullptr) {
_indiv->notifyObservers(MUTATION, mut);
delete mut;
}
}
}
Mutation *Dna::do_switch(void) {
Mutation * mut = NULL;
Mutation* Dna::do_switch(void) {
Mutation* mut = nullptr;
int32_t pos = _indiv->_mut_prng->random(_length);
......@@ -745,9 +755,9 @@ Mutation *Dna::do_switch(void) {
return mut;
}
Mutation *Dna::do_small_insertion(void)
Mutation* Dna::do_small_insertion(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
// Determine the position and size of the small insertion
int32_t pos = _indiv->_mut_prng->random(_length);
......@@ -803,9 +813,9 @@ Mutation *Dna::do_small_insertion(void)
return mut;
}
Mutation *Dna::do_small_deletion(void)
Mutation* Dna::do_small_deletion(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
// Determine the position and size of the small deletion
int32_t pos = _indiv->_mut_prng->random(_length);
......@@ -935,9 +945,9 @@ bool Dna::do_small_deletion(int32_t pos, int16_t nb_del)
return true;
}
Mutation *Dna::do_duplication(void)
Mutation* Dna::do_duplication(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
int32_t pos_1, pos_2, pos_3;
pos_1 = _indiv->_mut_prng->random(_length);
......@@ -984,9 +994,9 @@ Mutation *Dna::do_duplication(void)
return mut;
}
Mutation *Dna::do_deletion(void)
Mutation* Dna::do_deletion(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
int32_t pos_1, pos_2;
pos_1 = _indiv->_mut_prng->random(_length);
......@@ -1034,10 +1044,10 @@ Mutation *Dna::do_deletion(void)
return mut;
}
Mutation *Dna::do_translocation(void)
Mutation* Dna::do_translocation(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
int32_t pos_1, pos_2, pos_3, pos_4;
int32_t segment_length;
......@@ -1241,9 +1251,9 @@ Mutation *Dna::do_translocation(void)
return mut;
}
Mutation *Dna::do_inversion(void)
Mutation* Dna::do_inversion(void)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
int32_t pos_1, pos_2;
int32_t segment_length;
......@@ -1273,9 +1283,9 @@ Mutation *Dna::do_inversion(void)
return mut;
}
Mutation *Dna::do_insertion(const char* seq_to_insert, int32_t seq_length /*= -1*/)
Mutation* Dna::do_insertion(const char* seq_to_insert, int32_t seq_length /*= -1*/)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
Utils::ExitWithDevMsg("Not implemented yet", __FILE__, __LINE__);
......@@ -1760,9 +1770,9 @@ bool Dna::do_insertion(int32_t pos, const char* seq_to_insert, int32_t seq_lengt
}
Mutation *Dna::do_ins_HT(int32_t parent_id)
Mutation* Dna::do_ins_HT(int32_t parent_id)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
// TODO <david.parsons@inria.fr> disabled
// int32_t nb_indivs = _exp_m->get_pop()->get_nb_indivs();
......@@ -1885,9 +1895,9 @@ Mutation *Dna::do_ins_HT(int32_t parent_id)
return mut;
}
Mutation *Dna::do_repl_HT(int32_t parent_id)
Mutation* Dna::do_repl_HT(int32_t parent_id)
{
Mutation * mut = NULL;
Mutation* mut = nullptr;
// TODO <david.parsons@inria.fr> disabled
// int32_t nb_indivs = _exp_m->get_pop()->get_nb_indivs();
......
src/libaevol/DnaReplicationReport.cpp
+ 111
− 29
View file @ 46219429
......@@ -24,17 +24,27 @@
#include <cassert>
#include "DnaReplicationReport.h"
#include "InsertionHT.h"
#include "ReplacementHT.h"
#include "Mutation.h"
#include "Duplication.h"
#include "Translocation.h"
#include "Inversion.h"
#include "Deletion.h"
#include "SmallDeletion.h"
#include "PointMutation.h"
#include "SmallInsertion.h"
namespace aevol {
DnaReplicationReport::DnaReplicationReport(const DnaReplicationReport& other) {
for (auto& ht : other.ht_)
add_HT(*ht->Clone());
add_HT(ht->Clone());
for (auto& rear : other.rearrangements_)
add_rear(*rear->Clone());
add_rear(rear->Clone());
for (auto& mut : other.mutations_)
add_local_mut(*mut->Clone());
add_local_mut(mut->Clone());
}
int32_t DnaReplicationReport::get_nb(MutationType t) const {
......@@ -52,7 +62,7 @@ int32_t DnaReplicationReport::get_nb(MutationType t) const {
_nb_mut[TRANS] +
_nb_mut[INV]));
return rearrangements_.size();
case HT:
case H_T:
assert(ht_.size() ==
static_cast<size_t>(_nb_mut[INS_HT] +
_nb_mut[REPL_HT]));
......@@ -64,33 +74,72 @@ int32_t DnaReplicationReport::get_nb(MutationType t) const {
};
}
void DnaReplicationReport::add_mut(const Mutation& mut) {
if (mut.is_local_mut()) {
void DnaReplicationReport::add_mut(Mutation* mut) {
if (mut->is_local_mut()) {
add_local_mut(mut);
}
else if (mut.is_rear()) {
else if (mut->is_rear()) {
add_rear(mut);
}
else if (mut.is_ht()) {
else if (mut->is_ht()) {
add_HT(mut);
}
}
void DnaReplicationReport::add_local_mut(const Mutation& mut) {
assert(mut.is_local_mut());
mutations_.emplace_back(&mut);
_nb_mut[mut.get_mut_type()]++;
void DnaReplicationReport::add_local_mut(Mutation* mut) {
assert(mut->is_local_mut());
std::unique_ptr<const LocalMutation> cmut = nullptr;
switch(mut->get_mut_type()) {
case SWITCH:
cmut = std::make_unique<const PointMutation>(static_cast<PointMutation&>(*mut));
break;
case S_DEL:
cmut = std::make_unique<const SmallDeletion>(static_cast<SmallDeletion&>(*mut));
break;
case S_INS:
cmut = std::make_unique<const SmallInsertion>(static_cast<SmallInsertion&>(*mut));
break;
}
mutations_.push_back(std::move(cmut));
_nb_mut[mut->get_mut_type()]++;
}
void DnaReplicationReport::add_rear(const Mutation& mut) {
assert(mut.is_rear());
rearrangements_.emplace_back(&mut);
_nb_mut[mut.get_mut_type()]++;
void DnaReplicationReport::add_rear(Mutation* mut) {
assert(mut->is_rear());
std::unique_ptr<const Rearrangement> cmut = nullptr;
switch(mut->get_mut_type()) {
case DUPL:
cmut = std::make_unique<const Duplication>(static_cast<Duplication&>(*mut));
break;
case DEL:
cmut = std::make_unique<const Deletion>(static_cast<Deletion&>(*mut));
break;
case TRANS:
cmut = std::make_unique<const Translocation>(static_cast<Translocation&>(*mut));
break;
case INV:
cmut = std::make_unique<const Inversion>(static_cast<Inversion&>(*mut));
break;
}
rearrangements_.push_back(std::move(cmut));
_nb_mut[mut->get_mut_type()]++;
}
void DnaReplicationReport::add_HT(const Mutation& mut) {
assert(mut.is_ht());
ht_.emplace_back(&mut);
_nb_mut[mut.get_mut_type()]++;
void DnaReplicationReport::add_HT(Mutation* mut) {
assert(mut->is_ht());
std::unique_ptr<const HT> cmut = nullptr;
switch(mut->get_mut_type()) {
case INS_HT:
cmut = std::make_unique<const InsertionHT>(static_cast<InsertionHT&>(*mut));
break;
case REPL_HT:
cmut = std::make_unique<const ReplacementHT>(static_cast<ReplacementHT&>(*mut));
break;
}
ht_.push_back(std::move(cmut));
_nb_mut[mut->get_mut_type()]++;
}
......@@ -133,22 +182,55 @@ void DnaReplicationReport::compute_stats( void )
void DnaReplicationReport::write_to_tree_file(gzFile tree_file) const {
// Write the mutations and rearrangements undergone during replication
// Store HT
int32_t nb_HT = get_nb(HT);
int32_t nb_HT = get_nb(H_T);
gzwrite(tree_file, &nb_HT, sizeof(nb_HT));
for (const auto& ht : ht_)
ht->save(tree_file);
for (const auto& ht : ht_) {
switch(ht->get_mut_type()) {
case INS_HT:
ht->save(tree_file);
break;
case REPL_HT:
ht->save(tree_file);
break;
}
}
// Store rearrangements
int32_t nb_rears = get_nb(REARR);
gzwrite(tree_file, &nb_rears, sizeof(nb_rears));
for (const auto& rear : rearrangements_)
rear->save(tree_file);
for (const auto& rear : rearrangements_) {
switch(rear->get_mut_type()) {
case DUPL:
rear->save(tree_file);
break;
case DEL:
rear->save(tree_file);
break;
case TRANS:
rear->save(tree_file);
break;
case INV:
rear->save(tree_file);
break;
}
}
// Store mutations
int32_t nb_muts = get_nb(S_MUT);
gzwrite(tree_file, &nb_muts, sizeof(nb_muts));
for (const auto& mut : mutations_)
mut->save(tree_file);
switch(mut->get_mut_type()) {
case SWITCH:
mut->save(tree_file);
break;
case S_DEL:
mut->save(tree_file);
break;
case S_INS:
mut->save(tree_file);
break;
}
}
void DnaReplicationReport::read_from_tree_file(gzFile tree_file) {
......@@ -156,14 +238,14 @@ void DnaReplicationReport::read_from_tree_file(gzFile tree_file) {
gzread(tree_file, &nb_HT, sizeof(nb_HT));
for (int i = 0 ; i < nb_HT ; i++)
add_HT(*Mutation::Load(tree_file));
add_HT(Mutation::Load(tree_file));
gzread(tree_file, &nb_rears, sizeof(nb_rears));
for (int i = 0 ; i < nb_rears ; i++)
add_rear(*Mutation::Load(tree_file));
add_rear(Mutation::Load(tree_file));
gzread(tree_file, &nb_muts, sizeof(nb_muts));
for(int i = 0 ; i < nb_muts ; i++)
add_mut(*Mutation::Load(tree_file));
add_mut(Mutation::Load(tree_file));
}
} // namespace aevol
src/libaevol/DnaReplicationReport.h
+ 13
− 10
View file @ 46219429
......@@ -25,6 +25,9 @@
#include <memory>
#include "Mutation.h"
#include "LocalMutation.h"
#include "HT.h"
#include "Rearrangement.h"
namespace aevol {
......@@ -56,32 +59,32 @@ class DnaReplicationReport {
DnaReplicationReport& operator=(DnaReplicationReport&& other) = delete;
// Accessors
const std::list<std::unique_ptr<const Mutation>>& get_mutations() const {
const std::list<std::unique_ptr<const LocalMutation>>& get_mutations() const {
return mutations_;
};
const std::list<std::unique_ptr<const Mutation>>& get_rearrangements() const {
const std::list<std::unique_ptr<const Rearrangement>>& get_rearrangements() const {
return rearrangements_;
};
const std::list<std::unique_ptr<const Mutation>>& get_HT() const {
const std::list<std::unique_ptr<const HT>>& get_HT() const {
return ht_;
};
int32_t get_nb(MutationType t) const;
// Public Methods
void compute_stats(); // useful when we inspect a tree file
void add_mut(const Mutation& mut);
void add_local_mut(const Mutation& mut);
void add_rear(const Mutation& mut);
void add_HT(const Mutation& mut);
void add_mut(Mutation* mut);
void add_local_mut(Mutation* mut);
void add_rear(Mutation* mut);
void add_HT(Mutation* mut);
void write_to_tree_file(gzFile tree_file) const;
void read_from_tree_file(gzFile tree_file);
protected :
/// Lists of mutations, rearrangements and undergone
std::list<std::unique_ptr<const Mutation>> mutations_;
std::list<std::unique_ptr<const Mutation>> rearrangements_;
std::list<std::unique_ptr<const Mutation>> ht_;
std::list<std::unique_ptr<const LocalMutation>> mutations_;
std::list<std::unique_ptr<const Rearrangement>> rearrangements_;
std::list<std::unique_ptr<const HT>> ht_;
// Number of mutations/rearrangements/HT of each (simple) type undergone
int32_t _nb_mut[10] = {0,0,0,0,0,0,0,0,0,0};
};
......
src/libaevol/Mutation.h
+ 1
− 1
View file @ 46219429
......@@ -75,7 +75,7 @@ enum MutationType {
// C++ enums can't be inherited directly.
S_MUT, // SWITCH or S_INS or S_DEL
REARR, // DUPL or DEL or TRANS or INV
HT, // INS_HT or REPL_HT
H_T, // INS_HT or REPL_HT
INDEL // S_INS or S_DEL
};
......
src/libaevol/ReplicationReport.cpp
+ 1
− 1
View file @ 46219429
......@@ -261,7 +261,7 @@ void ReplicationReport::update(Observable& o, ObservableEvent e, void* arg) {
signal_end_of_replication(dynamic_cast<Individual*>(&o));
break;
case MUTATION :
_dna_replic_report.add_mut(*reinterpret_cast<Mutation*>(arg));
_dna_replic_report.add_mut(reinterpret_cast<Mutation*>(arg));
break;
default :
Utils::ExitWithDevMsg("Event not handled", __FILE__, __LINE__);
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment