Fix Issue #74

Author: huangminghuang

src/mfast/coder/encoder/encoder_field_operator.cpp

@@ -208,9 +208,9 @@ class copy_or_increment_operator_impl : public mfast::detail::codec_helper {
   template <typename T>
   void encode_impl(const T &cref, fast_ostream &stream,
                    encoder_presence_map &pmap) const {
-
+    
     value_storage previous = previous_value_of(cref);
-    stream.save_previous_value(cref);
+    
 
     if (!previous.is_defined()) {
       // if the previous value is undefined – the value of the field is the
@@ -220,14 +220,16 @@ class copy_or_increment_operator_impl : public mfast::detail::codec_helper {
       // considered
       // absent and the state of the previous value is changed to empty.
       if (cref.is_initial_value()) {
-
+        stream.save_previous_value(cref);
         pmap.set_next_bit(false);
         return;
       }
     } else if (previous.is_empty()) {
+      
       // if the previous value is empty – the value of the field is empty.
       // If the field is optional the value is considered absent.
       if (cref.absent()) {
+        stream.save_previous_value(cref);
         pmap.set_next_bit(false);
         return;
       } else if (!cref.optional()) {
@@ -239,10 +241,11 @@ class copy_or_increment_operator_impl : public mfast::detail::codec_helper {
         // has optional presence.
       }
     } else if (Operation()(cref, previous)) {
+      stream.save_previous_value(cref);
       pmap.set_next_bit(false);
       return;
-    }
-
+    } 
+    stream.save_previous_value(cref);
     pmap.set_next_bit(true);
     stream << cref;
   }

src/mfast/coder/encoder_v2/fast_encoder_core.h

@@ -90,6 +90,9 @@ struct MFAST_CODER_EXPORT fast_encoder_core : mfast::detail::codec_helper {
   template <typename T, typename TypeCategory>
   void encode_field(const T &ext_ref, constant_operator_tag, TypeCategory);
 
+  template <typename T>
+  void encode_field(const T &ext_ref, copy_operator_tag, number_type_tag);
+
   template <typename T, typename TypeCategory>
   void encode_field(const T &ext_ref, copy_operator_tag, TypeCategory);
 
@@ -306,9 +309,9 @@ void fast_encoder_core::encode_field(const T &ext_ref, constant_operator_tag,
     strm_.save_previous_value(cref);
 }
 
-template <typename T, typename TypeCategory>
+template <typename T>
 void fast_encoder_core::encode_field(const T &ext_ref, copy_operator_tag,
-                                     TypeCategory) {
+                                     number_type_tag) {
   encoder_presence_map &pmap = *current_;
   typename T::cref_type cref = ext_ref.get();
 
@@ -349,6 +352,52 @@ void fast_encoder_core::encode_field(const T &ext_ref, copy_operator_tag,
   strm_ << ext_ref;
 }
 
+template <typename T, typename TypeCategory>
+void fast_encoder_core::encode_field(const T &ext_ref, copy_operator_tag,
+                                     TypeCategory) {
+  encoder_presence_map &pmap = *current_;
+  typename T::cref_type cref = ext_ref.get();
+
+  value_storage previous = previous_value_of(cref);
+  
+  if (!previous.is_defined()) {
+    // if the previous value is undefined – the value of the field is the
+    // initial value
+    // that also becomes the new previous value.
+    // If the field has optional presence and no initial value, the field is
+    // considered
+    // absent and the state of the previous value is changed to empty.
+    if (cref.is_initial_value()) {
+      strm_.save_previous_value(cref);
+      pmap.set_next_bit(false);
+      return;
+    }
+  } else if (previous.is_empty()) {
+    // if the previous value is empty – the value of the field is empty.
+    // If the field is optional the value is considered absent.
+    if (!ext_ref.present()) {
+      strm_.save_previous_value(cref);
+      pmap.set_next_bit(false);
+      return;
+    } else if (!ext_ref.optional()) {
+      // It is a dynamic error [ERR D6] if the field is mandatory.
+      BOOST_THROW_EXCEPTION(fast_dynamic_error("D6"));
+
+      // We need to handle this case because the previous value may have been
+      // modified by another instruction with the same key and that intruction
+      // has optional presence.
+    }
+  } else if (equivalent(cref, previous)) {
+    strm_.save_previous_value(cref);
+    pmap.set_next_bit(false);
+    return;
+  }
+
+  strm_.save_previous_value(cref);
+  pmap.set_next_bit(true);
+  strm_ << ext_ref;
+}
+
 template <typename T, typename TypeCategory>
 void fast_encoder_core::encode_field(const T &ext_ref, increment_operator_tag,
                                      TypeCategory) {

tests/encoder_operator_test.cpp

@@ -1034,8 +1034,44 @@ TEST_CASE("test the encoding of fast no operator for ascii string", "[operator_n
       inst.destruct_value(storage, &alloc);
       inst.destruct_value(inst.prev_value(), &alloc);
   }
-  
-  
+}
+
+TEST_CASE("test the encoding of fast operator copy for ascii string", "[operator_copy_ascii_encode_test]")
+{
+    debug_allocator alloc;
+    value_storage storage;
+
+    { // testing Option assci field with copy operator
+        ascii_field_instruction inst(operator_copy,
+            presence_optional,
+            1,
+            "test_ascii", "",
+            nullptr,
+            string_value_storage());
+
+        inst.construct_value(storage, &alloc);
+
+        ascii_string_mref result(&alloc, &storage, &inst);
+
+        result.as("0");
+        REQUIRE(encode_mref("\xc0\xb0", result, CHANGE_PREVIOUS_VALUE));
+        result.as("1");
+        REQUIRE(encode_mref("\xc0\xb1", result, CHANGE_PREVIOUS_VALUE));
+
+        inst.prev_value().defined(false);
+        result.as("0");
+        REQUIRE(encode_ext_cref("\xc0\xb0",
+            ext_cref<ascii_string_cref, copy_operator_tag, optional_without_initial_value_tag>(result),
+            CHANGE_PREVIOUS_VALUE, &alloc));
+        result.as("1");
+        REQUIRE(encode_ext_cref("\xc0\xb1",
+            ext_cref<ascii_string_cref, copy_operator_tag, optional_without_initial_value_tag>(result),
+            CHANGE_PREVIOUS_VALUE, &alloc));
+
+        inst.destruct_value(storage, &alloc);
+        inst.destruct_value(inst.prev_value(), &alloc);
+    }
+    
 }
 TEST_CASE("test the encoding of fast operator delta for ascii string","[operator_delta_ascii_encode_test]")
 {
@@ -1205,7 +1241,7 @@ TEST_CASE("test the encoding of fast operator delta for ascii string","[operator
   }
 }
 
-TEST_CASE("test the encoding of fast operator unicode string","[operator_delta_unicode_encode_test]")
+TEST_CASE("test the encoding of fast operator delta for unicode string","[operator_delta_unicode_encode_test]")
 {
   debug_allocator alloc;
   value_storage storage;