Commits

Kaya Kupferschmidt committed df993ec

Removed some .inl files and unneeded #includes

Comments (0)

Files changed (44)

source/libs/magnum_application/source/magnum/application/Message.cpp

 /* 
   Magnum 
-  Copyright (C) 2002-2006 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/system/Mutex.h"
 
 #include "magnum/application/Message.inl"
-#include "magnum/container/PoolAllocator.inl"
 #include "magnum/system/Mutex.inl"
 
 

source/libs/magnum_core/magnum_core.files

 source/magnum/container/Item.h
 source/magnum/container/Item.inl
 source/magnum/container/Iterator.h
-source/magnum/container/Iterator.inl
 source/magnum/container/List.h
 source/magnum/container/List.inl
 source/magnum/container/ListEnumerator.h
 source/magnum/container/Multiset.inl
 source/magnum/container/Pair.h
 source/magnum/container/Pool.h
-source/magnum/container/Pool.inl
 source/magnum/container/PoolAllocator.h
-source/magnum/container/PoolAllocator.inl
 source/magnum/container/PriorityHeap.h
 source/magnum/container/PriorityHeap.inl
 source/magnum/container/Queue.h
 source/magnum/container/Scheduler.inl
 source/magnum/container/Sequence.cpp
 source/magnum/container/Sequence.h
-source/magnum/container/Sequence.inl
 source/magnum/container/Set.h
 source/magnum/container/Set.inl
 source/magnum/container/SetEnumerator.h

source/libs/magnum_core/source/magnum/container.h

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/container/Compound.h"
 #include "magnum/container/Item.h"
 
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/Pool.inl"
 #include "magnum/container/Tuple.inl"
 #include "magnum/container/Compound.inl"
 #include "magnum/container/Item.inl"

source/libs/magnum_core/source/magnum/container/BinaryTree.h

 #ifndef __MAGNUM_CONTAINER_BINARYTREE_H
 #define __MAGNUM_CONTAINER_BINARYTREE_H
 
-#include "magnum/object/Object.h"
 #include "magnum/container/Iterator.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
-using magnum::types::String;
 
 template<class Key, class Item> class BinaryTreeEnumerator;
 

source/libs/magnum_core/source/magnum/container/BinaryTree.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_CONTAINER_BINARYTREE_INL
 #define __MAGNUM_CONTAINER_BINARYTREE_INL
 
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
 
 namespace magnum { namespace container {
 

source/libs/magnum_core/source/magnum/container/Chain.h

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_CONTAINER_CHAIN_H
 #define __MAGNUM_CONTAINER_CHAIN_H
 
-#include "magnum/object/Object.h"
 #include "magnum/object/Array.h"
 #include "magnum/object/Aspect.h"
 #include "magnum/object/Reference.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
 using magnum::object::Aspect;
 using magnum::object::Array;
 using magnum::object::Reference;

source/libs/magnum_core/source/magnum/container/Chain.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 #include "magnum/object/Exception.h"
 
-#include "magnum/object/Object.inl"
 #include "magnum/object/Array.inl"
-#include "magnum/container/Iterator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/ForwardChain.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/object/Exception.h"
 
 #include "magnum/object/Array.inl"
-#include "magnum/container/Iterator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/HashMap.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #define __MAGNUM_CONTAINER_HASHMAP_INL
 
 #include "magnum/object/Array.inl"
-#include "magnum/container/PoolAllocator.inl"
-#include "magnum/container/Iterator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/HashSet.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_CONTAINER_HASHSET_INL
 #define __MAGNUM_CONTAINER_HASHSET_INL
 
-#include "magnum/container/PoolAllocator.inl"
-#include "magnum/container/Iterator.inl"
-
 
 namespace magnum { namespace container {
  

source/libs/magnum_core/source/magnum/container/Heap.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #define __MAGNUM_CONTAINER_HEAP_INL
 
 #include "magnum/object/Array.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/Iterator.h

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
  */
 template<class T> class IteratorBase {
 public:
-	inline bool operator!=(const T& iter) const;
-	inline bool operator>=(const T& iter) const;
-	inline bool operator<=(const T& iter) const;
-	inline bool operator<(const T& iter) const;
+    inline bool operator!=(const T& iter) const
+    {
+        return !((*(T *)this) == iter);
+    }
+    inline bool operator>=(const T& iter) const
+    {
+        return (((*(T *)this) > iter) || ((*(T *)this) == iter));
+    }
+    inline bool operator<=(const T& iter) const
+    {
+        return !((*(T *)this) > iter);
+    }
+    inline bool operator<(const T& iter) const
+    {
+        return ((!((*(T *)this) == iter)) && !((*(T *)this) > iter));
+    }
 
-	inline T& operator+=(int n);
-	inline T& operator-=(int n);
-	inline T operator+(int n) const;
-	inline T operator-(int n) const;
+    T& operator+=(int n)
+    {
+        if (n>0) {
+            for(;n>0;n--)
+                (*(T *)this)++;
+        }
+        else if (n<0) {
+            for(;n<0;n++)
+                (*(T *)this)--;
+        }
+
+        return *(T *)this;
+    }
+    T& operator-=(int n)
+    {
+        if (n>0) {
+            for(;n>0;n--)
+                (*(T *)this)--;
+        }
+        else if (n<0) {
+            for(;n<0;n++)
+                (*(T *)this)++;
+        }
+
+        return *(T *)this;
+    }
+
+    T operator+(int n) const
+    {
+        T iter = *this;
+        if (n>0) {
+            for(;n>0;n--)
+                iter++;
+        }
+        else if (n<0) {
+            for(;n<0;n++)
+                iter--;
+        }
+
+        return iter;
+    }
+
+    T operator-(int n) const
+    {
+        T iter = *this;
+        if (n>0) {
+            for(;n>0;n--)
+                iter--;
+        }
+        else if (n<0) {
+            for(;n<0;n++)
+                iter++;
+        }
+
+        return iter;
+    }
 };
 
