add stringlist wrapper.

src/stringlist.cc

@@ -0,0 +1,78 @@
+#include "types.hh"
+
+#include <pEp/status_to_string.hh> // from libpEpAdapter
+#include <pEp/stringlist.h>
+
+#include <string>
+
+namespace pEp
+{
+    template<>
+    void Wrapper<::stringlist_t*>::_free(::stringlist_t* sl)
+    {
+        ::free_stringlist(sl);
+    }
+    
+    template<>
+    char* stringlist_t::* const ListWrapper<stringlist_t*, char*>::Value = &stringlist_t::value;
+
+    template<>
+    int StringList::size() const
+    {
+        return stringlist_length(value);
+    }
+
+    // faster than .size()==0 because it's not necessary to iterate throgh the whole list
+    template<>
+    bool StringList::empty() const
+    {
+        return !(value && value->value);
+    }
+    
+    template<>
+    void StringList::erase( const StringList::iterator& it)
+    {
+        if(it.value && it.value->value)
+        {
+            value = stringlist_delete(value, it.value->value);
+        }
+    }
+    
+    template<>
+    void StringList::clear()
+    {
+        free_stringlist(value);
+        value = nullptr;
+    }
+    
+    template<>
+    void StringList::push_back(const char*&& s)
+    {
+        auto last = stringlist_add(value, s);
+        if(value==nullptr)
+            value = last;
+    }
+    
+    
+    template<>
+    ListWrapper<::stringlist_t*, const char*>::ListWrapper(const std::initializer_list<const char*>& il)
+    : StringList{}
+    {
+        ::stringlist_t* last  = nullptr;
+        for(const char* s : il)
+        {
+            last = stringlist_add(last, s);
+            if(last==nullptr)
+            {
+                throw std::runtime_error("Cannot create StringPairList from {}: Out Of Memory.");
+            }
+            if(value==nullptr)
+                value = last; // save the head of linked list.
+        }
+    }
+
+////////////////
+
+    template class ListWrapper<::stringlist_t*, const char*>;
+
+} // end of namespace pEp

src/types.cc

@@ -152,10 +152,11 @@ namespace pEp
 
 ////////////////
 
-    template class Wrapper<::pEp_identity>;
-    template class Wrapper<::stringpair_t>;
-    
-    template class Wrapper<::message>;
+    template class Wrapper<::pEp_identity*>;
+    template class Wrapper<::stringpair_t*>;
+
+    template class Wrapper<::message*>;
+
     template class ListWrapper<::stringpair_list_t*, ::stringpair_t*>;
 
 } // end of namespace pEp

src/types.hh

@@ -23,6 +23,9 @@ namespace pEp
     using StringPair = Wrapper<::stringpair_t*>;
     using StringPairList = ListWrapper<::stringpair_list_t*, ::stringpair_t*>;
     
+    using StringList = ListWrapper<::stringlist_t*, const char*>;
+    using BlobList   = ListWrapper<::bloblist_t*, ::bloblist_t*>;
+    
     using Message = Wrapper<::message*>;
 
 } // end of namespace pEp

src/wrapper.hh

@@ -65,11 +65,12 @@ public:
         victim.value = nullptr;
     }
     
-    Wrapper<T*>&& operator=(Wrapper<T*>&& victim)
+    Wrapper<T*>& operator=(Wrapper<T*>&& victim)
     {
         _free(value);
         value = victim.value;
         victim.value = nullptr;
+        return *this;
     }
     
     ~Wrapper()
@@ -142,7 +143,9 @@ public:
     using Base::value;
     
     ListWrapper() : Base() {}
-    ListWrapper(const std::initializer_list<pEp::Wrapper<Element> >& i);
+    
+    ListWrapper(const std::initializer_list<pEp::Wrapper<Element>>& i);
+    ListWrapper(const std::initializer_list<Element>& i);
     
     iterator begin()     { return iterator{value}; }
     iterator end() const { return iterator{}; }