Greater compliance with C++ spec.

deque.h

@@ -83,7 +83,7 @@ namespace etl
     deque()
       : ideque<T>(reinterpret_cast<T*>(&buffer[0]), MAX_SIZE, BUFFER_SIZE)
     {
-      initialise();
+      ideque<T>::initialise();
     }
 
     //*************************************************************************
@@ -92,7 +92,6 @@ namespace etl
     deque(const deque& other)
       : ideque<T>(reinterpret_cast<T*>(&buffer[0]), MAX_SIZE, BUFFER_SIZE)
     {
-      initialise();
       ideque<T>::assign(other.begin(), other.end());
     }
 
@@ -103,7 +102,6 @@ namespace etl
     deque(TIterator begin, TIterator end)
       : ideque<T>(reinterpret_cast<T*>(&buffer[0]), MAX_SIZE, BUFFER_SIZE)
     {
-      initialise();
       ideque<T>::assign(begin, end);
     }
 
@@ -113,7 +111,6 @@ namespace etl
     explicit deque(size_t n, typename ideque<T>::parameter_t value = value_type())
       : ideque<T>(reinterpret_cast<T*>(&buffer[0]), MAX_SIZE, BUFFER_SIZE)
     {
-      initialise();
       ideque<T>::assign(n, value);
     }
 

forward_list.h

@@ -71,7 +71,7 @@ namespace etl
     forward_list()
       : iforward_list<T>(node_pool, MAX_SIZE)
     {
-      initialise();
+      iforward_list<T>::initialise();
     }
 
     //*************************************************************************
@@ -80,7 +80,6 @@ namespace etl
     explicit forward_list(size_t initialSize, typename iforward_list<T>::parameter_t value = T())
       : iforward_list<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       iforward_list<T>::assign(initialSize, value);
     }
 
@@ -90,7 +89,6 @@ namespace etl
     forward_list(const forward_list& other)
       : iforward_list<T>(node_pool, MAX_SIZE)
     {
-      initialise();
 			iforward_list<T>::assign(other.cbegin(), other.cend());
     }
 
@@ -101,7 +99,6 @@ namespace etl
     forward_list(TIterator first, TIterator last)
       : iforward_list<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       iforward_list<T>::assign(first, last);
     }
 

list.h

@@ -71,7 +71,7 @@ namespace etl
     list()
       : ilist<T>(node_pool, MAX_SIZE)
     {
-      initialise();
+      ilist<T>::initialise();
     }
 
     //*************************************************************************
@@ -80,7 +80,6 @@ namespace etl
     explicit list(size_t initialSize)
       : ilist<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       ilist<T>::assign(initialSize, T());
     }
 
@@ -90,7 +89,6 @@ namespace etl
     list(size_t initialSize, typename ilist<T>::parameter_t value)
       : ilist<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       ilist<T>::assign(initialSize, value);
     }
 
@@ -100,7 +98,6 @@ namespace etl
     list(const list& other)
       : ilist<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       ilist<T>::assign(other.cbegin(), other.cend());
     }
 
@@ -111,7 +108,6 @@ namespace etl
     list(TIterator first, TIterator last)
       : ilist<T>(node_pool, MAX_SIZE)
     {
-      initialise();
       ilist<T>::assign(first, last);
     }
 

map.h

@@ -63,7 +63,7 @@ namespace etl
     map()
       : imap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
+      imap<TKey, TValue, TCompare>::initialise();
     }
 
     //*************************************************************************
@@ -72,7 +72,6 @@ namespace etl
     map(const map& other)
       : imap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
 			imap<TKey, TValue, TCompare>::assign(other.cbegin(), other.cend());
     }
 
@@ -86,8 +85,7 @@ namespace etl
     map(TIterator first, TIterator last)
       : imap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
-      imap<TKey, TValue, TCompare>::insert(first, last);
+      imap<TKey, TValue, TCompare>::assign(first, last);
     }
 
     //*************************************************************************

multimap.h

@@ -62,7 +62,7 @@ namespace etl
     multimap()
       : imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
+      imultimap<TKey, TValue, TCompare>::initialise();
     }
 
     //*************************************************************************
@@ -71,7 +71,6 @@ namespace etl
     explicit multimap(const multimap& other)
       : imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
 			imultimap<TKey, TValue, TCompare>::assign(other.cbegin(), other.cend());
     }
 
@@ -85,8 +84,7 @@ namespace etl
     multimap(TIterator first, TIterator last)
       : imultimap<TKey, TValue, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
-      imultimap<TKey, TValue, TCompare>::insert(first, last);
+      imultimap<TKey, TValue, TCompare>::assign(first, last);
     }
 
     //*************************************************************************

multiset.h

@@ -62,7 +62,7 @@ namespace etl
     multiset()
       : imultiset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
+      imultiset<T, TCompare>::initialise();
     }
 
     //*************************************************************************
@@ -71,7 +71,6 @@ namespace etl
     explicit multiset(const multiset& other)
       : imultiset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
 			imultiset<T, TCompare>::assign(other.cbegin(), other.cend());
     }
 
@@ -85,8 +84,7 @@ namespace etl
     multiset(TIterator first, TIterator last)
       : imultiset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
-      imultiset<T, TCompare>::insert(first, last);
+      imultiset<T, TCompare>::assign(first, last);
     }
 
     //*************************************************************************

set.h

@@ -63,7 +63,7 @@ namespace etl
     set()
       : iset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
+      iset<T, TCompare>::initialise();
     }
 
     //*************************************************************************
@@ -72,7 +72,6 @@ namespace etl
     explicit set(const set& other)
       : iset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
 			iset<T, TCompare>::assign(other.cbegin(), other.cend());
     }
 
@@ -86,8 +85,7 @@ namespace etl
     set(TIterator first, TIterator last)
       : iset<T, TCompare>(node_pool, MAX_SIZE)
     {
-      initialise();
-      iset<T, TCompare>::insert(first, last);
+      iset<T, TCompare>::assign(first, last);
     }
 
     //*************************************************************************

vector.h

@@ -67,7 +67,7 @@ namespace etl
     vector()
       : ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
     {
-      initialise();
+      ivector<T>::initialise();
     }
 
     //*************************************************************************
@@ -77,7 +77,7 @@ namespace etl
     explicit vector(size_t initialSize)
       : ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
     {
-      initialise();
+      ivector<T>::initialise();
       ivector<T>::resize(initialSize);
     }
 
@@ -89,7 +89,7 @@ namespace etl
     vector(size_t initialSize, typename ivector<T>::parameter_t value)
       : ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
     {
-      initialise();
+      ivector<T>::initialise();
       ivector<T>::resize(initialSize, value);
     }
 
@@ -103,7 +103,6 @@ namespace etl
     vector(TIterator first, TIterator last)
       : ivector<T>(reinterpret_cast<T*>(&buffer), MAX_SIZE)
     {
-      initialise();
       ivector<T>::assign(first, last);
     }