Add back fill and unique

Author: lucic71

rules/algorithm/src.cpp

@@ -31,6 +31,15 @@ template <typename T1> T1 f8(T1 first, T1 last) {
 
 template <typename T1> void f9(T1 &a0, T1 &a1) { return std::swap(a0, a1); }
 
+template <typename T1> T1 f10(T1 first, T1 last) {
+  return std::unique(first, last);
+}
+
+template <typename T1, typename T2>
+void f12(T1 first, T1 last, const T2 &value) {
+  return std::fill(first, last, value);
+}
+
 std::ostream_iterator<char> f13(std::string::iterator a0,
                                 std::string::iterator a1,
                                 std::ostream_iterator<char> a2) {

rules/algorithm/tgt_refcount.rs

@@ -94,6 +94,34 @@ fn f9<T1: Clone + ByteRepr>(a0: Ptr<T1>, a1: Ptr<T1>) {
     a1.write(tmp);
 }
 
+fn f10<T1: CppInputIterator<T2>, T2: PartialEq + Clone + ByteRepr>(a0: T1, a1: T1) -> T1 {
+    if a0 == a1 {
+        a1
+    } else {
+        let mut __write = a0.clone();
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            let __v = __it.iter_deref().read();
+            if __write.iter_deref().with(|__w| *__w != __v) {
+                __write.iter_inc();
+                __write.iter_deref().write(__v);
+            }
+            __it.iter_inc();
+        }
+        __write.iter_inc();
+        __write
+    }
+}
+
+fn f12<T1: CppInputIterator<T3>, T2: Clone + Into<T3>, T3: ByteRepr>(a0: T1, a1: T1, a2: T2) {
+    let mut __it = a0;
+    while __it != a1 {
+        __it.iter_deref().write(a2.clone().into());
+        __it.iter_inc();
+    }
+}
+
 fn f13(a0: Ptr<i8>, a1: Ptr<i8>, a2: &mut ::std::fs::File) -> ::std::fs::File {
     a0.with_slice(a1.get_offset() - a0.get_offset(), |__s| {
         CChar::with_u8_slice(__s, |__b| a2.write_all(__b))

rules/algorithm/tgt_unsafe.rs

@@ -85,6 +85,33 @@ unsafe fn f9<T1>(a0: &mut T1, a1: &mut T1) {
     std::mem::swap(&mut *a0, &mut *a1)
 }
 
+unsafe fn f10<T1: UnsafeCppInputIterator<T2>, T2: PartialEq + Clone>(a0: T1, a1: T1) -> T1 {
+    if a0 == a1 {
+        a1
+    } else {
+        let mut __write = a0.clone();
+        let mut __it = a0;
+        __it.iter_inc();
+        while __it != a1 {
+            if *__write.iter_deref() != *__it.iter_deref() {
+                __write.iter_inc();
+                *__write.iter_deref() = (*__it.iter_deref()).clone();
+            }
+            __it.iter_inc();
+        }
+        __write.iter_inc();
+        __write
+    }
+}
+
+unsafe fn f12<T1: UnsafeCppInputIterator<T3>, T2: Clone + Into<T3>, T3>(a0: T1, a1: T1, a2: T2) {
+    let mut __it = a0;
+    while __it != a1 {
+        *__it.iter_deref() = a2.clone().into();
+        __it.iter_inc();
+    }
+}
+
 unsafe fn f13(
     a0: *const libc::c_char,
     a1: *const libc::c_char,