-}; };
+} }
 #endif

source/libs/magnum_core/source/magnum/container/Iterator.inl

-/* 
-  Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, under the terms in LICENSE.TXT.
-
-  Kaya Kupferschmidt  (k.kupferschmidt@dimajix.de)
-*/
-
-#ifndef __MAGNUM_CONTAINER_ITERATORBASE_INL
-#define __MAGNUM_CONTAINER_ITERATORBASE_INL
-
-
-namespace magnum { namespace container {
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline bool IteratorBase<T>::operator!=(const T& iter) const {
-	return !((*(T *)this) == iter);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline bool IteratorBase<T>::operator>=(const T& iter) const {
-	return (((*(T *)this) > iter) || ((*(T *)this) == iter));
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline bool IteratorBase<T>::operator<=(const T& iter) const {
-	return !((*(T *)this) > iter);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline bool IteratorBase<T>::operator<(const T& iter) const {
-	return ((!((*(T *)this) == iter)) && !((*(T *)this) > iter));
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline T& IteratorBase<T>::operator+=(int n) {
-	if (n>0) {
-		for(;n>0;n--)
-			(*(T *)this)++;
-	} else if (n<0) {
-		for(;n<0;n++)
-			(*(T *)this)--;
-	}
-
-	return *(T *)this;
-}
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline T& IteratorBase<T>::operator-=(int n) {
-	if (n>0) {
-		for(;n>0;n--)
-			(*(T *)this)--;
-	} else if (n<0) {
-		for(;n<0;n++)
-			(*(T *)this)++;
-	}
-
-	return *(T *)this;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline T IteratorBase<T>::operator+(int n) const {
-	T iter = *this;
-	if (n>0) {
-		for(;n>0;n--)
-			iter++;
-	} else if (n<0) {
-		for(;n<0;n++)
-			iter--;
-	}
-
-	return iter;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-inline T IteratorBase<T>::operator-(int n) const {
-	T iter = *this;
-	if (n>0) {
-		for(;n>0;n--)
-			iter--;
-	} else if (n<0) {
-		for(;n<0;n++)
-			iter++;
-	}
-
-	return iter;
-}
-
-}; };
-#endif

source/libs/magnum_core/source/magnum/container/List.h

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 #include "magnum/object/traits/CallTraits.h"
 #include "magnum/object/Array.h"
-#include "magnum/object/Object.h"
 #include "magnum/container/Iterator.h"
 #include "magnum/container/PoolAllocator.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
 using magnum::object::Array;
 using magnum::types::String;
 using magnum::types::traits::CallTraits;
 
 /*----------------------------------------------------------------------------
 ----------------------------------------------------------------------------*/
-template<class T,class A = ListAllocator<T> > class List : public Object {
+template<class T,class A = ListAllocator<T> > class List {
 public:
     typedef A Allocator;
 	typedef ListIterator<T,A>	Iterator;

source/libs/magnum_core/source/magnum/container/List.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #define __MAGNUM_CONTAINER_LIST_INL
 
 #include "magnum/object/Array.inl"
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
+
 
 namespace magnum { namespace container {
 

source/libs/magnum_core/source/magnum/container/Map.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_CONTAINER_MAP_INL
 #define __MAGNUM_CONTAINER_MAP_INL
 
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
 
 namespace magnum { namespace container {
 

source/libs/magnum_core/source/magnum/container/Pool.inl

-/* 
-  Magnum 
-  Copyright (C) 2002-2004 Kaya Kupferschmidt. All Rights Reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, under the terms in LICENSE.TXT.
-
-  Kaya Kupferschmidt  (k.kupferschmidt@dimajix.de)
-*/
-

source/libs/magnum_core/source/magnum/container/PoolAllocator.h

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 
 namespace magnum { namespace container {
+using magnum::types::byte;
 
 
 /*--------------------------------------------------------------------------*/
 template<class T, int I=(1023 + sizeof(T)) / sizeof(T) > 
 class PoolAllocator : public Allocator<T> {
 public:
-	PoolAllocator();
-	~PoolAllocator();
+    PoolAllocator()
+    {
+        m_Size = I;
+        m_Increment = I;
+        m_Size = 0;
+        m_Last = NULL;
+        m_First = NULL;
+        m_Free = NULL;
+    }
 
-	inline T*	    allocate();
-	inline T*	    allocate(size_t );
-	inline void		deallocate(T* );
-	inline void		deallocate(T* ,size_t );
+    ~PoolAllocator()
+    {
+       Pool* pool = m_First;
+       while(pool != NULL) {
+           Pool* next = pool->m_Next;
+           magnum::object::sys::core_allocator::deallocate(pool);
+           pool = next;
+       }
+       m_Size = 0;
+       m_Last = NULL;
+       m_First = NULL;
+       m_Free = NULL;
+   }
+
+
+    inline T* allocate()
+    {
+        if (m_Free == NULL)
+            allocateBlock();
+        T* ret = (T*)m_Free;
+        m_Free = *(void **)m_Free;
+        return ret;
+    }
+    inline T* allocate(size_t cnt)
+    {
+        if (cnt == 1)
+            return allocate();
+        else return Allocator<T>::allocate(cnt);
+    }
+    inline void deallocate(T* data)
+    {
+        *(void **)data = (void *)m_Free;
+        m_Free = (void **)data;
+    }
+    inline void deallocate(T* ,size_t );
 
     template<class U> struct rebind { typedef PoolAllocator<U> result; };
 
 private:
-	void			allocateBlock();
-	void			deallocateBlock();
+    void allocateBlock()
+    {
+        Pool* pool = (Pool*)magnum::object::sys::core_allocator::allocate(sizeof(Pool) + (m_Increment-1)*Tsize);
+        pool->m_Size = m_Increment;
+        pool->m_Next = NULL;
+        if (m_Last != NULL) {
+            m_Last->m_Next = pool;
+            m_Last = pool;
+        }
+        else {
+            m_First = pool;
+            m_Last = m_First;
+        }
+
+        void* data = &pool->m_Data[0];
+        void* next;
+        for (unsigned int i = 0; i < m_Increment-1; i++) {
+            next = (void*)((byte *)data + Tsize);
+            *(void **)data = next;
+            data = next;
+        }
+
+        *(void **)data = m_Free;
+        m_Free = &m_Last->m_Data[0];
+
+        m_Size += m_Increment;
+    }
+    void deallocateBlock()
+    {
+    }
 
 private:
 	enum {
 ----------------------------------------------------------------------------*/
 template<class T> class PoolAllocator<T,1> : public Allocator<T>  {
 public:
-	inline PoolAllocator();
-	inline ~PoolAllocator();
+    inline PoolAllocator()
+    {
+    }
+    inline ~PoolAllocator()
+    {
+    }
 
-	inline T*	    allocate();
-	inline T*	    allocate(size_t );
-	inline void		deallocate(T* );
-	inline void		deallocate(T* ,size_t );
+    inline T* allocate()
+    {
+        return (T*)magnum::object::sys::core_allocator::allocate(sizeof(T));
+    }
+    inline T* allocate(size_t cnt)
+    {
+        return (T*)magnum::object::sys::core_allocator::allocate(sizeof(T)*cnt);
+    }
+    inline void deallocate(T* t)
+    {
+        magnum::object::sys::core_allocator::deallocate(t);
+    }
+    inline void deallocate(T* t,size_t )
+    {
+       magnum::object::sys::core_allocator::deallocate(t);
+    }
 
     template<class U> struct rebind { typedef PoolAllocator<U> result; };
     

source/libs/magnum_core/source/magnum/container/PoolAllocator.inl

-/* 
-  Magnum 
-  Copyright (C) 2002-2006 Kaya Kupferschmidt. All Rights Reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, under the terms in LICENSE.TXT.
-
-  Kaya Kupferschmidt  (k.kupferschmidt@dimajix.de)
-*/
-
-#ifndef __MAGNUM_CONTAINER_POOLALLOCATOR_INL
-#define __MAGNUM_CONTAINER_POOLALLOCATOR_INL
-
-
-namespace magnum { namespace container {
-using magnum::types::byte;
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-PoolAllocator<T,I>::PoolAllocator() {
-	m_Size = I;
-	m_Increment = I;
-	m_Size = 0;
-	m_Last = NULL;
-	m_First = NULL;
-	m_Free = NULL;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I>
-PoolAllocator<T,I>::~PoolAllocator() {
-	Pool* pool = m_First;
-	while(pool != NULL) {
-		Pool* next = pool->m_Next;
-		magnum::object::sys::core_allocator::deallocate(pool);
-		pool = next;
-	}
-	m_Size = 0;
-	m_Last = NULL;
-	m_First = NULL;
-	m_Free = NULL;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-inline T* PoolAllocator<T,I>::allocate() {
-	if (m_Free == NULL)
-		allocateBlock();
-	T* ret = (T*)m_Free;
-	m_Free = *(void **)m_Free;
-	return ret;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-inline T* PoolAllocator<T,I>::allocate(size_t cnt) {
-    if (cnt == 1)
-        return allocate();
-    else return Allocator<T>::allocate(cnt);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-inline void PoolAllocator<T,I>::deallocate(T* data) {
-	*(void **)data = (void *)m_Free;
-	m_Free = (void **)data;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-void PoolAllocator<T,I>::allocateBlock() {
-	Pool* pool = (Pool*)magnum::object::sys::core_allocator::allocate(sizeof(Pool) + (m_Increment-1)*Tsize);
-	pool->m_Size = m_Increment;
-	pool->m_Next = NULL;
-	if (m_Last != NULL) {
-		m_Last->m_Next = pool;
-		m_Last = pool;
-	} 
-	else {
-		m_First = pool;
-		m_Last = m_First;
-	}
-
-	void* data = &pool->m_Data[0];
-	void* next;
-	for (unsigned int i = 0; i < m_Increment-1; i++) {
-		next = (void*)((byte *)data + Tsize);
-		*(void **)data = next;
-		data = next;
-	}
-
-	*(void **)data = m_Free;
-	m_Free = &m_Last->m_Data[0];
-
-	m_Size += m_Increment;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, int I> 
-void PoolAllocator<T,I>::deallocateBlock() {
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline PoolAllocator<T,1>::PoolAllocator() {
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline PoolAllocator<T,1>::~PoolAllocator() {
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline T* PoolAllocator<T,1>::allocate() {
-	return (T*)magnum::object::sys::core_allocator::allocate(sizeof(T));
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline T* PoolAllocator<T,1>::allocate(size_t cnt) {
-	return (T*)magnum::object::sys::core_allocator::allocate(sizeof(T)*cnt);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline void PoolAllocator<T,1>::deallocate(T* t) {
-    magnum::object::sys::core_allocator::deallocate(t);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T> 
-inline void PoolAllocator<T,1>::deallocate(T* t,size_t ) {
-    magnum::object::sys::core_allocator::deallocate(t);
-}
-
-
-}; };
-
-#endif

source/libs/magnum_core/source/magnum/container/Queue.h

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_CONTAINER_QUEUE_H
 #define __MAGNUM_CONTAINER_QUEUE_H
 
-#include "magnum/object/Object.h"
 #include "magnum/object/Aspect.h"
 #include "magnum/container/Iterator.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
 using magnum::object::Aspect;
 using magnum::types::String;
 
 
 #pragma warning(pop)
 
-}; };
+} }
 
 
 #endif

source/libs/magnum_core/source/magnum/container/Queue.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 #include "magnum/object/Exception.h"
 
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-
 
 namespace magnum { namespace container {
 using magnum::object::NullPointerException;

source/libs/magnum_core/source/magnum/container/Scheduler.h

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
  */
 template<class T> 
 class Scheduler : public Object, private magnum::object::Noncopyable {
-DeclareClass(Scheduler, Object);
+TOBJECT_METAINFO(Scheduler);
 friend class Task<T>;
 public:
 	typedef TaskIterator<T>	Iterator;

source/libs/magnum_core/source/magnum/container/Scheduler.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 #include "magnum/object/Object.inl"
 #include "magnum/object/WeakPointer.inl"
-#include "magnum/container/Iterator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/Sequence.cpp

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Memisoglu. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
   including commercial applications, and to alter it and redistribute it
   freely, under the terms in LICENSE.TXT.
 
-  Kaya Memisoglu  (k.memisoglu@dimajix.de)
+  Kaya Kupferschmidt  (k.kupferschmidt@dimajix.de)
 */
 
 #include "magnum/container/Sequence.h"
 
-#include "magnum/container/Sequence.inl"
-
 
 namespace magnum { namespace container {
 
 	}
 }
 
-}; };
+} }

source/libs/magnum_core/source/magnum/container/Sequence.h

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Memisoglu. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
   including commercial applications, and to alter it and redistribute it
   freely, under the terms in LICENSE.TXT.
 
-  Kaya Memisoglu  (k.memisoglu@dimajix.de)
+  Kaya Kupferschmidt  (k.kupferschmidt@dimajix.de)
 */
 
 #ifndef __MAGNUM_CONTAINER_SEQUENCE_H
 #include "magnum/object/Object.h"
 #include "magnum/object/Array.h"
 
+#include "magnum/object/Object.inl"
+#include "magnum/object/Array.inl"
+
 
 namespace magnum { namespace container {
 using magnum::object::Object;
 /*----------------------------------------------------------------------------
 ----------------------------------------------------------------------------*/
 class Sequence : public Object {
-DeclareClass(Sequence, Object);
+OBJECT_METAINFO(Sequence);
 public:
 	template<class T>
-	void	insert(T* ,void (T::*)(void)); 
+    void insert(T* obj,void (T::*)(void))
+    {
+        m_Sequence.insert((intptr_t)(void*)obj);
+        m_Sequence.insert((intptr_t)(void*)&Executor0<T>::execute);
+    }
 	template<class T,class P1>
-	void	insert(T* ,void (T::*)(P1),const P1& ); 
+    void insert(T* obj,void (T::*)(P1),const P1& p1)
+    {
+        m_Sequence.insert((intptr_t)(void*)obj);
+        m_Sequence.insert((intptr_t)(void*)&Executor1<T,P1>::execute);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
+    }
 	template<class T,class P1,class P2>
-	void	insert(T* ,void (T::*)(P1,P2),const P1& ,const P2& ); 
+    void insert(T* obj,void (T::*)(P1,P2),const P1& p1,const P2& p2)
+    {
+        m_Sequence.insert((intptr_t)(void*)obj);
+        m_Sequence.insert((intptr_t)(void*)&Executor2<T,P1,P2>::execute);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p2);
+    }
 	template<class T,class P1,class P2,class P3>
-	void	insert(T* ,void (T::*)(P1,P2,P3),const P1& ,const P2& ,const P3& ); 
+    void insert(T* obj,void (T::*)(P1,P2,P3),const P1& p1,const P2& p2,const P3& p3)
+    {
+        m_Sequence.insert((intptr_t)(void*)obj);
+        m_Sequence.insert((intptr_t)(void*)&Executor3<T,P1,P2,P3>::execute);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p2);
+        m_Sequence.insert((intptr_t)(void*)*(void**)&p3);
+    }
 	
-	inline void		clear();
-	inline bool		isEmpty() const;
+    inline void clear()
+    {
+        m_Sequence.clear();
+    }
+
+    inline bool isEmpty() const
+    {
+        return m_Sequence.isEmpty();
+    }
 	
-	void			execute();
+    void execute();
 
 private:
 	Array<intptr_t>	m_Sequence;
 
 	template<class T> class Executor0 {
 	public:
-		static const intptr_t*	execute(const intptr_t* );
+        static const intptr_t*	execute(const intptr_t* stream)
+        {
+            T* obj = (T*)(void*)*stream++;
+            void (T::*method)() = *(void (T::**)())(void**)&*stream++;
+            (obj->*method)();
+            return stream;
+        }
 	};
 
 	template<class T,class P1> class Executor1 {
 	public:
-		static const intptr_t*	execute(const intptr_t* );
+        static const intptr_t*	execute(const intptr_t* stream)
+        {
+            T* obj = (T*)(void*)*stream++;
+            void (T::*method)(P1) = *(void (T::**)(P1))(void**)&*stream++;
+            const P1& p1 = *(const P1*)(void *)&*stream++;
+            (obj->*method)(p1);
+            return stream;
+        }
 	};
 
 	template<class T,class P1,class P2> class Executor2 {
 	public:
-		static const intptr_t*	execute(const intptr_t* );
+        static const intptr_t*	execute(const intptr_t* stream)
+        {
+            T* obj = (T*)(void*)*stream++;
+            void (T::*method)(P1,P2) = *(void (T::**)(P1,P2))(void**)&*stream++;
+            const P1& p1 = *(const P1*)(void *)&*stream++;
+            const P2& p2 = *(const P2*)(void *)&*stream++;
+            (obj->*method)(p1,p2);
+            return stream;
+        }
 	};
 
 	template<class T,class P1,class P2,class P3> class Executor3 {
 	public:
-		static const intptr_t*	execute(const intptr_t* );
+        static const intptr_t*	execute(const intptr_t* stream)
+        {
+            T* obj = (T*)(void*)*stream++;
+            void (T::*method)(P1,P2,P3) = *(void (T::**)(P1,P2,P3))(void**)&*stream++;
+            const P1& p1 = *(const P1*)(void *)&*stream++;
+            const P2& p2 = *(const P2*)(void *)&*stream++;
+            const P3& p3 = *(const P3*)(void *)&*stream++;
+            (obj->*method)(p1,p2,p3);
+            return stream;
+        }
 	};
 };
 
-}; };
+} }
 
 #endif

source/libs/magnum_core/source/magnum/container/Sequence.inl

-/* 
-  Magnum 
-  Copyright (C) 2002-2009 Kaya Memisoglu. All Rights Reserved.
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, under the terms in LICENSE.TXT.
-
-  Kaya Memisoglu  (k.memisoglu@dimajix.de)
-*/
-
-#ifndef __MAGNUM_CONTAINER_SEQUENCE_INL
-#define __MAGNUM_CONTAINER_SEQUENCE_INL
-
-#include "magnum/object/Object.inl"
-#include "magnum/object/Array.inl"
-
-
-namespace magnum { namespace container {
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-void Sequence::insert(T* obj,void (T::*method)(void)) {
-	m_Sequence.insert((intptr_t)(void*)obj);
-	m_Sequence.insert((intptr_t)(void*)&Executor0<T>::execute);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, class P1>
-void Sequence::insert(T* obj,void (T::*method)(P1),const P1& p1) {
-	m_Sequence.insert((intptr_t)(void*)obj);
-	m_Sequence.insert((intptr_t)(void*)&Executor1<T,P1>::execute);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, class P1,class P2>
-void Sequence::insert(T* obj,void (T::*method)(P1,P2),const P1& p1,const P2& p2) {
-	m_Sequence.insert((intptr_t)(void*)obj);
-	m_Sequence.insert((intptr_t)(void*)&Executor2<T,P1,P2>::execute);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p2);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T, class P1,class P2,class P3>
-void Sequence::insert(T* obj,void (T::*method)(P1,P2,P3),const P1& p1,const P2& p2,const P3& p3) {
-	m_Sequence.insert((intptr_t)(void*)obj);
-	m_Sequence.insert((intptr_t)(void*)&Executor3<T,P1,P2,P3>::execute);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p1);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p2);
-	m_Sequence.insert((intptr_t)(void*)*(void**)&p3);
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T>
-const intptr_t* Sequence::Executor0<T>::execute(const intptr_t* stream) {
-	T* obj = (T*)(void*)*stream++;
-	void (T::*method)() = *(void (T::**)())(void**)&*stream++;
-	(obj->*method)();
-	return stream;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T,class P1>
-const intptr_t* Sequence::Executor1<T,P1>::execute(const intptr_t* stream) {
-	T* obj = (T*)(void*)*stream++;
-	void (T::*method)(P1) = *(void (T::**)(P1))(void**)&*stream++;
-	const P1& p1 = *(const P1*)(void *)&*stream++;
-	(obj->*method)(p1);
-	return stream;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T,class P1,class P2>
-const intptr_t* Sequence::Executor2<T,P1,P2>::execute(const intptr_t* stream) {
-	T* obj = (T*)(void*)*stream++;
-	void (T::*method)(P1,P2) = *(void (T::**)(P1,P2))(void**)&*stream++;
-	const P1& p1 = *(const P1*)(void *)&*stream++;
-	const P2& p2 = *(const P2*)(void *)&*stream++;
-	(obj->*method)(p1,p2);
-	return stream;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-template<class T,class P1,class P2,class P3>
-const intptr_t* Sequence::Executor3<T,P1,P2,P3>::execute(const intptr_t* stream) {
-	T* obj = (T*)(void*)*stream++;
-	void (T::*method)(P1,P2,P3) = *(void (T::**)(P1,P2,P3))(void**)&*stream++;
-	const P1& p1 = *(const P1*)(void *)&*stream++;
-	const P2& p2 = *(const P2*)(void *)&*stream++;
-	const P3& p3 = *(const P3*)(void *)&*stream++;
-	(obj->*method)(p1,p2,p3);
-	return stream;
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-inline void Sequence::clear() {
-	m_Sequence.clear();
-}
-
-
-/*----------------------------------------------------------------------------
-----------------------------------------------------------------------------*/
-inline bool Sequence::isEmpty() const {
-	return m_Sequence.isEmpty();
-}
-
-}; };
-
-#endif

source/libs/magnum_core/source/magnum/container/Set.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #define __MAGNUM_CONTAINER_SET_INL
 
 #include "magnum/object/Array.inl"
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/Stack.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 #include "magnum/util/ElementUtils.h"
 
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-
 
 namespace magnum { namespace container {
 

source/libs/magnum_core/source/magnum/container/Trie.h

 #ifndef __MAGNUM_CONTAINER_TRIE_H
 #define __MAGNUM_CONTAINER_TRIE_H
 
+#include "magnum/object/String.h"
 #include "magnum/object/traits/CallTraits.h"
-#include "magnum/object/Object.h"
 #include "magnum/container/Iterator.h"
 #include "magnum/container/PoolAllocator.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
 using magnum::types::String;
 using magnum::types::traits::CallTraits;
 

source/libs/magnum_core/source/magnum/container/Trie.inl

 
 #include "magnum/object/Error.h" 
 
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
+#include "magnum/object/String.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_core/source/magnum/container/Vector.h

 #define __MAGNUM_CONTAINER_VECTOR_H
 
 #include "magnum/object/traits/CallTraits.h"
-#include "magnum/object/Object.h"
 #include "magnum/object/Array.h"
 #include "magnum/util/swap.h"
 #include "magnum/container/Iterator.h"
 
 
 namespace magnum { namespace container {
-using magnum::object::Object;
 using magnum::object::Array;
 using magnum::object::MemoryIterator;
 using magnum::object::ConstMemoryIterator;

source/libs/magnum_core/source/magnum/container/Vector.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/util/ElementUtils.h"
 
 #include "magnum/object/Array.inl"
-#include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
 
 
 namespace magnum { namespace container {

source/libs/magnum_geometry/source/magnum/geometry/Space.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/geometry/Line.inl"
 #include "magnum/geometry/Ray.inl"
 #include "magnum/geometry/Segment.inl"
-#include "magnum/container/Iterator.inl"
-#include "magnum/container/PoolAllocator.inl"
 
 
 namespace magnum { namespace geometry {

source/libs/magnum_graph/source/magnum/graph/Graph.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #define __MAGNUM_GRAPH_GRAPH_INL
 
 #include "magnum/object/Array.inl"
-#include "magnum/container/PoolAllocator.inl"
 #include "magnum/graph/Edge.inl"
 #include "magnum/graph/Node.inl"
 

source/libs/magnum_graph/source/magnum/graph/Node.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_GRAPH_NODE_INL
 #define __MAGNUM_GRAPH_NODE_INL
 
-#include "magnum/container/Iterator.inl"
 #include "magnum/graph/Edge.inl"
 
 

source/libs/magnum_physics/source/magnum/physics/Weight.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2011 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #include "magnum/physics/Spring.h"
 
 #include "magnum/object/Object.inl"
-#include "magnum/container/Iterator.inl"
 #include "magnum/physics/Relaxator.inl"
 #include "magnum/physics/Spring.inl"
 

source/libs/magnum_scene3d/source/magnum/scene3d/behaviourscheduler.cpp

 #include "magnum/scene3d/Behaviour.h"
 
 #include "magnum/object/WeakPointer.inl"
-#include "magnum/container/Iterator.inl"
 #include "magnum/scene3d/behaviourScheduler.inl"
 
 

source/libs/magnum_scene3d/source/magnum/scene3d/group.inl

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 #ifndef __MAGNUM_SCENE3D_GROUP_INL
 #define __MAGNUM_SCENE3D_GROUP_INL
 
-#include "magnum/container/Iterator.inl"
 #include "magnum/scene3d/Node.inl"
 
 

source/libs/magnum_test/source/magnum/test/Report.h

 /* 
   Magnum 
-  Copyright (C) 2002-2008 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
     virtual const ResultList* getResults() const = 0;
 };
 
-}; };
+} }
 
 #endif

source/libs/magnum_test/source/magnum/test/Result.h

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 typedef List<Reference<const Result> > ResultList;
 
-}; };
+} }
 
 #endif

source/libs/magnum_test/source/magnum/test/StdReport.cpp

 /* 
   Magnum 
-  Copyright (C) 2002-2009 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 /*--------------------------------------------------------------------------*/
 /**
  */
-StdReport::StdReport() {
-    m_Results = new ResultList();
+StdReport::StdReport()
+{
 }
 
 
 /**
  */
 const ResultList* StdReport::getResults() const {
-    return m_Results;
+    return &m_Results;
 }
 
 
 /**
  */
 void StdReport::insertResult(const Result* r) {
-    m_Results->insert(r);
+    m_Results.insert(r);
 }
 
 
 /**
  */
 void StdReport::removeResult(const Result* r) {
-    m_Results->remove(r);
+    m_Results.remove(r);
 }
 
 
 /*--------------------------------------------------------------------------*/
 /**
  */
-void StdReport::clearResults() {
-    m_Results = new ResultList();
+void StdReport::clearResults()
+{
+    m_Results.clear();
 }
 
-}; };
+} }

source/libs/magnum_test/source/magnum/test/StdReport.h

 /* 
   Magnum 
-  Copyright (C) 2002-2008 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 
 
 namespace magnum { namespace test {
-using magnum::object::Reference;
 
 
 /*--------------------------------------------------------------------------*/
 /**
  */
 class MAGNUM_TEST_API StdReport : public Report {
-DeclareClass(StdReport, Report);
+OBJECT_METAINFO(StdReport);
 public:
     StdReport();
     
-    virtual const ResultList*   getResults() const;
+    virtual const ResultList* getResults() const;
     
-    void                        insertResult(const Result* );
-    void                        removeResult(const Result* );
-    void                        clearResults();
+    void insertResult(const Result* );
+    void removeResult(const Result* );
+    void clearResults();
     
 private:
-    Reference<ResultList>       m_Results;
+    ResultList m_Results;
 };
 
-}; };
+} }
 
 #endif

source/libs/magnum_test/source/magnum/test/TestSuite.h

 /* 
   Magnum 
-  Copyright (C) 2002-2010 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
 	virtual const Result*   getResult() const = 0;
 };
 
-}; };
+} }
 
 #endif

source/libs/magnum_test/source/magnum/test/TestSuiteResult.h

 /* 
   Magnum 
-  Copyright (C) 2002-2008 Kaya Kupferschmidt. All Rights Reserved.
+  Copyright (C) 2002-2013 Kaya Kupferschmidt. All Rights Reserved.
 
   This software is provided 'as-is', without any express or implied
   warranty.  In no event will the authors be held liable for any damages
     Reference<const Result> m_TestResult;
 };
 
-}; };
+} }
 
 #endif