Fixed deprecated constructors with templates (#855)

Tomaqa · Tomaqa · commit afcebcefa000 · 2025-02-18T11:22:30.000+01:00
diff --git a/src/common/HashSet.h b/src/common/HashSet.h
@@ -30,11 +30,11 @@ template <class Value> class HashSet
     typedef typename Super::iterator iterator;
     typedef typename Super::const_iterator const_iterator;
 
-    HashSet<Value>()
+    HashSet()
     {
     }
 
-    HashSet<Value>( const std::initializer_list<Value> &initializerList )
+    HashSet( const std::initializer_list<Value> &initializerList )
         : _container( initializerList )
     {
     }
@@ -44,35 +44,35 @@ template <class Value> class HashSet
         _container.insert( value );
     }
 
-    void insert( const HashSet<Value> &other )
+    void insert( const HashSet &other )
     {
         for ( auto it = other.begin(); it != other.end(); ++it )
             _container.insert( *it );
     }
 
-    void operator+=( const HashSet<Value> &other )
+    void operator+=( const HashSet &other )
     {
         insert( other );
     }
 
-    HashSet<Value> operator+( const HashSet<Value> &other )
+    HashSet operator+( const HashSet &other )
     {
-        HashSet<Value> result = *this;
+        HashSet result = *this;
         result.insert( other );
         return result;
     }
 
-    bool operator==( const HashSet<Value> &other ) const
+    bool operator==( const HashSet &other ) const
     {
         return _container == other._container;
     }
 
-    bool operator!=( const HashSet<Value> &other ) const
+    bool operator!=( const HashSet &other ) const
     {
         return _container != other._container;
     }
 
-    bool operator<( const HashSet<Value> &other ) const
+    bool operator<( const HashSet &other ) const
     {
         return _container < other._container;
     }
diff --git a/src/common/List.h b/src/common/List.h
@@ -31,27 +31,27 @@ template <class T> class List
     typedef typename Super::reverse_iterator reverse_iterator;
     typedef typename Super::const_reverse_iterator const_reverse_iterator;
 
-    List<T>()
+    List()
     {
     }
 
-    List<T>( const std::initializer_list<T> &initializerList )
+    List( const std::initializer_list<T> &initializerList )
         : _container( initializerList )
     {
     }
 
-    List<T>( unsigned size, T value )
+    List( unsigned size, T value )
         : _container( size, value )
     {
     }
 
     template <class InputIt>
-    List<T>( InputIt begin, InputIt end )
+    List( InputIt begin, InputIt end )
         : _container( begin, end )
     {
     }
 
-    void append( const List<T> &other )
+    void append( const List &other )
     {
         for ( const auto &element : other )
             _container.push_back( element );
@@ -67,7 +67,7 @@ template <class T> class List
         _container.push_front( value );
     }
 
-    void appendHead( const List<T> &other )
+    void appendHead( const List &other )
     {
         _container.insert( begin(), other.begin(), other.end() );
     }
@@ -188,12 +188,12 @@ template <class T> class List
         _container.remove_if( p );
     }
 
-    bool operator==( const List<T> &other ) const
+    bool operator==( const List &other ) const
     {
         return _container == other._container;
     }
 
-    bool operator!=( const List<T> &other ) const
+    bool operator!=( const List &other ) const
     {
         return _container != other._container;
     }
diff --git a/src/common/Set.h b/src/common/Set.h
@@ -36,11 +36,11 @@ template <class Value> class Set
     typedef typename Super::const_iterator const_iterator;
     typedef typename Super::const_reverse_iterator const_reverse_iterator;
 
-    Set<Value>()
+    Set()
     {
     }
 
-    Set<Value>( const std::initializer_list<Value> &initializerList )
+    Set( const std::initializer_list<Value> &initializerList )
         : _container( initializerList )
     {
     }
@@ -50,7 +50,7 @@ template <class Value> class Set
         _container.insert( value );
     }
 
-    void insert( const Set<Value> &other )
+    void insert( const Set &other )
     {
         for ( auto it = other.begin(); it != other.end(); ++it )
             _container.insert( *it );
@@ -62,43 +62,43 @@ template <class Value> class Set
             _container.insert( *it );
     }
 
-    void operator+=( const Set<Value> &other )
+    void operator+=( const Set &other )
     {
         insert( other );
     }
 
