Merge branch 'fix/placement-new' into 'develop'

Fix/placement new

See merge request njoy/NDItk!2

src/NDItk/depletion/ReactionMultiplicities/src/ctor.hpp

@@ -85,7 +85,12 @@ ReactionMultiplicities( ReactionMultiplicities&& base ) :
  */
 ReactionMultiplicities& operator=( const ReactionMultiplicities& base ) {
 
-  new (this) ReactionMultiplicities( base );
+  if ( this != &base ) {
+
+    base::IntegerListRecord::operator=( base );
+    this->reactions_ = base.reactions_;
+    this->generateBlocks();
+  }
   return *this;
 }
 
@@ -94,6 +99,11 @@ ReactionMultiplicities& operator=( const ReactionMultiplicities& base ) {
  */
 ReactionMultiplicities& operator=( ReactionMultiplicities&& base ) {
 
-  new (this) ReactionMultiplicities( std::move( base ) );
+  if ( this != &base ) {
+
+    base::IntegerListRecord::operator=( std::move( base ) );
+    this->reactions_ = base.reactions_;
+    this->generateBlocks();
+  }
   return *this;
 }

src/NDItk/depletion/ReactionMultiplicities/test/ReactionMultiplicities.test.cpp

@@ -19,6 +19,7 @@ void verifyChunk( const ReactionMultiplicities& );
 std::string chunkWithMultiplicityType();
 void verifyChunkWithMultiplicityType( const ReactionMultiplicities& );
 std::string chunkWithInsufficientNumberReactions();
+ReactionMultiplicities makeDummyRecord();
 
 SCENARIO( "ReactionMultiplicities" ) {
 
@@ -75,6 +76,108 @@ SCENARIO( "ReactionMultiplicities" ) {
         CHECK( buffer == record );
       } // THEN
     } // WHEN
+
+    WHEN( "using the copy constructor" ) {
+
+      auto iter = record.begin() + 5;
+      auto end = record.end();
+      ReactionMultiplicities chunk;
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities copy( chunk );
+
+      THEN( "a ReactionMultiplicities can be constructed and members can "
+            "be tested" ) {
+
+        verifyChunk( copy );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        copy.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using the move constructor" ) {
+
+      auto iter = record.begin() + 5;
+      auto end = record.end();
+      ReactionMultiplicities chunk;
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities move( std::move( chunk ) );
+
+      THEN( "a ReactionMultiplicities can be constructed and members can "
+            "be tested" ) {
+
+        verifyChunk( move );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        move.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using copy assignment" ) {
+
+      auto iter = record.begin() + 5;
+      auto end = record.end();
+      ReactionMultiplicities chunk;
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities copy = makeDummyRecord();
+      copy = chunk;
+
+      THEN( "an ReactionMultiplicities can be copy assigned and "
+            "members can be tested" ) {
+
+        verifyChunk( copy );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        copy.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using move assignment" ) {
+
+      auto iter = record.begin() + 5;
+      auto end = record.end();
+      ReactionMultiplicities chunk;
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities move = makeDummyRecord();
+      move = std::move( chunk );
+
+      THEN( "an ReactionMultiplicities can be copy assigned and "
+            "members can be tested" ) {
+
+        verifyChunk( move );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        move.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
   } // GIVEN
 
   GIVEN( "valid data for a ReactionMultiplicities instance with a multiplicity type" ) {
@@ -131,6 +234,108 @@ SCENARIO( "ReactionMultiplicities" ) {
         CHECK( buffer == record );
       } // THEN
     } // WHEN
+
+    WHEN( "using the copy constructor" ) {
+
+      auto iter = record.begin() + 9;
+      auto end = record.end();
+      ReactionMultiplicities chunk( ReactionMultiplicityType::All );
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities copy( chunk );
+
+      THEN( "a ReactionMultiplicities can be constructed and members can "
+            "be tested" ) {
+
+        verifyChunkWithMultiplicityType( copy );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        copy.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using the move constructor" ) {
+
+      auto iter = record.begin() + 9;
+      auto end = record.end();
+      ReactionMultiplicities chunk( ReactionMultiplicityType::All );
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities move( std::move( chunk ) );
+
+      THEN( "a ReactionMultiplicities can be constructed and members can "
+            "be tested" ) {
+
+        verifyChunkWithMultiplicityType( move );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        move.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using copy assignment" ) {
+
+      auto iter = record.begin() + 9;
+      auto end = record.end();
+      ReactionMultiplicities chunk( ReactionMultiplicityType::All );
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities copy = makeDummyRecord();
+      copy = chunk;
+
+      THEN( "an ReactionMultiplicities can be copy assigned and "
+            "members can be tested" ) {
+
+        verifyChunkWithMultiplicityType( copy );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        copy.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
+
+    WHEN( "using move assignment" ) {
+
+      auto iter = record.begin() + 9;
+      auto end = record.end();
+      ReactionMultiplicities chunk( ReactionMultiplicityType::All );
+      chunk.read( iter, end, 2 );
+
+      ReactionMultiplicities move = makeDummyRecord();
+      move = std::move( chunk );
+
+      THEN( "an ReactionMultiplicities can be copy assigned and "
+            "members can be tested" ) {
+
+        verifyChunkWithMultiplicityType( move );
+      } // THEN
+
+      THEN( "the record can be printed" ) {
+
+        std::string buffer;
+        auto output = std::back_inserter( buffer );
+        move.print( output );
+
+        CHECK( buffer == record );
+      } // THEN
+    } // WHEN
   } // GIVEN
 
   GIVEN( "invalid data for a ReactionMultiplicities instance" ) {
@@ -302,3 +507,8 @@ std::string chunkWithInsufficientNumberReactions() {
 
   return "rprod\n";
 }
+
+ReactionMultiplicities makeDummyRecord() {
+
+  return ReactionMultiplicities( { { 102, { 1 }, { 1 } } } );
+}

src/NDItk/multigroup/ReactionCrossSections/src/ctor.hpp

@@ -50,7 +50,13 @@ ReactionCrossSections( ReactionCrossSections&& base ) :
  */
 ReactionCrossSections& operator=( const ReactionCrossSections& base ) {
 
-  new (this) ReactionCrossSections( base );
+  if ( this != &base ) {
+
+    base::RealListRecord::operator=( base );
+    this->groups_ = base.groups_;
+    this->reactions_ = base.reactions_;
+    this->generateBlocks();
+  }
   return *this;
 }
 
@@ -59,6 +65,12 @@ ReactionCrossSections& operator=( const ReactionCrossSections& base ) {
  */
 ReactionCrossSections& operator=( ReactionCrossSections&& base ) {
 
-  new (this) ReactionCrossSections( std::move( base ) );
+  if ( this != &base ) {
+
+    base::RealListRecord::operator=( std::move( base ) );
+    this->groups_ = base.groups_;
+    this->reactions_ = base.reactions_;
+    this->generateBlocks();
+  }
   return *this;
 }