fix version issue with compilers

Author: carmeloevoli

include/hermes/CacheTools.h

@@ -37,7 +37,7 @@ struct pair_hash {
 	}
 };
 
-struct pair_equal : public std::binary_function<tPairKey, tPairKey, bool> {
+struct pair_equal {
 	inline bool areEqual(double a, double b) const {
 		return (std::fabs(a - b) < std::numeric_limits<double>::epsilon());
 	}
@@ -46,7 +46,7 @@ struct pair_equal : public std::binary_function<tPairKey, tPairKey, bool> {
 	}
 };
 
-struct array_hash : public std::unary_function<tArrayKey, std::size_t> {
+struct array_hash {
 	std::size_t operator()(const tArrayKey &k) const {
 		auto h1 = std::hash<double>{}(std::get<0>(k));
 		auto h2 = std::hash<double>{}(std::get<1>(k));
@@ -58,18 +58,15 @@ struct array_hash : public std::unary_function<tArrayKey, std::size_t> {
 	}
 };
 
-struct array_equal : public std::binary_function<tArrayKey, tArrayKey, bool> {
-	bool areEqual(double a, double b) const {
-		return (std::fabs(a - b) < std::numeric_limits<double>::epsilon());
-	}
+struct array_equal {
+	bool areEqual(double a, double b) const { return (std::fabs(a - b) < std::numeric_limits<double>::epsilon()); }
 	bool operator()(const tArrayKey &v0, const tArrayKey &v1) const {
-		return (areEqual(std::get<0>(v0), std::get<0>(v1)) &&
-		        areEqual(std::get<1>(v0), std::get<1>(v1)) &&
+		return (areEqual(std::get<0>(v0), std::get<0>(v1)) && areEqual(std::get<1>(v0), std::get<1>(v1)) &&
 		        areEqual(std::get<2>(v0), std::get<2>(v1)));
 	}
 };
 
-struct array2_hash : public std::unary_function<tArray2Key, std::size_t> {
+struct array2_hash {
 	std::size_t operator()(const tArray2Key &k) const {
 		auto h1 = std::hash<int>{}(std::get<0>(k));
 		auto h2 = std::hash<int>{}(std::get<1>(k));
@@ -79,15 +76,13 @@ struct array2_hash : public std::unary_function<tArray2Key, std::size_t> {
 	}
 };
 
-struct array2_equal
-    : public std::binary_function<tArray2Key, tArray2Key, bool> {
+struct array2_equal {
 	bool operator()(const tArray2Key &v0, const tArray2Key &v1) const {
-		return (std::get<0>(v0) == std::get<0>(v1) &&
-		        std::get<1>(v0) == std::get<1>(v1));
+		return (std::get<0>(v0) == std::get<0>(v1) && std::get<1>(v0) == std::get<1>(v1));
 	}
 };
 
-struct tuple_hash : public std::unary_function<tTupleKey, std::size_t> {
+struct tuple_hash {
 	std::size_t operator()(const tTupleKey &k) const {
 		auto h1 = std::hash<double>{}(std::get<0>(k));
 		auto h2 = std::hash<double>{}(std::get<1>(k));
@@ -99,13 +94,10 @@ struct tuple_hash : public std::unary_function<tTupleKey, std::size_t> {
 	}
 };
 
-struct tuple_equal : public std::binary_function<tTupleKey, tTupleKey, bool> {
-	bool areEqual(double a, double b) const {
-		return (std::fabs(a - b) < std::numeric_limits<double>::epsilon());
-	}
+struct tuple_equal {
+	bool areEqual(double a, double b) const { return (std::fabs(a - b) < std::numeric_limits<double>::epsilon()); }
 	bool operator()(const tTupleKey &v0, const tTupleKey &v1) const {
-		return (areEqual(std::get<0>(v0), std::get<0>(v1)) &&
-		        areEqual(std::get<1>(v0), std::get<1>(v1)) &&
+		return (areEqual(std::get<0>(v0), std::get<0>(v1)) && areEqual(std::get<1>(v0), std::get<1>(v1)) &&
 		        areEqual(std::get<2>(v0), std::get<2>(v1)));
 	}
 };
@@ -121,26 +113,22 @@ class CacheStorageWith2Args {
 	mutable MutexType mtx;
 
   public:
-	CacheStorageWith2Args(){};
+	CacheStorageWith2Args() {};
 	~CacheStorageWith2Args() { cachedValues.clear(); };
 	CacheStorageWith2Args(CacheStorageWith2Args &&other) {  // Move declaration
 		std::unique_lock<MutexType>(other.mtx);
 	}
-	CacheStorageWith2Args &operator=(CacheStorageWith2Args &&other) =
-	    delete;  // Move assignment
-	CacheStorageWith2Args(const CacheStorageWith2Args &other) =
-	    delete;  // Copy declaration
-	CacheStorageWith2Args &operator=(const CacheStorageWith2Args &other) =
-	    delete;  // Copy Assignment
+	CacheStorageWith2Args &operator=(CacheStorageWith2Args &&other) = delete;       // Move assignment
+	CacheStorageWith2Args(const CacheStorageWith2Args &other) = delete;             // Copy declaration
+	CacheStorageWith2Args &operator=(const CacheStorageWith2Args &other) = delete;  // Copy Assignment
 
 	void setFunction(std::function<V(Q1, Q2)> f_) { f = f_; }
 
 	void cacheValue(const tPairKey &key, V value) { cachedValues[key] = value; }
 
 	V getValue(Q1 q1, Q2 q2) {
 		V result(0);
-		auto key =
-		    std::make_pair(static_cast<double>(q1), static_cast<double>(q2));
+		auto key = std::make_pair(static_cast<double>(q1), static_cast<double>(q2));
 		auto it = cachedValues.find(key);
 		if (it == cachedValues.end()) {
 			result = f(q1, q2);
@@ -150,9 +138,7 @@ class CacheStorageWith2Args {
 		return cachedValues[key];
 	}
 
-	V operator[](const std::pair<double, double> &key) const {
-		return cachedValues[key];
-	}
+	V operator[](const std::pair<double, double> &key) const { return cachedValues[key]; }
 };
 
 template <typename Q1, typename Q2, typename Q3, typename V>
@@ -169,32 +155,26 @@ class CacheStorageWith3Args {
 	mutable MutexType mtx;
 
   public:
-	CacheStorageWith3Args(){};
+	CacheStorageWith3Args() {};
 	~CacheStorageWith3Args() { cachedValues.clear(); };
 	CacheStorageWith3Args(CacheStorageWith3Args &&other) {  // Move declaration
 		std::unique_lock<MutexType>(other.mtx);
 	}
-	CacheStorageWith3Args &operator=(CacheStorageWith3Args &&other) =
-	    delete;  // Move assignment
-	CacheStorageWith3Args(const CacheStorageWith3Args &other) =
-	    delete;  // Copy declaration
-	CacheStorageWith3Args &operator=(const CacheStorageWith3Args &other) =
-	    delete;  // Copy Assignment
+	CacheStorageWith3Args &operator=(CacheStorageWith3Args &&other) = delete;       // Move assignment
+	CacheStorageWith3Args(const CacheStorageWith3Args &other) = delete;             // Copy declaration
+	CacheStorageWith3Args &operator=(const CacheStorageWith3Args &other) = delete;  // Copy Assignment
 
 	void setFunction(std::function<V(Q1, Q2, Q3)> f_) { f = f_; }
 
-	void cacheValue(const tTupleKey &key, V value) {
-		cachedValues[key] = value;
-	}
+	void cacheValue(const tTupleKey &key, V value) { cachedValues[key] = value; }
 
 	V getValue(Q1 q1, Q2 q2, Q3 q3) {
 		V result(0);
 		/*auto key = std::make_tuple(
 		        static_cast<double>(q1),
 		        static_cast<double>(q2),
 		        static_cast<double>(q3));*/
-		tTupleKey key = {{static_cast<double>(q1), static_cast<double>(q2),
-		                  static_cast<double>(q3)}};
+		tTupleKey key = {{static_cast<double>(q1), static_cast<double>(q2), static_cast<double>(q3)}};
 		auto it = cachedValues.find(key);
 		if (it == cachedValues.end()) {
 			result = f(q1, q2, q3);
@@ -207,18 +187,13 @@ class CacheStorageWith3Args {
 class CacheStorageIC2 {
   private:
 	typedef std::array<int, 2> tArray2Key;
-	std::unordered_map<tArray2Key, QGREmissivity, array2_hash, array2_equal>
-	    cachedValues;
+	std::unordered_map<tArray2Key, QGREmissivity, array2_hash, array2_equal> cachedValues;
 	std::function<QGREmissivity(int, int, QEnergy)> f;
 
   public:
-	void setFunction(std::function<QGREmissivity(int, int, QEnergy)> f_) {
-		f = f_;
-	}
+	void setFunction(std::function<QGREmissivity(int, int, QEnergy)> f_) { f = f_; }
 
-	void cacheValue(const tArray2Key &key, QGREmissivity value) {
-		cachedValues[key] = value;
-	}
+	void cacheValue(const tArray2Key &key, QGREmissivity value) { cachedValues[key] = value; }
 
 	QGREmissivity getValue(int q1, int q2, QEnergy q3) {
 		QGREmissivity result(0);
@@ -233,10 +208,8 @@ class CacheStorageIC2 {
 };
 
 typedef CacheStorageWith3Args<int, int, QEnergy, QGREmissivity> CacheStorageIC;
-typedef CacheStorageWith2Args<QEnergy, QEnergy, QDiffCrossSection>
-    CacheStorageCrossSection;
-typedef CacheStorageWith3Args<QEnergy, QEnergy, QEnergy, QDiffCrossSection>
-    CacheStorageCrossSection3Args;
+typedef CacheStorageWith2Args<QEnergy, QEnergy, QDiffCrossSection> CacheStorageCrossSection;
+typedef CacheStorageWith3Args<QEnergy, QEnergy, QEnergy, QDiffCrossSection> CacheStorageCrossSection3Args;
 
 }  // namespace hermes