[ViewVC] Diff of: cvs/libptytty/src/estl.h

Comparing libptytty/src/estl.h (file contents):
Revision 1.14 by root, Sat May 19 02:13:59 2012 UTC vs.
Revision 1.25 by sf-exg, Mon Oct 27 15:48:04 2014 UTC

   return first;
 }
 #include <new>
-#if __cplusplus >= 201103L
+#if ECB_CPP11
   #include <type_traits>
 #endif
 // original version taken from MICO, but this has been completely rewritten
 // known limitations w.r.t. std::vector
 // - no bool specialisation
 template<class T>
 struct simplevec
 {
 #if ESTL_BIG_VECTOR
-  // shoudl use size_t/ssize_t, but that's not portable enough for us
+  // should use size_t/ssize_t, but that's not portable enough for us
   typedef unsigned long size_type;
   typedef          long difference_type;
 #else
   typedef uint32_t size_type;
   typedef  int32_t difference_type;
   // we shamelessly optimise for "simple" types. everything
   // "not simple enough" will use the slow path.
   static bool is_simple_enough ()
   {
-    return 1; // we are not there yet
+    #if ECB_CPP11
-    #if __cplusplus >= 201103L
       return std::is_trivially_assignable<T, T>::value
           && std::is_trivially_constructable<T>::value
           && std::is_trivially_copyable<T>::value
           && std::is_trivially_destructible<T>::value;
     #elif ECB_GCC_VERSION(4,4)
   static void construct (iterator a, size_type n = 1)
   {
     if (!is_simple_enough ())
       while (n--)
-        new (*a++) T ();
+        new (a++) T ();
   }
   static void destruct (iterator a, size_type n = 1)
   {
     if (!is_simple_enough ())
   template<class I>
   static void cop_set (iterator a, I b) {     *a  =  *b ; }
   // MUST copy forwards
   template<class I>
-  static void copy (iterator dst, I        src, size_type n, void (*op)(iterator,        I) = cop_new)
+  static void copy (iterator dst, I        src, size_type n, void (*op)(iterator,        I))
   {
     while (n--)
       op (dst++, src++);
   }
-  static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator) = cop_new)
+  static void copy (iterator dst, iterator src, size_type n, void (*op)(iterator, iterator))
   {
     if (is_simple_enough ())
       memcpy (dst, src, sizeof (T) * n);
     else
       copy<iterator> (dst, src, n, op);
         buf = nbuf;
       }
     construct (buf + sze, n);
-    sze += n;
     iterator src = buf + pos;
     if (is_simple_enough ())
-      memmove (src + n, src, sizeof (T) * n);
+      memmove (src + n, src, sizeof (T) * (sze - pos));
     else
-      for (size_type i = n; i--; )
+      for (size_type i = sze - pos; i--; )
-        op (src + n + i, src + i);
+        cop_set (src + n + i, src + i);
+    sze += n;
   }
 public:
   size_type capacity () const { return res; }
   size_type size     () const { return sze; }
       return;
     sz = good_size (sz);
     T *nbuf = alloc (sz);
-    copy (nbuf, begin (), sze);
+    copy (nbuf, begin (), sze, cop_new);
     dealloc ();
     buf  = nbuf;
     res = sz;
   }
     while (n--)
       new (buf + n) T (t);
   }
-  template<class I>
+  simplevec (const_iterator first, const_iterator last)
-  simplevec (I first, I last)
   {
     sze = res = last - first;
     buf = alloc (sze);
-    copy (buf, first, sze);
+    copy (buf, first, sze, cop_new);
   }
   simplevec (const simplevec<T> &v)
   : sze(0), res(0), buf(0)
   {
     sze = res = v.size ();
     buf = alloc (sze);
-    copy (buf, v.begin (), sze);
+    copy (buf, v.begin (), sze, cop_new);
   }
   ~simplevec ()
   {
     dealloc ();
         reference operator [](size_type idx)       { return buf[idx]; }
   const_reference at (size_type idx) const { return buf [idx]; }
         reference at (size_type idx)       { return buf [idx]; }
-  template<class I>
+  void assign (const_iterator first, const_iterator last)
-  void assign (I first, I last)
   {
-    swap (simplevec<T> (first, last));
+    simplevec<T> v (first, last);
+    swap (v);
   }
   void assign (size_type n, const T &t)
   {
-    swap (simplevec<T> (n, t));
+    simplevec<T> v (n, t);
+    swap (v);
   }
   simplevec<T> &operator= (const simplevec<T> &v)
   {
     assign (v.begin (), v.end ());
     buf [at] = t;
     return buf + at;
   }
-  template<class I>
-  iterator insert (iterator pos, I first, I last)
+  iterator insert (iterator pos, const_iterator first, const_iterator last)
   {
     size_type n  = last - first;
     size_type at = pos - begin ();
     ins (pos, n);
       *i++ = t;
     return buf + at;
   }
-  void erase (iterator first, iterator last)
+  iterator erase (iterator first, iterator last)
   {
-    size_t n = last - first;
+    size_type n = last - first;
+    size_type c = end () - last;
     if (is_simple_enough ())
-      memmove (first, last, sizeof (T) * n);
+      memmove (first, last, sizeof (T) * c);
     else
-      copy<iterator> (first, last, n, cop_new);
+      copy (first, last, c, cop_set);
     sze -= n;
     destruct (buf + sze, n);
-  }
+    return first;
+  }
-  void erase (iterator pos)
+  iterator erase (iterator pos)
   {
     if (pos != end ())
       erase (pos, pos + 1);
+    return pos;
   }
 };
 template<class T>
 bool operator ==(const simplevec<T> &v1, const simplevec<T> &v2)

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libptytty/src/estl.h (file contents): Revision 1.14 by root, Sat May 19 02:13:59 2012 UTC vs. Revision 1.25 by sf-exg, Mon Oct 27 15:48:04 2014 UTC

Diff Legend

Comparing libptytty/src/estl.h (file contents):
Revision 1.14 by root, Sat May 19 02:13:59 2012 UTC vs.
Revision 1.25 by sf-exg, Mon Oct 27 15:48:04 2014 UTC