stricter template definitions for gcc compat

src/VAObjectContainer.h

@@ -4,6 +4,8 @@
 #include <limits>
 #include <map>
 #include <set>
+#include <cstdint>
+#include <climits>
 
 /**
  * Diese generische Klasse realisiert Container fr Objekte in VA (Schallquellen, Hrer, ...)
@@ -16,12 +18,20 @@
  * Wichtig: Die Klasse ist nicht Thread-safe! Sie muss von aussen abgesichert werden.
  */
 
-template <typename T> class CVAObjectContainer
+template< typename T > class CVAObjectContainer
 {
 public:
 	// iEndID letztmgliche ID. Falls berlauf -> Exception
-	CVAObjectContainer(int iStartID=1, int iLastID=INT_MAX) : m_iStartID(iStartID), m_iIDCount(iStartID), m_iIDLast(iLastID) {}
-	virtual ~CVAObjectContainer() {};
+	inline CVAObjectContainer( int iStartID = 1, int iLastID = std::numeric_limits<std::int32_t>::max() )
+		: m_iStartID( iStartID )
+		, m_iIDCount( iStartID )
+		, m_iIDLast( iLastID )
+	{
+	};
+
+	inline virtual ~CVAObjectContainer()
+	{
+	};
 
 	// Lscht alle Elemente im Container
 	inline void Clear()
@@ -34,30 +44,30 @@ public:
 
 	// Fgt dem Container ein neues Objekt hinzu und gibt die ID zurck
 	// (Falls das Objekt schon enthalten war, wird die bereits zugeordnete ID zurckgegeben)
-	inline int Add(T* pObject)
+	inline int Add( T* pObject )
 	{
 		// Zunchst prfen, ob das Objekt schon enthalten ist
-		int iID = GetID(pObject);
-		if (iID != -1) return iID;
+		int iID = GetID( pObject );
+		if( iID != -1 ) return iID;
 
 		// Freie ID holen
 		iID = m_iIDCount++;
 
 		// Zuordnungen setzen
 		//m_sElements.insert(pObject);
-		m_mID2Object.insert( std::pair<int,T*>( iID, pObject ) );
-		m_mObject2ID.insert( std::pair<T*,int>( pObject, iID ) );
+		m_mID2Object.insert( std::pair<int, T*>( iID, pObject ) );
+		m_mObject2ID.insert( std::pair<T*, int>( pObject, iID ) );
 
 		// Referenzzhler initialisieren
-		m_mID2Ref.insert( std::pair<int,int>( iID, 0 ) );
+		m_mID2Ref.insert( std::pair<int, int>( iID, 0 ) );
 
 		return iID;
 	};
 
 	inline void Remove( int iID )
 	{
-		std::map< int, T* >::iterator it = m_mID2Object.find( iID );
-		
+		typename std::map< int, T* >::iterator it = m_mID2Object.find( iID );
+
 		if( it == m_mID2Object.end() )
 			return;
 
@@ -68,72 +78,76 @@ public:
 	};
 
 	// Entfernt ein enthaltenes Objekt
-	inline void Remove(T* pObject)
+	inline void Remove( T* pObject )
 	{
-		std::map<T*,int>::iterator it = m_mObject2ID.find(pObject);
-		
+		typename std::map< T*, int >::iterator it = m_mObject2ID.find( pObject );
+
 		// Nicht enthalten
-		if (it == m_mObject2ID.end()) return;
+		if( it == m_mObject2ID.end() ) return;
 
 		int iID = it->second;
-		m_mID2Objects.erase(iID);
+		m_mID2Objects.erase( iID );
 		m_mObject2ID.erase( pObject );
-		m_mID2Ref.erase(iID);
+		m_mID2Ref.erase( iID );
 	};
 
 	// Gibt zu einer ID das assozierte Objekt zurck
 	// (Gibt nullptr zurck, falls das Objekt nicht enthalten ist)
-	inline T* GetObject(int iID) const
+	inline T* GetObject( int iID ) const
 	{
-		std::map<int,T*>::const_iterator cit = m_mID2Object.find(iID);
-		return (cit == m_mID2Object.end() ? nullptr : cit->second);
+		typename std::map< int, T* >::const_iterator cit = m_mID2Object.find( iID );
+		return ( cit == m_mID2Object.end() ? nullptr : cit->second );
 	};
 
 	// Gibt zu einem Objekt die zugeordnete ID zurck
 	// (Gibt -1 zurck, falls Objekt nicht enthalten)
-	inline int GetID(T* pObject) const
+	inline int GetID( T* pObject ) const
 	{
-		std::map<T*,int>::const_iterator cit = m_mObject2ID.find(pObject);
-		return (cit == m_mObject2ID.end() ? -1 : cit->second);
+		typename std::map<T*, int>::const_iterator cit = m_mObject2ID.find( pObject );
+		return ( cit == m_mObject2ID.end() ? -1 : cit->second );
 	};
 
 	// Referenzzhler eines Objektes zurckgeben (Rckgabe -1 falls ID ungltig)
-	inline int GetRefCount(int iID) const
+	inline int GetRefCount( int iID ) const
 	{
-		std::map<int,int>::const_iterator cit = m_mID2Ref.find(iID);
-		return (cit == m_mID2Ref.end() ? -1 : cit->second);
+		typename std::map<int, int>::const_iterator cit = m_mID2Ref.find( iID );
+		return ( cit == m_mID2Ref.end() ? -1 : cit->second );
 	};
 
 	// Referenzzhler eines Objektes inkrementieren (gibt Wert nach Inkrementierung zurck, Rckgabe -1 falls ID ungltig)
-	inline int IncRefCount(int iID) {
-		std::map<int,int>::iterator it = m_mID2Ref.find(iID);
-		return (it == m_mID2Ref.end() ? -1 : ++(it->second));
+	inline int IncRefCount( int iID )
+	{
+		typename std::map<int, int>::iterator it = m_mID2Ref.find( iID );
+		return ( it == m_mID2Ref.end() ? -1 : ++( it->second ) );
 	};
 
 	// Referenzzhler eines Objektes dekrementieren (gibt Wert nach Dekrementierung zurck, Rckgabe -1 falls ID ungltig)
-	inline int DecRefCount(int iID) {
-		std::map<int,int>::iterator it = m_mID2Ref.find(iID);
-		return (it == m_mID2Ref.end() ? -1 : (it->second > 0 ? --(it->second) : 0));
+	inline int DecRefCount( int iID )
+	{
+		typename std::map<int, int>::iterator it = m_mID2Ref.find( iID );
+		return ( it == m_mID2Ref.end() ? -1 : ( it->second > 0 ? --( it->second ) : 0 ) );
 	};
 
 	// Wie GetObject(), erhht aber direkt den Referenzzhler
-	inline T* Request(int iID) {
-		T* pObject = GetObject(iID);
+	inline T* Request( int iID ) {
+		T* pObject = GetObject( iID );
 
 		// Gltige ID? Dann Referenzzhler erhhen
-		if (pObject) IncRefCount(iID);
+		if( pObject ) IncRefCount( iID );
 
 		return pObject;
 	};
 
 	// Alias fr DecRefCount() (Rckgabewert: Verbleibende Anzahl Referenzen, Rckgabe -1 falls ID ungltig)
-	inline int Release(int iID) {
-		return DecRefCount(iID);
+	inline int Release( int iID )
+	{
+		return DecRefCount( iID );
 	};
 
 	// Der Operator [] ist Alias fr GetObject()
-	inline T* operator[](int iID) const {
-		return GetObject(iID);
+	inline T* operator[]( int iID ) const
+	{
+		return GetObject( iID );
 	};
 
 	// --= Realisierung des STL-Iterator-Patterns =--
@@ -145,26 +159,61 @@ public:
 	typedef typename std::map<int, T*>::iterator iterator;
 	typedef typename std::map<int, T*>::const_iterator const_iterator;
 
-	inline iterator begin() { return m_mID2Object.begin(); };
-	inline iterator end() { return m_mID2Object.end(); };
+	inline iterator begin()
+	{ 
+		return m_mID2Object.begin();
+	};
 
-	inline const_iterator begin() const { return m_mID2Object.begin(); };
-	inline const_iterator end() const { return m_mID2Object.end(); };
+	inline iterator end()
+	{
+		return m_mID2Object.end();
+	};
 
-	inline T& front() { return m_mID2Object.front(); };
-	inline T& back() { return m_mID2Object.back(); };
+	inline const_iterator begin() const 
+	{ 
+		return m_mID2Object.begin();
+	};
 
-	inline const T& front() const { return m_mID2Object.front(); };
-	inline const T& back() const { return m_mID2Object.back(); };
+	inline const_iterator end() const
+	{
+		return m_mID2Object.end();
+	};
+
+	inline T& front() 
+	{ 
+		return m_mID2Object.front();
+	};
+
+	inline T& back() 
+	{ 
+		return m_mID2Object.back(); 
+	};
+
+	inline const T& front() const 
+	{
+		return m_mID2Object.front();
+	};
 
-	inline size_t size() const { return m_mID2Object.size(); };
-	inline bool empty() const { return m_mID2Object.empty(); };
+	inline const T& back() const 
+	{
+		return m_mID2Object.back();
+	};
+
+	inline size_t size() const 
+	{
+		return m_mID2Object.size();
+	};
+
+	inline bool empty() const 
+	{
+		return m_mID2Object.empty();
+	};
 
 private:
 	int m_iStartID, m_iIDCount, m_iIDLast;
-	std::map<int, T*> m_mID2Object;	// Assoziationen ID -> Objekt
-	std::map<T*, int> m_mObject2ID;	// Assoziationen Objekt -> ID
-	std::map<int, int> m_mID2Ref;	// Referenzzhler
+	std::map< int, T* > m_mID2Object;	// Assoziationen ID -> Objekt
+	std::map< T*, int > m_mObject2ID;	// Assoziationen Objekt -> ID
+	std::map< int, int> m_mID2Ref;	// Referenzzhler
 };
 
 #endif // __VA_OBJECTCONTAINER_H__