inline operator bool();
inline bool operator!();
-// added methods for autodelete implementation
- inline void setAutoDelete(bool b);
- inline bool isAutoDelete();
-
// added compare struct ... to sort
struct less;
private:
iterator cur;
- bool autoDelete;
-
public:
iterator ePtrList<T>::begin()
{
{
// Remove the item it, if auto-deletion is enabled, than the list call delete for this item
// If current is equal to the item that was removed, current is set to the next item in the list
- if (autoDelete && *it)
- delete *it;
-
if (cur == it)
return cur = std::list<T*>::erase(it);
else
// Creates an vector and copys all elements to this vector
// returns a pointer to this new vector ( the reserved memory must deletet from the receiver !! )
std::vector<T>* v=new std::vector<T>();
- v->reserve( size() );
+ v->reserve( std::list<T>::size() );
for ( std_list_T_iterator it( std::list<T*>::begin() ); it != std::list<T*>::end(); it++)
v->push_back( **it );
return v;
}
- inline iterator insert_in_order( T* e )
- {
- // added a new item to the list... in order
- // returns a iterator to the new item
- return insert( std::lower_bound( std::list<T*>::begin(), std::list<T*>::end(), e ), e );
- }
+// inline iterator insert_in_order( T* e )
+// {
+// // added a new item to the list... in order
+// // returns a iterator to the new item
+// return insert( std::lower_bound( std::list<T*>::begin(), std::list<T*>::end(), e ), e );
+// }
};
/////////////////// Default Constructor /////////////////////////////
template <class T>
ePtrList<T>::ePtrList()
- :cur(std::list<T*>::begin()), autoDelete(false)
+ :cur(std::list<T*>::begin())
{
}
/////////////////// Copy Constructor /////////////////////////////
template <class T>
ePtrList<T>::ePtrList(const ePtrList& e)
- :std::list<T*>(e), cur(e.cur), autoDelete( false )
+ :std::list<T*>(e), cur(e.cur)
{
- if ( e.autoDelete )
- if ( e.size() )
- eDebug("Warning !! We make a Copy of a non empty ePtrList, with autoDelete enabled"
- "We disable autoDelete in the new ePtrList !!");
- else
- autoDelete=true;
}
/////////////////// ePtrList Destructor /////////////////////////////
template <class T>
inline ePtrList<T>::~ePtrList()
{
-// if autoDelete is enabled, delete is called for all elements in the list
- if (autoDelete)
- for (std_list_T_iterator it(std::list<T*>::begin()); it != std::list<T*>::end(); it++)
- delete *it;
}
-
/////////////////// ePtrList sort() /////////////////////////
template <class T>
inline void ePtrList<T>::sort()
{
// Sorts all items in the list.
// The type T must have a operator <.
- std::list<T*>::sort(ePtrList<T>::less());
+ std::list<T*>::sort(typename ePtrList<T>::less());
}
/////////////////// ePtrList remove(T*) /////////////////////////
ePtrList<T>::operator bool()
{
// Returns a bool that contains true, when the list is NOT empty otherwise false
- return !empty();
+ return !std::list<T*>::empty();
}
template <class T>
bool ePtrList<T>::operator!()
{
// Returns a bool that contains true, when the list is empty otherwise false
- return empty();
-}
-
-template <class T>
-void ePtrList<T>::setAutoDelete(bool b)
-{
-// switched autoDelete on or off
-// if autoDelete is true, than the pointer list controls the heap memory behind the pointer itself
-// the list calls delete for the item before it removed from the list
- autoDelete=b;
-}
-
-template <class T>
-bool ePtrList<T>::isAutoDelete()
-{
-// returns a bool that contains the state of autoDelete
- return autoDelete;
+ return std::list<T*>::empty();
}
template <class T>
inline operator bool();
inline bool operator!();
-// added methods for autodelete implementation
- inline void setAutoDelete(bool b);
- inline bool isAutoDelete();
-
// added compare struct ... to sort
struct less;
private:
iterator cur;
- bool autoDelete;
-
public:
iterator eSmartPtrList<T>::begin()
{
{
// Remove the item it, if auto-deletion is enabled, than the list call delete for this item
// If current is equal to the item that was removed, current is set to the next item in the list
- if (autoDelete && *it)
- delete *it;
if (cur == it)
return cur = std::list<ePtr<T> >::erase(it);
// Creates an vector and copys all elements to this vector
// returns a pointer to this new vector ( the reserved memory must deletet from the receiver !! )
std::vector<T>* v=new std::vector<T>();
- v->reserve( size() );
+ v->reserve( std::list<T>::size() );
for ( std_list_T_iterator it( std::list<ePtr<T> >::begin() ); it != std::list<ePtr<T> >::end(); it++)
v->push_back( **it );
return v;
}
- inline iterator insert_in_order( T* e )
- {
- // added a new item to the list... in order
- // returns a iterator to the new item
- return insert( std::lower_bound( std::list<ePtr<T> >::begin(), std::list<ePtr<T> >::end(), e ), e );
- }
+// inline iterator insert_in_order( T* e )
+// {
+// // added a new item to the list... in order
+// // returns a iterator to the new item
+// return insert( std::lower_bound( std::list<ePtr<T> >::begin(), std::list<ePtr<T> >::end(), e ), e );
+// }
};
/////////////////// Default Constructor /////////////////////////////
template <class T>
eSmartPtrList<T>::eSmartPtrList()
- :cur(std::list<ePtr<T> >::begin()), autoDelete(false)
+ :cur(std::list<ePtr<T> >::begin())
{
}
/////////////////// Copy Constructor /////////////////////////////
template <class T>
eSmartPtrList<T>::eSmartPtrList(const eSmartPtrList& e)
- :std::list<ePtr<T> >(e), cur(e.cur), autoDelete( false )
+ :std::list<ePtr<T> >(e), cur(e.cur)
{
- if ( e.autoDelete )
- if ( e.size() )
- eDebug("Warning !! We make a Copy of a non empty eSmartPtrList, with autoDelete enabled"
- "We disable autoDelete in the new eSmartPtrList !!");
- else
- autoDelete=true;
}
/////////////////// eSmartPtrList Destructor /////////////////////////////
template <class T>
inline eSmartPtrList<T>::~eSmartPtrList()
{
-// if autoDelete is enabled, delete is called for all elements in the list
- if (autoDelete)
- for (std_list_T_iterator it(std::list<ePtr<T> >::begin()); it != std::list<ePtr<T> >::end(); it++)
- delete *it;
}
eSmartPtrList<T>::operator bool()
{
// Returns a bool that contains true, when the list is NOT empty otherwise false
- return !empty();
+ return !std::list<T>::empty();
}
template <class T>
bool eSmartPtrList<T>::operator!()
{
// Returns a bool that contains true, when the list is empty otherwise false
- return empty();
-}
-
-template <class T>
-void eSmartPtrList<T>::setAutoDelete(bool b)
-{
-// switched autoDelete on or off
-// if autoDelete is true, than the pointer list controls the heap memory behind the pointer itself
-// the list calls delete for the item before it removed from the list
- autoDelete=b;
-}
-
-template <class T>
-bool eSmartPtrList<T>::isAutoDelete()
-{
-// returns a bool that contains the state of autoDelete
- return autoDelete;
+ return std::list<T>::empty();
}
#endif // _E_PTRLIST
git.cweiske.de / enigma2.git / blobdiff