added facility to persist model transformations

Signed-off-by: Nikolaj Bjorner <nbjorner@microsoft.com>

src/util/vector.h

@@ -26,6 +26,7 @@ Revision History:
 
 #include "util/debug.h"
 #include<algorithm>
+#include<type_traits>
 #include<memory.h>
 #include "util/memory_manager.h"
 #include "util/hash.h"
@@ -75,9 +76,27 @@ class vector {
                 UNREACHABLE();
                 throw default_exception("Overflow encountered when expanding vector");
             }
-            SZ *mem = (SZ*)memory::reallocate(reinterpret_cast<SZ*>(m_data)-2, new_capacity_T);
-            *mem    = new_capacity;
-            m_data  = reinterpret_cast<T *>(mem + 2);
+            SZ *mem, *old_mem = reinterpret_cast<SZ*>(m_data) - 2;
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 5
+            if (__has_trivial_copy(T)) {
+#else
+            if (std::is_trivially_copyable<T>::value) {
+#endif
+                mem = (SZ*)memory::reallocate(old_mem, new_capacity_T);
+                m_data = reinterpret_cast<T *>(mem + 2);
+            } else {
+                mem = (SZ*)memory::allocate(new_capacity_T);
+                auto old_data = m_data;
+                auto old_size = size();
+                mem[1] = old_size;
+                m_data  = reinterpret_cast<T *>(mem + 2);
+                for (unsigned i = 0; i < old_size; ++i) {
+                    new (&m_data[i]) T(std::move(old_data[i]));
+                    old_data[i].~T();
+                }
+                memory::deallocate(old_mem);
+            }
+            *mem = new_capacity;
         }
     }
 
@@ -149,6 +168,10 @@ public:
         SASSERT(size() == source.size());
     }
 
+    vector(vector&& other) : m_data(0) {
+        std::swap(m_data, other.m_data);
+    }
+
     vector(SZ s, T const * data):
         m_data(0) {
         for (SZ i = 0; i < s; i++) {
@@ -180,6 +203,16 @@ public:
         return *this;
     }
 
+    vector & operator=(vector && source) {
+        if (this == &source) {
+            return *this;
+        }
+        destroy();
+        m_data = 0;
+        std::swap(m_data, source.m_data);
+        return *this;
+    }
+
     void reset() { 
         if (m_data) {
             if (CallDestructors) {
@@ -293,6 +326,11 @@ public:
         m_data[idx] = val;
     }
 
+    void set(SZ idx, T && val) {
+        SASSERT(idx < size());
+        m_data[idx] = std::move(val);
+    }
+
     T & back() { 
         SASSERT(!empty()); 
         return operator[](size() - 1); 
@@ -319,6 +357,14 @@ public:
         reinterpret_cast<SZ *>(m_data)[SIZE_IDX]++;
     }
 
+    void push_back(T && elem) {
+        if (m_data == 0 || reinterpret_cast<SZ *>(m_data)[SIZE_IDX] == reinterpret_cast<SZ *>(m_data)[CAPACITY_IDX]) {
+            expand_vector();
+        }
+        new (m_data + reinterpret_cast<SZ *>(m_data)[SIZE_IDX]) T(std::move(elem));
+        reinterpret_cast<SZ *>(m_data)[SIZE_IDX]++;
+    }
+
     void insert(T const & elem) {
         push_back(elem);
     }
@@ -358,7 +404,8 @@ public:
         }
     }
 
-    void resize(SZ s, T const & elem=T()) {
+    template<typename Args>
+    void resize(SZ s, Args args...) {
         SZ sz = size();
         if (s <= sz) { shrink(s); return; }
         while (s > capacity()) {
@@ -368,8 +415,23 @@ public:
         reinterpret_cast<SZ *>(m_data)[SIZE_IDX] = s;
         iterator it  = m_data + sz;
         iterator end = m_data + s;
-        for(; it != end; ++it) {
-            new (it) T(elem);
+        for (; it != end; ++it) {
+            new (it) T(std::forward<Args>(args));
+        }
+    }
+
+    void resize(SZ s) {
+        SZ sz = size();
+        if (s <= sz) { shrink(s); return; }
+        while (s > capacity()) {
+            expand_vector();
+        }
+        SASSERT(m_data != 0);
+        reinterpret_cast<SZ *>(m_data)[SIZE_IDX] = s;
+        iterator it  = m_data + sz;
+        iterator end = m_data + s;
+        for (; it != end; ++it) {
+            new (it) T();
         }
     }
 
@@ -440,10 +502,15 @@ public:
         return m_data[idx];
     }
 
-    void reserve(SZ s, T const & d = T()) {
+    void reserve(SZ s, T const & d) {
         if (s > size())
             resize(s, d);
     }
+
+    void reserve(SZ s) {
+        if (s > size())
+            resize(s);
+    }
 };
 
 template<typename T>
@@ -453,7 +520,12 @@ public:
     ptr_vector(unsigned s):vector<T *, false>(s) {}
     ptr_vector(unsigned s, T * elem):vector<T *, false>(s, elem) {}
     ptr_vector(ptr_vector const & source):vector<T *, false>(source) {}
+    ptr_vector(ptr_vector && other) : vector<T*, false>(std::move(other)) {}
     ptr_vector(unsigned s, T * const * data):vector<T *, false>(s, const_cast<T**>(data)) {}
+    ptr_vector & operator=(ptr_vector const & source) {
+        vector<T *, false>::operator=(source);
+        return *this;
+    }
 };
 
 template<typename T, typename SZ = unsigned>
@@ -463,7 +535,12 @@ public:
     svector(SZ s):vector<T, false, SZ>(s) {}
     svector(SZ s, T const & elem):vector<T, false, SZ>(s, elem) {}
     svector(svector const & source):vector<T, false, SZ>(source) {}
+    svector(svector && other) : vector<T, false, SZ>(std::move(other)) {}
     svector(SZ s, T const * data):vector<T, false, SZ>(s, data) {}
+    svector & operator=(svector const & source) {
+        vector<T, false, SZ>::operator=(source);
+        return *this;
+    }
 };
 
 typedef svector<int> int_vector;
@@ -500,23 +577,4 @@ struct vector_hash : public vector_hash_tpl<Hash, vector<typename Hash::data> >
 template<typename Hash>
 struct svector_hash : public vector_hash_tpl<Hash, svector<typename Hash::data> > {};
 
-#include <vector>
-// Specialize vector<std::string> to be an instance of std::vector instead.
-// This will catch any regression of issue #564 and #420.
-
-template <>
-class vector<std::string, true, unsigned> : public std::vector<std::string> {
-public:
-    vector(vector<std::string, true, unsigned> const& other): std::vector<std::string>(other) {}
-    vector(size_t sz, char const* s): std::vector<std::string>(sz, s) {}
-    vector() {}
-
-    void reset() { clear(); }
-   
-    
-};
-
-
-
 #endif /* VECTOR_H_ */
-