-    Set<Value> operator+( const Set<Value> &other )
+    Set operator+( const Set &other )
     {
-        Set<Value> result = *this;
+        Set result = *this;
         result.insert( other );
         return result;
     }
 
-    bool operator==( const Set<Value> &other ) const
+    bool operator==( const Set &other ) const
     {
         return _container == other._container;
     }
 
-    bool operator!=( const Set<Value> &other ) const
+    bool operator!=( const Set &other ) const
     {
         return _container != other._container;
     }
 
-    bool operator<( const Set<Value> &other ) const
+    bool operator<( const Set &other ) const
     {
         return _container < other._container;
     }
 
-    static bool containedIn( const Set<Value> &one, const Set<Value> &two )
+    static bool containedIn( const Set &one, const Set &two )
     // Is one contained in two?
     {
-        return Set<Value>::difference( one, two ).empty();
+        return Set::difference( one, two ).empty();
     }
 
-    static Set<Value> difference( const Set<Value> &one, const Set<Value> &two )
+    static Set difference( const Set &one, const Set &two )
     // Elements that appear in one, but do not appear in two.
     {
-        Set<Value> difference;
+        Set difference;
         std::set_difference( one.begin(),
                              one.end(),
                              two.begin(),
@@ -107,9 +107,9 @@ template <class Value> class Set
         return difference;
     }
 
-    static Set<Value> intersection( const Set<Value> &one, const Set<Value> &two )
+    static Set intersection( const Set &one, const Set &two )
     {
-        Set<Value> intersection;
+        Set intersection;
         std::set_intersection( one.begin(),
                                one.end(),
                                two.begin(),
diff --git a/src/common/Vector.h b/src/common/Vector.h
@@ -33,29 +33,29 @@ template <class T> class Vector
 
     typedef typename Super::const_reverse_iterator const_reverse_iterator;
 
-    Vector<T>()
+    Vector()
     {
     }
 
-    Vector<T>( const Vector<T> &rhs ) = default;
+    Vector( const Vector &rhs ) = default;
 
-    Vector<T>( const std::initializer_list<T> &initializerList )
+    Vector( const std::initializer_list<T> &initializerList )
         : _container( initializerList )
     {
     }
 
-    Vector<T>( unsigned size )
+    Vector( unsigned size )
         : _container( size )
     {
     }
 
-    Vector<T>( unsigned size, T value )
+    Vector( unsigned size, T value )
         : _container( size, value )
     {
     }
 
     template <class InputIt>
-    Vector<T>( InputIt begin, InputIt end )
+    Vector( InputIt begin, InputIt end )
         : _container( begin, end )
     {
     }
@@ -238,9 +238,9 @@ template <class T> class Vector
         std::shuffle( _container.begin(), _container.end(), g );
     }
 
-    Vector<T> operator+( const Vector<T> &other )
+    Vector operator+( const Vector &other )
     {
-        Vector<T> output;
+        Vector output;
 
         for ( unsigned i = 0; i < this->size(); ++i )
             output.append( ( *this )[i] );
@@ -251,7 +251,7 @@ template <class T> class Vector
         return output;
     }
 
-    Vector<T> &operator+=( const Vector<T> &other )
+    Vector &operator+=( const Vector &other )
     {
         ( *this ) = ( *this ) + other;
         return *this;
@@ -293,12 +293,12 @@ template <class T> class Vector
         return value;
     }
 
-    bool operator==( const Vector<T> &other ) const
+    bool operator==( const Vector &other ) const
     {
         if ( size() != other.size() )
             return false;
 
-        Vector<T> copyOfOther = other;
+        Vector copyOfOther = other;
 
         for ( unsigned i = 0; i < size(); ++i )
         {
@@ -311,12 +311,12 @@ template <class T> class Vector
         return true;
     }
 
-    bool operator!=( const Vector<T> &other ) const
+    bool operator!=( const Vector &other ) const
     {
         return !( *this == other );
     }
 
-    Vector &operator=( const Vector<T> &other )
+    Vector &operator=( const Vector &other )
     {
         _container = other._container;
         return *this;

Original file line number	Diff line number	Diff line change
`@@ -30,11 +30,11 @@ template <class Value> class HashSet`
`30`	`30`	`typedef typename Super::iterator iterator;`
`31`	`31`	`typedef typename Super::const_iterator const_iterator;`
`32`	`32`
`33`		`- HashSet<Value>()`
	`33`	`+ HashSet()`
`34`	`34`	`{`
`35`	`35`	`}`
`36`	`36`
`37`		`- HashSet<Value>( const std::initializer_list<Value> &initializerList )`
	`37`	`+ HashSet( const std::initializer_list<Value> &initializerList )`
`38`	`38`	`: _container( initializerList )`
`39`	`39`	`{`
`40`	`40`	`}`
`@@ -44,35 +44,35 @@ template <class Value> class HashSet`
`44`	`44`	`_container.insert( value );`
`45`	`45`	`}`
`46`	`46`
`47`		`- void insert( const HashSet<Value> &other )`
	`47`	`+ void insert( const HashSet &other )`
`48`	`48`	`{`
`49`	`49`	`for ( auto it = other.begin(); it != other.end(); ++it )`
`50`	`50`	`_container.insert( *it );`
`51`	`51`	`}`
`52`	`52`
`53`		`- void operator+=( const HashSet<Value> &other )`
	`53`	`+ void operator+=( const HashSet &other )`
`54`	`54`	`{`
`55`	`55`	`insert( other );`
`56`	`56`	`}`
`57`	`57`
`58`		`- HashSet<Value> operator+( const HashSet<Value> &other )`
	`58`	`+ HashSet operator+( const HashSet &other )`
`59`	`59`	`{`
`60`		`- HashSet<Value> result = *this;`
	`60`	`+ HashSet result = *this;`
`61`	`61`	`result.insert( other );`
`62`	`62`	`return result;`
`63`	`63`	`}`
`64`	`64`
`65`		`- bool operator==( const HashSet<Value> &other ) const`
	`65`	`+ bool operator==( const HashSet &other ) const`
`66`	`66`	`{`
`67`	`67`	`return _container == other._container;`
`68`	`68`	`}`
`69`	`69`
`70`		`- bool operator!=( const HashSet<Value> &other ) const`
	`70`	`+ bool operator!=( const HashSet &other ) const`
`71`	`71`	`{`
`72`	`72`	`return _container != other._container;`
`73`	`73`	`}`
`74`	`74`
`75`		`- bool operator<( const HashSet<Value> &other ) const`
	`75`	`+ bool operator<( const HashSet &other ) const`
`76`	`76`	`{`
`77`	`77`	`return _container < other._container;`
`78`	`78`	`}`
Original file line number	Diff line number	Diff line change
`@@ -31,27 +31,27 @@ template <class T> class List`
`31`	`31`	`typedef typename Super::reverse_iterator reverse_iterator;`
`32`	`32`	`typedef typename Super::const_reverse_iterator const_reverse_iterator;`
`33`	`33`
`34`		`- List<T>()`
	`34`	`+ List()`
`35`	`35`	`{`
`36`	`36`	`}`
`37`	`37`
`38`		`- List<T>( const std::initializer_list<T> &initializerList )`
	`38`	`+ List( const std::initializer_list<T> &initializerList )`
`39`	`39`	`: _container( initializerList )`
`40`	`40`	`{`
`41`	`41`	`}`
`42`	`42`
`43`		`- List<T>( unsigned size, T value )`
	`43`	`+ List( unsigned size, T value )`
`44`	`44`	`: _container( size, value )`
`45`	`45`	`{`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`template <class InputIt>`
`49`		`- List<T>( InputIt begin, InputIt end )`
	`49`	`+ List( InputIt begin, InputIt end )`
`50`	`50`	`: _container( begin, end )`
`51`	`51`	`{`
`52`	`52`	`}`
`53`	`53`
`54`		`- void append( const List<T> &other )`
	`54`	`+ void append( const List &other )`
`55`	`55`	`{`
`56`	`56`	`for ( const auto &element : other )`
`57`	`57`	`_container.push_back( element );`
`@@ -67,7 +67,7 @@ template <class T> class List`
`67`	`67`	`_container.push_front( value );`
`68`	`68`	`}`
`69`	`69`
`70`		`- void appendHead( const List<T> &other )`
	`70`	`+ void appendHead( const List &other )`
`71`	`71`	`{`
`72`	`72`	`_container.insert( begin(), other.begin(), other.end() );`
`73`	`73`	`}`
`@@ -188,12 +188,12 @@ template <class T> class List`
`188`	`188`	`_container.remove_if( p );`
`189`	`189`	`}`
`190`	`190`
`191`		`- bool operator==( const List<T> &other ) const`
	`191`	`+ bool operator==( const List &other ) const`
`192`	`192`	`{`
`193`	`193`	`return _container == other._container;`
`194`	`194`	`}`
`195`	`195`
`196`		`- bool operator!=( const List<T> &other ) const`
	`196`	`+ bool operator!=( const List &other ) const`
`197`	`197`	`{`
`198`	`198`	`return _container != other._container;`
`199`	`199`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,11 +36,11 @@ template <class Value> class Set`
`36`	`36`	`typedef typename Super::const_iterator const_iterator;`
`37`	`37`	`typedef typename Super::const_reverse_iterator const_reverse_iterator;`
`38`	`38`
`39`		`- Set<Value>()`
	`39`	`+ Set()`
`40`	`40`	`{`
`41`	`41`	`}`
`42`	`42`
`43`		`- Set<Value>( const std::initializer_list<Value> &initializerList )`
	`43`	`+ Set( const std::initializer_list<Value> &initializerList )`
`44`	`44`	`: _container( initializerList )`
`45`	`45`	`{`
`46`	`46`	`}`
`@@ -50,7 +50,7 @@ template <class Value> class Set`
`50`	`50`	`_container.insert( value );`
`51`	`51`	`}`
`52`	`52`
`53`		`- void insert( const Set<Value> &other )`
	`53`	`+ void insert( const Set &other )`
`54`	`54`	`{`
`55`	`55`	`for ( auto it = other.begin(); it != other.end(); ++it )`
`56`	`56`	`_container.insert( *it );`
`@@ -62,43 +62,43 @@ template <class Value> class Set`
`62`	`62`	`_container.insert( *it );`
`63`	`63`	`}`
`64`	`64`
`65`		`- void operator+=( const Set<Value> &other )`
	`65`	`+ void operator+=( const Set &other )`
`66`	`66`	`{`
`67`	`67`	`insert( other );`
`68`	`68`	`}`
`69`	`69`
`70`		`- Set<Value> operator+( const Set<Value> &other )`
	`70`	`+ Set operator+( const Set &other )`
`71`	`71`	`{`
`72`		`- Set<Value> result = *this;`
	`72`	`+ Set result = *this;`
`73`	`73`	`result.insert( other );`
`74`	`74`	`return result;`
`75`	`75`	`}`
`76`	`76`
`77`		`- bool operator==( const Set<Value> &other ) const`
	`77`	`+ bool operator==( const Set &other ) const`
`78`	`78`	`{`
`79`	`79`	`return _container == other._container;`
`80`	`80`	`}`
`81`	`81`
`82`		`- bool operator!=( const Set<Value> &other ) const`
	`82`	`+ bool operator!=( const Set &other ) const`
`83`	`83`	`{`
`84`	`84`	`return _container != other._container;`
`85`	`85`	`}`
`86`	`86`
`87`		`- bool operator<( const Set<Value> &other ) const`
	`87`	`+ bool operator<( const Set &other ) const`
`88`	`88`	`{`
`89`	`89`	`return _container < other._container;`
`90`	`90`	`}`
`91`	`91`
`92`		`- static bool containedIn( const Set<Value> &one, const Set<Value> &two )`
	`92`	`+ static bool containedIn( const Set &one, const Set &two )`
`93`	`93`	`// Is one contained in two?`
`94`	`94`	`{`
`95`		`- return Set<Value>::difference( one, two ).empty();`
	`95`	`+ return Set::difference( one, two ).empty();`
`96`	`96`	`}`
`97`	`97`
`98`		`- static Set<Value> difference( const Set<Value> &one, const Set<Value> &two )`
	`98`	`+ static Set difference( const Set &one, const Set &two )`
`99`	`99`	`// Elements that appear in one, but do not appear in two.`
`100`	`100`	`{`
`101`		`- Set<Value> difference;`
	`101`	`+ Set difference;`
`102`	`102`	`std::set_difference( one.begin(),`
`103`	`103`	`one.end(),`
`104`	`104`	`two.begin(),`
`@@ -107,9 +107,9 @@ template <class Value> class Set`
`107`	`107`	`return difference;`
`108`	`108`	`}`
`109`	`109`
`110`		`- static Set<Value> intersection( const Set<Value> &one, const Set<Value> &two )`
	`110`	`+ static Set intersection( const Set &one, const Set &two )`
`111`	`111`	`{`
`112`		`- Set<Value> intersection;`
	`112`	`+ Set intersection;`
`113`	`113`	`std::set_intersection( one.begin(),`
`114`	`114`	`one.end(),`
`115`	`115`	`two.begin(),`
Original file line number	Diff line number	Diff line change
`@@ -33,29 +33,29 @@ template <class T> class Vector`
`33`	`33`
`34`	`34`	`typedef typename Super::const_reverse_iterator const_reverse_iterator;`
`35`	`35`
`36`		`- Vector<T>()`
	`36`	`+ Vector()`
`37`	`37`	`{`
`38`	`38`	`}`
`39`	`39`
`40`		`- Vector<T>( const Vector<T> &rhs ) = default;`
	`40`	`+ Vector( const Vector &rhs ) = default;`
`41`	`41`
`42`		`- Vector<T>( const std::initializer_list<T> &initializerList )`
	`42`	`+ Vector( const std::initializer_list<T> &initializerList )`
`43`	`43`	`: _container( initializerList )`
`44`	`44`	`{`
`45`	`45`	`}`
`46`	`46`
`47`		`- Vector<T>( unsigned size )`
	`47`	`+ Vector( unsigned size )`
`48`	`48`	`: _container( size )`
`49`	`49`	`{`
`50`	`50`	`}`
`51`	`51`
`52`		`- Vector<T>( unsigned size, T value )`
	`52`	`+ Vector( unsigned size, T value )`
`53`	`53`	`: _container( size, value )`
`54`	`54`	`{`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`template <class InputIt>`
`58`		`- Vector<T>( InputIt begin, InputIt end )`
	`58`	`+ Vector( InputIt begin, InputIt end )`
`59`	`59`	`: _container( begin, end )`
`60`	`60`	`{`
`61`	`61`	`}`
`@@ -238,9 +238,9 @@ template <class T> class Vector`
`238`	`238`	`std::shuffle( _container.begin(), _container.end(), g );`
`239`	`239`	`}`
`240`	`240`
`241`		`- Vector<T> operator+( const Vector<T> &other )`
	`241`	`+ Vector operator+( const Vector &other )`
`242`	`242`	`{`
`243`		`- Vector<T> output;`
	`243`	`+ Vector output;`
`244`	`244`
`245`	`245`	`for ( unsigned i = 0; i < this->size(); ++i )`
`246`	`246`	`output.append( ( *this )[i] );`
`@@ -251,7 +251,7 @@ template <class T> class Vector`
`251`	`251`	`return output;`
`252`	`252`	`}`
`253`	`253`
`254`		`- Vector<T> &operator+=( const Vector<T> &other )`
	`254`	`+ Vector &operator+=( const Vector &other )`
`255`	`255`	`{`
`256`	`256`	`( this ) = ( this ) + other;`
`257`	`257`	`return *this;`
`@@ -293,12 +293,12 @@ template <class T> class Vector`
`293`	`293`	`return value;`
`294`	`294`	`}`
`295`	`295`
`296`		`- bool operator==( const Vector<T> &other ) const`
	`296`	`+ bool operator==( const Vector &other ) const`
`297`	`297`	`{`
`298`	`298`	`if ( size() != other.size() )`
`299`	`299`	`return false;`
`300`	`300`
`301`		`- Vector<T> copyOfOther = other;`
	`301`	`+ Vector copyOfOther = other;`
`302`	`302`
`303`	`303`	`for ( unsigned i = 0; i < size(); ++i )`
`304`	`304`	`{`
`@@ -311,12 +311,12 @@ template <class T> class Vector`
`311`	`311`	`return true;`
`312`	`312`	`}`
`313`	`313`
`314`		`- bool operator!=( const Vector<T> &other ) const`
	`314`	`+ bool operator!=( const Vector &other ) const`
`315`	`315`	`{`
`316`	`316`	`return !( *this == other );`
`317`	`317`	`}`
`318`	`318`
`319`		`- Vector &operator=( const Vector<T> &other )`
	`319`	`+ Vector &operator=( const Vector &other )`
`320`	`320`	`{`
`321`	`321`	`_container = other._container;`
`322`	`322`	`return *this;`