thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-22 23:52:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

Unification [#CLICKHOUSE-2].

Browse Source
This commit is contained in:
Alexey Milovidov 2017-09-15 15:16:12 +03:00
parent e29b0e1750
commit 86c46ad1bd
51 changed files with 409 additions and 409 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dbms/src/AggregateFunctions/AggregateFunctionGroupArray.cpp
View File

@ -8,7 +8,7 @@ namespace DB
namespace namespace
{ {
template <template <typename, typename> class AggregateFunctionTemplate, class Data, typename ... TArgs> template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
static IAggregateFunction * createWithNumericOrTimeType(const IDataType & argument_type, TArgs && ... args) static IAggregateFunction * createWithNumericOrTimeType(const IDataType & argument_type, TArgs && ... args)
{ {
if (typeid_cast<const DataTypeDate *>(&argument_type)) return new AggregateFunctionTemplate<UInt16, Data>(std::forward<TArgs>(args)...); if (typeid_cast<const DataTypeDate *>(&argument_type)) return new AggregateFunctionTemplate<UInt16, Data>(std::forward<TArgs>(args)...);

30
dbms/src/AggregateFunctions/AggregateFunctionStatistics.h
View File

@ -47,7 +47,7 @@ bool areComparable(UInt64 a, UInt64 b)
* Source: "Updating formulae and a pairwise algorithm for computing sample variances" * Source: "Updating formulae and a pairwise algorithm for computing sample variances"
* (Chan et al., Stanford University, 12.1979) * (Chan et al., Stanford University, 12.1979)
*/ */
template<typename T, typename Op> template <typename T, typename Op>
class AggregateFunctionVarianceData class AggregateFunctionVarianceData
{ {
public: public:
@ -109,7 +109,7 @@ private:
/** The main code for the implementation of varSamp, stddevSamp, varPop, stddevPop. /** The main code for the implementation of varSamp, stddevSamp, varPop, stddevPop.
*/ */
template<typename T, typename Op> template <typename T, typename Op>
class AggregateFunctionVariance final class AggregateFunctionVariance final
: public IUnaryAggregateFunction<AggregateFunctionVarianceData<T, Op>, : public IUnaryAggregateFunction<AggregateFunctionVarianceData<T, Op>,
AggregateFunctionVariance<T, Op>> AggregateFunctionVariance<T, Op>>
@ -214,7 +214,7 @@ struct AggregateFunctionStdDevPopImpl
/** If `compute_marginal_moments` flag is set this class provides the successor /** If `compute_marginal_moments` flag is set this class provides the successor
* CovarianceData support of marginal moments for calculating the correlation. * CovarianceData support of marginal moments for calculating the correlation.
*/ */
template<bool compute_marginal_moments> template <bool compute_marginal_moments>
class BaseCovarianceData class BaseCovarianceData
{ {
protected: protected:
@ -224,7 +224,7 @@ protected:
void deserialize(const ReadBuffer & buf) {} void deserialize(const ReadBuffer & buf) {}
}; };
template<> template <>
class BaseCovarianceData<true> class BaseCovarianceData<true>
{ {
protected: protected:
@ -262,7 +262,7 @@ protected:
* (J. Bennett et al., Sandia National Laboratories, * (J. Bennett et al., Sandia National Laboratories,
* 2009 IEEE International Conference on Cluster Computing) * 2009 IEEE International Conference on Cluster Computing)
*/ */
template<typename T, typename U, typename Op, bool compute_marginal_moments> template <typename T, typename U, typename Op, bool compute_marginal_moments>
class CovarianceData : public BaseCovarianceData<compute_marginal_moments> class CovarianceData : public BaseCovarianceData<compute_marginal_moments>
{ {
private: private:
@ -348,13 +348,13 @@ public:
Base::deserialize(buf); Base::deserialize(buf);
} }
template<bool compute = compute_marginal_moments> template <bool compute = compute_marginal_moments>
void publish(IColumn & to, typename std::enable_if<compute>::type * = nullptr) const void publish(IColumn & to, typename std::enable_if<compute>::type * = nullptr) const
{ {
static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, Base::left_m2, Base::right_m2, count)); static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, Base::left_m2, Base::right_m2, count));
} }
template<bool compute = compute_marginal_moments> template <bool compute = compute_marginal_moments>
void publish(IColumn & to, typename std::enable_if<!compute>::type * = nullptr) const void publish(IColumn & to, typename std::enable_if<!compute>::type * = nullptr) const
{ {
static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, count)); static_cast<ColumnFloat64 &>(to).getData().push_back(Op::apply(co_moment, count));
@ -367,7 +367,7 @@ private:
Float64 co_moment = 0.0; Float64 co_moment = 0.0;
}; };
template<typename T, typename U, typename Op, bool compute_marginal_moments = false> template <typename T, typename U, typename Op, bool compute_marginal_moments = false>
class AggregateFunctionCovariance final class AggregateFunctionCovariance final
: public IBinaryAggregateFunction< : public IBinaryAggregateFunction<
CovarianceData<T, U, Op, compute_marginal_moments>, CovarianceData<T, U, Op, compute_marginal_moments>,
@ -465,25 +465,25 @@ struct AggregateFunctionCorrImpl
} }
}; };
template<typename T> template <typename T>
using AggregateFunctionVarSamp = AggregateFunctionVariance<T, AggregateFunctionVarSampImpl>; using AggregateFunctionVarSamp = AggregateFunctionVariance<T, AggregateFunctionVarSampImpl>;
template<typename T> template <typename T>
using AggregateFunctionStdDevSamp = AggregateFunctionVariance<T, AggregateFunctionStdDevSampImpl>; using AggregateFunctionStdDevSamp = AggregateFunctionVariance<T, AggregateFunctionStdDevSampImpl>;
template<typename T> template <typename T>
using AggregateFunctionVarPop = AggregateFunctionVariance<T, AggregateFunctionVarPopImpl>; using AggregateFunctionVarPop = AggregateFunctionVariance<T, AggregateFunctionVarPopImpl>;
template<typename T> template <typename T>
using AggregateFunctionStdDevPop = AggregateFunctionVariance<T, AggregateFunctionStdDevPopImpl>; using AggregateFunctionStdDevPop = AggregateFunctionVariance<T, AggregateFunctionStdDevPopImpl>;
template<typename T, typename U> template <typename T, typename U>
using AggregateFunctionCovarSamp = AggregateFunctionCovariance<T, U, AggregateFunctionCovarSampImpl>; using AggregateFunctionCovarSamp = AggregateFunctionCovariance<T, U, AggregateFunctionCovarSampImpl>;
template<typename T, typename U> template <typename T, typename U>
using AggregateFunctionCovarPop = AggregateFunctionCovariance<T, U, AggregateFunctionCovarPopImpl>; using AggregateFunctionCovarPop = AggregateFunctionCovariance<T, U, AggregateFunctionCovarPopImpl>;
template<typename T, typename U> template <typename T, typename U>
using AggregateFunctionCorr = AggregateFunctionCovariance<T, U, AggregateFunctionCorrImpl, true>; using AggregateFunctionCorr = AggregateFunctionCovariance<T, U, AggregateFunctionCorrImpl, true>;
} }

4
dbms/src/AggregateFunctions/Helpers.h
View File

@ -34,7 +34,7 @@ static IAggregateFunction * createWithNumericType(const IDataType & argument_typ
return nullptr; return nullptr;
} }
template <template <typename, typename> class AggregateFunctionTemplate, class Data> template <template <typename, typename> class AggregateFunctionTemplate, typename Data>
static IAggregateFunction * createWithNumericType(const IDataType & argument_type) static IAggregateFunction * createWithNumericType(const IDataType & argument_type)
{ {
if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>; if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>;
@ -53,7 +53,7 @@ static IAggregateFunction * createWithNumericType(const IDataType & argument_typ
return nullptr; return nullptr;
} }
template <template <typename, typename> class AggregateFunctionTemplate, class Data, typename ... TArgs> template <template <typename, typename> class AggregateFunctionTemplate, typename Data, typename ... TArgs>
static IAggregateFunction * createWithNumericType(const IDataType & argument_type, TArgs && ... args) static IAggregateFunction * createWithNumericType(const IDataType & argument_type, TArgs && ... args)
{ {
if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>(std::forward<TArgs>(args)...); if (typeid_cast<const DataTypeUInt8 *>(&argument_type)) return new AggregateFunctionTemplate<UInt8, Data>(std::forward<TArgs>(args)...);

6
dbms/src/AggregateFunctions/ReservoirSampler.h
View File

@ -30,7 +30,7 @@ namespace ReservoirSamplerOnEmpty
}; };
} }
template<typename ResultType, bool IsFloatingPoint> template <typename ResultType, bool IsFloatingPoint>
struct NanLikeValueConstructor struct NanLikeValueConstructor
{ {
static ResultType getValue() static ResultType getValue()
@ -38,7 +38,7 @@ struct NanLikeValueConstructor
return std::numeric_limits<ResultType>::quiet_NaN(); return std::numeric_limits<ResultType>::quiet_NaN();
} }
}; };
template<typename ResultType> template <typename ResultType>
struct NanLikeValueConstructor<ResultType, false> struct NanLikeValueConstructor<ResultType, false>
{ {
static ResultType getValue() static ResultType getValue()
@ -47,7 +47,7 @@ struct NanLikeValueConstructor<ResultType, false>
} }
}; };
template<typename T, ReservoirSamplerOnEmpty::Enum OnEmpty = ReservoirSamplerOnEmpty::THROW, typename Comparer = std::less<T>> template <typename T, ReservoirSamplerOnEmpty::Enum OnEmpty = ReservoirSamplerOnEmpty::THROW, typename Comparer = std::less<T>>
class ReservoirSampler class ReservoirSampler
{ {
public: public:

4
dbms/src/Common/CombinedCardinalityEstimator.h
View File

@ -287,13 +287,13 @@ private:
} }
} }
template<typename T> template <typename T>
inline T & getContainer() inline T & getContainer()
{ {
return *reinterpret_cast<T *>(address & mask); return *reinterpret_cast<T *>(address & mask);
} }
template<typename T> template <typename T>
inline const T & getContainer() const inline const T & getContainer() const
{ {
return *reinterpret_cast<T *>(address & mask); return *reinterpret_cast<T *>(address & mask);

8
dbms/src/Common/ConcurrentBoundedQueue.h
View File

@ -11,10 +11,10 @@
namespace detail namespace detail
{ {
template <class T, bool is_nothrow_move_assignable = std::is_nothrow_move_assignable<T>::value> template <typename T, bool is_nothrow_move_assignable = std::is_nothrow_move_assignable<T>::value>
struct MoveOrCopyIfThrow; struct MoveOrCopyIfThrow;
template <class T> template <typename T>
struct MoveOrCopyIfThrow<T, true> struct MoveOrCopyIfThrow<T, true>
{ {
void operator()(T && src, T & dst) const void operator()(T && src, T & dst) const
@ -23,7 +23,7 @@ namespace detail
} }
}; };
template <class T> template <typename T>
struct MoveOrCopyIfThrow<T, false> struct MoveOrCopyIfThrow<T, false>
{ {
void operator()(T && src, T & dst) const void operator()(T && src, T & dst) const
@ -32,7 +32,7 @@ namespace detail
} }
}; };
template <class T> template <typename T>
void moveOrCopyIfThrow(T && src, T & dst) void moveOrCopyIfThrow(T && src, T & dst)
{ {
MoveOrCopyIfThrow<T>()(std::forward<T>(src), dst); MoveOrCopyIfThrow<T>()(std::forward<T>(src), dst);

20
dbms/src/Common/HyperLogLogCounter.h
View File

@ -36,7 +36,7 @@ namespace details
{ {
/// Look-up table of logarithms for integer numbers, used in HyperLogLogCounter. /// Look-up table of logarithms for integer numbers, used in HyperLogLogCounter.
template<UInt8 K> template <UInt8 K>
struct LogLUT struct LogLUT
{ {
LogLUT() LogLUT()
@ -60,15 +60,15 @@ private:
double log_table[M + 1]; double log_table[M + 1];
}; };
template<UInt8 K> struct MinCounterTypeHelper; template <UInt8 K> struct MinCounterTypeHelper;
template<> struct MinCounterTypeHelper<0> { using Type = UInt8; }; template <> struct MinCounterTypeHelper<0> { using Type = UInt8; };
template<> struct MinCounterTypeHelper<1> { using Type = UInt16; }; template <> struct MinCounterTypeHelper<1> { using Type = UInt16; };
template<> struct MinCounterTypeHelper<2> { using Type = UInt32; }; template <> struct MinCounterTypeHelper<2> { using Type = UInt32; };
template<> struct MinCounterTypeHelper<3> { using Type = UInt64; }; template <> struct MinCounterTypeHelper<3> { using Type = UInt64; };
/// Auxiliary structure for automatic determining minimum size of counter's type depending on its maximum value. /// Auxiliary structure for automatic determining minimum size of counter's type depending on its maximum value.
/// Used in HyperLogLogCounter in order to spend memory efficiently. /// Used in HyperLogLogCounter in order to spend memory efficiently.
template<UInt64 MaxValue> struct MinCounterType template <UInt64 MaxValue> struct MinCounterType
{ {
using Type = typename MinCounterTypeHelper< using Type = typename MinCounterTypeHelper<
(MaxValue >= 1 << 8) + (MaxValue >= 1 << 8) +
@ -78,7 +78,7 @@ template<UInt64 MaxValue> struct MinCounterType
}; };
/// Denominator of expression for HyperLogLog algorithm. /// Denominator of expression for HyperLogLog algorithm.
template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType, template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
DenominatorMode denominator_mode, typename Enable = void> DenominatorMode denominator_mode, typename Enable = void>
class __attribute__ ((packed)) Denominator; class __attribute__ ((packed)) Denominator;
@ -118,7 +118,7 @@ struct IntermediateDenominator<HashValueType, DenominatorType, DenominatorMode::
/// "Lightweight" implementation of expression's denominator for HyperLogLog algorithm. /// "Lightweight" implementation of expression's denominator for HyperLogLog algorithm.
/// Uses minimum amount of memory, but estimates may be unstable. /// Uses minimum amount of memory, but estimates may be unstable.
/// Satisfiable when rank storage is small enough. /// Satisfiable when rank storage is small enough.
template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType, template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
DenominatorMode denominator_mode> DenominatorMode denominator_mode>
class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType, class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
denominator_mode, denominator_mode,
@ -162,7 +162,7 @@ private:
/// Fully-functional version of expression's denominator for HyperLogLog algorithm. /// Fully-functional version of expression's denominator for HyperLogLog algorithm.
/// Spends more space that lightweight version. Estimates will always be stable. /// Spends more space that lightweight version. Estimates will always be stable.
/// Used when rank storage is big. /// Used when rank storage is big.
template<UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType, template <UInt8 precision, int max_rank, typename HashValueType, typename DenominatorType,
DenominatorMode denominator_mode> DenominatorMode denominator_mode>
class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType, class __attribute__ ((packed)) Denominator<precision, max_rank, HashValueType, DenominatorType,
denominator_mode, denominator_mode,

10
dbms/src/Common/PoolWithFailoverBase.h
View File

@ -137,7 +137,7 @@ protected:
Logger * log; Logger * log;
}; };
template<typename TNestedPool> template <typename TNestedPool>
typename TNestedPool::Entry typename TNestedPool::Entry
PoolWithFailoverBase<TNestedPool>::get(const TryGetEntryFunc & try_get_entry, const GetPriorityFunc & get_priority) PoolWithFailoverBase<TNestedPool>::get(const TryGetEntryFunc & try_get_entry, const GetPriorityFunc & get_priority)
{ {
@ -149,7 +149,7 @@ PoolWithFailoverBase<TNestedPool>::get(const TryGetEntryFunc & try_get_entry, co
return results[0].entry; return results[0].entry;
} }
template<typename TNestedPool> template <typename TNestedPool>
std::vector<typename PoolWithFailoverBase<TNestedPool>::TryResult> std::vector<typename PoolWithFailoverBase<TNestedPool>::TryResult>
PoolWithFailoverBase<TNestedPool>::getMany( PoolWithFailoverBase<TNestedPool>::getMany(
size_t min_entries, size_t max_entries, size_t min_entries, size_t max_entries,
@ -293,7 +293,7 @@ PoolWithFailoverBase<TNestedPool>::getMany(
return try_results; return try_results;
} }
template<typename TNestedPool> template <typename TNestedPool>
void PoolWithFailoverBase<TNestedPool>::reportError(const Entry & entry) void PoolWithFailoverBase<TNestedPool>::reportError(const Entry & entry)
{ {
for (size_t i = 0; i < nested_pools.size(); ++i) for (size_t i = 0; i < nested_pools.size(); ++i)
@ -308,7 +308,7 @@ void PoolWithFailoverBase<TNestedPool>::reportError(const Entry & entry)
throw DB::Exception("Can't find pool to report error."); throw DB::Exception("Can't find pool to report error.");
} }
template<typename TNestedPool> template <typename TNestedPool>
struct PoolWithFailoverBase<TNestedPool>::PoolState struct PoolWithFailoverBase<TNestedPool>::PoolState
{ {
UInt64 error_count = 0; UInt64 error_count = 0;
@ -330,7 +330,7 @@ private:
std::minstd_rand rng = std::minstd_rand(randomSeed()); std::minstd_rand rng = std::minstd_rand(randomSeed());
}; };
template<typename TNestedPool> template <typename TNestedPool>
typename PoolWithFailoverBase<TNestedPool>::PoolStates typename PoolWithFailoverBase<TNestedPool>::PoolStates
PoolWithFailoverBase<TNestedPool>::updatePoolStates() PoolWithFailoverBase<TNestedPool>::updatePoolStates()
{ {

2
dbms/src/Common/UInt128.h
View File

@ -50,7 +50,7 @@ struct UInt128
template <typename T> bool inline operator<= (const T rhs) const { return *this <= UInt128(rhs); } template <typename T> bool inline operator<= (const T rhs) const { return *this <= UInt128(rhs); }
template <typename T> bool inline operator< (const T rhs) const { return *this < UInt128(rhs); } template <typename T> bool inline operator< (const T rhs) const { return *this < UInt128(rhs); }
template<typename T> explicit operator T() const { return static_cast<T>(low); } template <typename T> explicit operator T() const { return static_cast<T>(low); }
#if !__clang__ #if !__clang__
#pragma GCC diagnostic pop #pragma GCC diagnostic pop

4
dbms/src/Common/ZooKeeper/ZooKeeperHolder.h
View File

@ -19,7 +19,7 @@ public:
ZooKeeperHolder() = default; ZooKeeperHolder() = default;
/// вызывать из одного потока - не thread safe /// вызывать из одного потока - не thread safe
template <class... Args> template <typename... Args>
void init(Args&&... args); void init(Args&&... args);
/// был ли класс инициализирован /// был ли класс инициализирован
bool isInitialized() const { return ptr != nullptr; } bool isInitialized() const { return ptr != nullptr; }
@ -75,7 +75,7 @@ private:
static std::string nullptr_exception_message; static std::string nullptr_exception_message;
}; };
template <class... Args> template <typename... Args>
void ZooKeeperHolder::init(Args&&... args) void ZooKeeperHolder::init(Args&&... args)
{ {
ptr = std::make_shared<ZooKeeper>(std::forward<Args>(args)...); ptr = std::make_shared<ZooKeeper>(std::forward<Args>(args)...);

6
dbms/src/Common/tests/AvalancheTest.h
View File

@ -38,7 +38,7 @@ inline uint32_t getbit ( const void * block, int len, uint32_t bit )
return 0; return 0;
} }
template< typename T > template < typename T >
inline uint32_t getbit ( T & blob, uint32_t bit ) inline uint32_t getbit ( T & blob, uint32_t bit )
{ {
return getbit(&blob,sizeof(blob),bit); return getbit(&blob,sizeof(blob),bit);
@ -54,7 +54,7 @@ inline void flipbit ( void * block, int len, uint32_t bit )
if(byte < len) b[byte] ^= (1 << bit); if(byte < len) b[byte] ^= (1 << bit);
} }
template< typename T > template < typename T >
inline void flipbit ( T & blob, uint32_t bit ) inline void flipbit ( T & blob, uint32_t bit )
{ {
flipbit(&blob,sizeof(blob),bit); flipbit(&blob,sizeof(blob),bit);
@ -146,7 +146,7 @@ bool AvalancheTest ( pfHash hash, const int reps )
// BIC test variant - store all intermediate data in a table, draw diagram // BIC test variant - store all intermediate data in a table, draw diagram
// afterwards (much faster) // afterwards (much faster)
template< typename keytype, typename hashtype > template < typename keytype, typename hashtype >
void BicTest3 ( pfHash hash, const int reps, bool verbose = true ) void BicTest3 ( pfHash hash, const int reps, bool verbose = true )
{ {
const int keybytes = sizeof(keytype); const int keybytes = sizeof(keytype);

156
dbms/src/Common/tests/hopscotch-map/src/hopscotch_hash.h
View File

@ -146,7 +146,7 @@ private:
* Grow the map by GrowthFactor::num/GrowthFactor::den and use a modulo to map a hash * Grow the map by GrowthFactor::num/GrowthFactor::den and use a modulo to map a hash
* to a bucket. Slower but it can be usefull if you want a slower growth. * to a bucket. Slower but it can be usefull if you want a slower growth.
*/ */
template<class GrowthFactor = std::ratio<3, 2>> template <typename GrowthFactor = std::ratio<3, 2>>
class mod_growth_policy { class mod_growth_policy {
public: public:
mod_growth_policy(std::size_t& min_bucket_count_in_out) { mod_growth_policy(std::size_t& min_bucket_count_in_out) {
@ -212,7 +212,7 @@ static constexpr const std::array<std::size_t, 39> PRIMES = {{
1610612741ul, 3221225473ul, 4294967291ul 1610612741ul, 3221225473ul, 4294967291ul
}}; }};
template<unsigned int IPrime> template <unsigned int IPrime>
static std::size_t mod(std::size_t hash) { return hash % PRIMES[IPrime]; } static std::size_t mod(std::size_t hash) { return hash % PRIMES[IPrime]; }
// MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for faster modulo as the // MOD_PRIME[iprime](hash) returns hash % PRIMES[iprime]. This table allows for faster modulo as the
@ -274,26 +274,26 @@ namespace detail_hopscotch_hash {
template<typename T> template <typename T>
struct make_void { struct make_void {
using type = void; using type = void;
}; };
template<typename T, typename = void> template <typename T, typename = void>
struct has_is_transparent : std::false_type { struct has_is_transparent : std::false_type {
}; };
template<typename T> template <typename T>
struct has_is_transparent<T, typename make_void<typename T::is_transparent>::type> : std::true_type { struct has_is_transparent<T, typename make_void<typename T::is_transparent>::type> : std::true_type {
}; };
template<typename T, typename = void> template <typename T, typename = void>
struct has_key_compare : std::false_type { struct has_key_compare : std::false_type {
}; };
template<typename T> template <typename T>
struct has_key_compare<T, typename make_void<typename T::key_compare>::type> : std::true_type { struct has_key_compare<T, typename make_void<typename T::key_compare>::type> : std::true_type {
}; };
@ -305,29 +305,29 @@ struct has_key_compare<T, typename make_void<typename T::key_compare>::type> : s
* smallest_type_for_min_bits::type returns the smallest type that can fit MinBits. * smallest_type_for_min_bits::type returns the smallest type that can fit MinBits.
*/ */
static const size_t SMALLEST_TYPE_MAX_BITS_SUPPORTED = 64; static const size_t SMALLEST_TYPE_MAX_BITS_SUPPORTED = 64;
template<unsigned int MinBits, typename Enable = void> template <unsigned int MinBits, typename Enable = void>
class smallest_type_for_min_bits { class smallest_type_for_min_bits {
}; };
template<unsigned int MinBits> template <unsigned int MinBits>
class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 0) && (MinBits <= 8)>::type> { class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 0) && (MinBits <= 8)>::type> {
public: public:
using type = std::uint_least8_t; using type = std::uint_least8_t;
}; };
template<unsigned int MinBits> template <unsigned int MinBits>
class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 8) && (MinBits <= 16)>::type> { class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 8) && (MinBits <= 16)>::type> {
public: public:
using type = std::uint_least16_t; using type = std::uint_least16_t;
}; };
template<unsigned int MinBits> template <unsigned int MinBits>
class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 16) && (MinBits <= 32)>::type> { class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 16) && (MinBits <= 32)>::type> {
public: public:
using type = std::uint_least32_t; using type = std::uint_least32_t;
}; };
template<unsigned int MinBits> template <unsigned int MinBits>
class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 32) && (MinBits <= 64)>::type> { class smallest_type_for_min_bits<MinBits, typename std::enable_if<(MinBits > 32) && (MinBits <= 64)>::type> {
public: public:
using type = std::uint_least64_t; using type = std::uint_least64_t;
@ -353,7 +353,7 @@ public:
static const std::size_t NB_RESERVED_BITS_IN_NEIGHBORHOOD = 2; static const std::size_t NB_RESERVED_BITS_IN_NEIGHBORHOOD = 2;
template<bool StoreHash> template <bool StoreHash>
class hopscotch_bucket_hash { class hopscotch_bucket_hash {
public: public:
using hash_type = std::false_type; using hash_type = std::false_type;
@ -375,7 +375,7 @@ protected:
} }
}; };
template<> template <>
class hopscotch_bucket_hash<true> { class hopscotch_bucket_hash<true> {
public: public:
using hash_type = std::uint_least32_t; using hash_type = std::uint_least32_t;
@ -402,7 +402,7 @@ private:
hash_type m_hash; hash_type m_hash;
}; };
template<typename ValueType, unsigned int NeighborhoodSize, bool StoreHash> template <typename ValueType, unsigned int NeighborhoodSize, bool StoreHash>
class hopscotch_bucket: public hopscotch_bucket_hash<StoreHash> { class hopscotch_bucket: public hopscotch_bucket_hash<StoreHash> {
private: private:
static const size_t MIN_NEIGHBORHOOD_SIZE = 4; static const size_t MIN_NEIGHBORHOOD_SIZE = 4;
@ -529,7 +529,7 @@ public:
return *reinterpret_cast<const value_type*>(std::addressof(m_value)); return *reinterpret_cast<const value_type*>(std::addressof(m_value));
} }
template<typename... Args> template <typename... Args>
void set_value_of_empty_bucket(std::size_t hash, Args&&... value_type_args) { void set_value_of_empty_bucket(std::size_t hash, Args&&... value_type_args) {
tsl_assert(empty()); tsl_assert(empty());
@ -617,7 +617,7 @@ private:
* OverflowContainer will be used as containers for overflown elements. Usually it should be a list<ValueType> * OverflowContainer will be used as containers for overflown elements. Usually it should be a list<ValueType>
* or a set<Key>/map<Key, T>. * or a set<Key>/map<Key, T>.
*/ */
template<class ValueType, template <typename ValueType,
class KeySelect, class KeySelect,
class ValueSelect, class ValueSelect,
class Hash, class Hash,
@ -629,11 +629,11 @@ template<class ValueType,
class OverflowContainer> class OverflowContainer>
class hopscotch_hash: private Hash, private KeyEqual, private GrowthPolicy { class hopscotch_hash: private Hash, private KeyEqual, private GrowthPolicy {
private: private:
template<typename U> template <typename U>
using has_mapped_type = typename std::integral_constant<bool, !std::is_same<U, void>::value>; using has_mapped_type = typename std::integral_constant<bool, !std::is_same<U, void>::value>;
public: public:
template<bool is_const> template <bool is_const>
class hopscotch_iterator; class hopscotch_iterator;
using key_type = typename KeySelect::key_type; using key_type = typename KeySelect::key_type;
@ -680,7 +680,7 @@ public:
* In case of a map, to get a modifiable reference to the value associated to a key (the '.second' in the * In case of a map, to get a modifiable reference to the value associated to a key (the '.second' in the
* stored pair), you have to call 'value()'. * stored pair), you have to call 'value()'.
*/ */
template<bool is_const> template <bool is_const>
class hopscotch_iterator { class hopscotch_iterator {
friend class hopscotch_hash; friend class hopscotch_hash;
private: private:
@ -724,7 +724,7 @@ public:
return KeySelect()(*m_overflow_iterator); return KeySelect()(*m_overflow_iterator);
} }
template<class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
typename std::conditional< typename std::conditional<
is_const, is_const,
const typename U::value_type&, const typename U::value_type&,
@ -791,7 +791,7 @@ public:
public: public:
template<class OC = OverflowContainer, typename std::enable_if<!has_key_compare<OC>::value>::type* = nullptr> template <typename OC = OverflowContainer, typename std::enable_if<!has_key_compare<OC>::value>::type* = nullptr>
hopscotch_hash(size_type bucket_count, hopscotch_hash(size_type bucket_count,
const Hash& hash, const Hash& hash,
const KeyEqual& equal, const KeyEqual& equal,
@ -814,7 +814,7 @@ public:
this->max_load_factor(max_load_factor); this->max_load_factor(max_load_factor);
} }
template<class OC = OverflowContainer, typename std::enable_if<has_key_compare<OC>::value>::type* = nullptr> template <typename OC = OverflowContainer, typename std::enable_if<has_key_compare<OC>::value>::type* = nullptr>
hopscotch_hash(size_type bucket_count, hopscotch_hash(size_type bucket_count,
const Hash& hash, const Hash& hash,
const KeyEqual& equal, const KeyEqual& equal,
@ -949,7 +949,7 @@ public:
return insert_impl(value); return insert_impl(value);
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
std::pair<iterator, bool> insert(P&& value) { std::pair<iterator, bool> insert(P&& value) {
return emplace(std::forward<P>(value)); return emplace(std::forward<P>(value));
} }
@ -967,7 +967,7 @@ public:
return insert(value).first; return insert(value).first;
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
iterator insert(const_iterator hint, P&& value) { iterator insert(const_iterator hint, P&& value) {
return emplace_hint(hint, std::forward<P>(value)); return emplace_hint(hint, std::forward<P>(value));
} }
@ -981,7 +981,7 @@ public:
} }
template<class InputIt> template <typename InputIt>
void insert(InputIt first, InputIt last) { void insert(InputIt first, InputIt last) {
if(std::is_base_of<std::forward_iterator_tag, if(std::is_base_of<std::forward_iterator_tag,
typename std::iterator_traits<InputIt>::iterator_category>::value) typename std::iterator_traits<InputIt>::iterator_category>::value)
@ -1003,18 +1003,18 @@ public:
} }
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) {
return insert_or_assign_impl(k, std::forward<M>(obj)); return insert_or_assign_impl(k, std::forward<M>(obj));
} }
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) {
return insert_or_assign_impl(std::move(k), std::forward<M>(obj)); return insert_or_assign_impl(std::move(k), std::forward<M>(obj));
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) { iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { if(hint != cend() && compare_keys(KeySelect()(*hint), k)) {
auto it = mutable_iterator(hint); auto it = mutable_iterator(hint);
@ -1026,7 +1026,7 @@ public:
return insert_or_assign(k, std::forward<M>(obj)).first; return insert_or_assign(k, std::forward<M>(obj)).first;
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) { iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { if(hint != cend() && compare_keys(KeySelect()(*hint), k)) {
auto it = mutable_iterator(hint); auto it = mutable_iterator(hint);
@ -1039,27 +1039,27 @@ public:
} }
template<class... Args> template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args) { std::pair<iterator, bool> emplace(Args&&... args) {
return insert(value_type(std::forward<Args>(args)...)); return insert(value_type(std::forward<Args>(args)...));
} }
template<class... Args> template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args) { iterator emplace_hint(const_iterator hint, Args&&... args) {
return insert(hint, value_type(std::forward<Args>(args)...)); return insert(hint, value_type(std::forward<Args>(args)...));
} }
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) {
return try_emplace_impl(k, std::forward<Args>(args)...); return try_emplace_impl(k, std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) { std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
return try_emplace_impl(std::move(k), std::forward<Args>(args)...); return try_emplace_impl(std::move(k), std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) { iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { if(hint != cend() && compare_keys(KeySelect()(*hint), k)) {
return mutable_iterator(hint); return mutable_iterator(hint);
@ -1068,7 +1068,7 @@ public:
return try_emplace(k, std::forward<Args>(args)...).first; return try_emplace(k, std::forward<Args>(args)...).first;
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) { iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
if(hint != cend() && compare_keys(KeySelect()(*hint), k)) { if(hint != cend() && compare_keys(KeySelect()(*hint), k)) {
return mutable_iterator(hint); return mutable_iterator(hint);
@ -1111,12 +1111,12 @@ public:
return to_delete; return to_delete;
} }
template<class K> template <typename K>
size_type erase(const K& key) { size_type erase(const K& key) {
return erase(key, hash_key(key)); return erase(key, hash_key(key));
} }
template<class K> template <typename K>
size_type erase(const K& key, std::size_t hash) { size_type erase(const K& key, std::size_t hash) {
const std::size_t ibucket_for_hash = bucket_for_hash(hash); const std::size_t ibucket_for_hash = bucket_for_hash(hash);
@ -1157,23 +1157,23 @@ public:
/* /*
* Lookup * Lookup
*/ */
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
typename U::value_type& at(const K& key) { typename U::value_type& at(const K& key) {
return at(key, hash_key(key)); return at(key, hash_key(key));
} }
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
typename U::value_type& at(const K& key, std::size_t hash) { typename U::value_type& at(const K& key, std::size_t hash) {
return const_cast<typename U::value_type&>(static_cast<const hopscotch_hash*>(this)->at(key, hash)); return const_cast<typename U::value_type&>(static_cast<const hopscotch_hash*>(this)->at(key, hash));
} }
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
const typename U::value_type& at(const K& key) const { const typename U::value_type& at(const K& key) const {
return at(key, hash_key(key)); return at(key, hash_key(key));
} }
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
const typename U::value_type& at(const K& key, std::size_t hash) const { const typename U::value_type& at(const K& key, std::size_t hash) const {
using T = typename U::value_type; using T = typename U::value_type;
@ -1187,7 +1187,7 @@ public:
} }
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
typename U::value_type& operator[](K&& key) { typename U::value_type& operator[](K&& key) {
using T = typename U::value_type; using T = typename U::value_type;
@ -1206,57 +1206,57 @@ public:
} }
template<class K> template <typename K>
size_type count(const K& key) const { size_type count(const K& key) const {
return count(key, hash_key(key)); return count(key, hash_key(key));
} }
template<class K> template <typename K>
size_type count(const K& key, std::size_t hash) const { size_type count(const K& key, std::size_t hash) const {
return count_impl(key, hash, m_buckets.cbegin() + bucket_for_hash(hash)); return count_impl(key, hash, m_buckets.cbegin() + bucket_for_hash(hash));
} }
template<class K> template <typename K>
iterator find(const K& key) { iterator find(const K& key) {
return find(key, hash_key(key)); return find(key, hash_key(key));
} }
template<class K> template <typename K>
iterator find(const K& key, std::size_t hash) { iterator find(const K& key, std::size_t hash) {
return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash)); return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash));
} }
template<class K> template <typename K>
const_iterator find(const K& key) const { const_iterator find(const K& key) const {
return find(key, hash_key(key)); return find(key, hash_key(key));
} }
template<class K> template <typename K>
const_iterator find(const K& key, std::size_t hash) const { const_iterator find(const K& key, std::size_t hash) const {
return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash)); return find_impl(key, hash, m_buckets.begin() + bucket_for_hash(hash));
} }
template<class K> template <typename K>
std::pair<iterator, iterator> equal_range(const K& key) { std::pair<iterator, iterator> equal_range(const K& key) {
return equal_range(key, hash_key(key)); return equal_range(key, hash_key(key));
} }
template<class K> template <typename K>
std::pair<iterator, iterator> equal_range(const K& key, std::size_t hash) { std::pair<iterator, iterator> equal_range(const K& key, std::size_t hash) {
iterator it = find(key, hash); iterator it = find(key, hash);
return std::make_pair(it, (it == end())?it:std::next(it)); return std::make_pair(it, (it == end())?it:std::next(it));
} }
template<class K> template <typename K>
std::pair<const_iterator, const_iterator> equal_range(const K& key) const { std::pair<const_iterator, const_iterator> equal_range(const K& key) const {
return equal_range(key, hash_key(key)); return equal_range(key, hash_key(key));
} }
template<class K> template <typename K>
std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t hash) const { std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t hash) const {
const_iterator it = find(key, hash); const_iterator it = find(key, hash);
return std::make_pair(it, (it == cend())?it:std::next(it)); return std::make_pair(it, (it == cend())?it:std::next(it));
@ -1339,19 +1339,19 @@ public:
return m_overflow_elements.size(); return m_overflow_elements.size();
} }
template<class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr> template <typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
typename U::key_compare key_comp() const { typename U::key_compare key_comp() const {
return m_overflow_elements.key_comp(); return m_overflow_elements.key_comp();
} }
private: private:
template<class K> template <typename K>
std::size_t hash_key(const K& key) const { std::size_t hash_key(const K& key) const {
return Hash::operator()(key); return Hash::operator()(key);
} }
template<class K1, class K2> template <typename K1, typename K2>
bool compare_keys(const K1& key1, const K2& key2) const { bool compare_keys(const K1& key1, const K2& key2) const {
return KeyEqual::operator()(key1, key2); return KeyEqual::operator()(key1, key2);
} }
@ -1365,7 +1365,7 @@ private:
std::is_copy_constructible<value_type>::value, std::is_copy_constructible<value_type>::value,
"value_type must be either copy constructible or nothrow move constructible."); "value_type must be either copy constructible or nothrow move constructible.");
template<typename U = value_type, template <typename U = value_type,
typename std::enable_if<std::is_nothrow_move_constructible<U>::value>::type* = nullptr> typename std::enable_if<std::is_nothrow_move_constructible<U>::value>::type* = nullptr>
void rehash_impl(size_type count) { void rehash_impl(size_type count) {
hopscotch_hash new_map = new_hopscotch_hash(count); hopscotch_hash new_map = new_hopscotch_hash(count);
@ -1425,7 +1425,7 @@ private:
new_map.swap(*this); new_map.swap(*this);
} }
template<typename U = value_type, template <typename U = value_type,
typename std::enable_if<std::is_copy_constructible<U>::value && typename std::enable_if<std::is_copy_constructible<U>::value &&
!std::is_nothrow_move_constructible<U>::value>::type* = nullptr> !std::is_nothrow_move_constructible<U>::value>::type* = nullptr>
void rehash_impl(size_type count) { void rehash_impl(size_type count) {
@ -1499,7 +1499,7 @@ private:
template<class K, class M> template <typename K, typename M>
std::pair<iterator, bool> insert_or_assign_impl(K&& key, M&& obj) { std::pair<iterator, bool> insert_or_assign_impl(K&& key, M&& obj) {
auto it = try_emplace_impl(std::forward<K>(key), std::forward<M>(obj)); auto it = try_emplace_impl(std::forward<K>(key), std::forward<M>(obj));
if(!it.second) { if(!it.second) {
@ -1509,7 +1509,7 @@ private:
return it; return it;
} }
template<typename P, class... Args> template <typename P, typename... Args>
std::pair<iterator, bool> try_emplace_impl(P&& key, Args&&... args_value) { std::pair<iterator, bool> try_emplace_impl(P&& key, Args&&... args_value) {
const std::size_t hash = hash_key(key); const std::size_t hash = hash_key(key);
const std::size_t ibucket_for_hash = bucket_for_hash(hash); const std::size_t ibucket_for_hash = bucket_for_hash(hash);
@ -1525,7 +1525,7 @@ private:
std::forward_as_tuple(std::forward<Args>(args_value)...)); std::forward_as_tuple(std::forward<Args>(args_value)...));
} }
template<typename P> template <typename P>
std::pair<iterator, bool> insert_impl(P&& value) { std::pair<iterator, bool> insert_impl(P&& value) {
const std::size_t hash = hash_key(KeySelect()(value)); const std::size_t hash = hash_key(KeySelect()(value));
const std::size_t ibucket_for_hash = bucket_for_hash(hash); const std::size_t ibucket_for_hash = bucket_for_hash(hash);
@ -1540,7 +1540,7 @@ private:
return insert_impl(ibucket_for_hash, hash, std::forward<P>(value)); return insert_impl(ibucket_for_hash, hash, std::forward<P>(value));
} }
template<typename... Args> template <typename... Args>
std::pair<iterator, bool> insert_impl(std::size_t ibucket_for_hash, std::size_t hash, Args&&... value_type_args) { std::pair<iterator, bool> insert_impl(std::size_t ibucket_for_hash, std::size_t hash, Args&&... value_type_args) {
if((m_nb_elements - m_overflow_elements.size()) >= m_load_threshold) { if((m_nb_elements - m_overflow_elements.size()) >= m_load_threshold) {
rehash(GrowthPolicy::next_bucket_count()); rehash(GrowthPolicy::next_bucket_count());
@ -1624,7 +1624,7 @@ private:
* *
* Return bucket iterator to ibucket_empty * Return bucket iterator to ibucket_empty
*/ */
template<typename... Args> template <typename... Args>
iterator_buckets insert_in_bucket(std::size_t ibucket_empty, std::size_t ibucket_for_hash, iterator_buckets insert_in_bucket(std::size_t ibucket_empty, std::size_t ibucket_for_hash,
std::size_t hash, Args&&... value_type_args) std::size_t hash, Args&&... value_type_args)
{ {
@ -1682,7 +1682,7 @@ private:
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
typename U::value_type* find_value_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) { typename U::value_type* find_value_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) {
return const_cast<typename U::value_type*>( return const_cast<typename U::value_type*>(
static_cast<const hopscotch_hash*>(this)->find_value_impl(key, hash, it_bucket)); static_cast<const hopscotch_hash*>(this)->find_value_impl(key, hash, it_bucket));
@ -1693,7 +1693,7 @@ private:
* *
* Return null if no value for key (TODO use std::optional when available). * Return null if no value for key (TODO use std::optional when available).
*/ */
template<class K, class U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr> template <typename K, typename U = ValueSelect, typename std::enable_if<has_mapped_type<U>::value>::type* = nullptr>
const typename U::value_type* find_value_impl(const K& key, std::size_t hash, const typename U::value_type* find_value_impl(const K& key, std::size_t hash,
const_iterator_buckets it_bucket) const const_iterator_buckets it_bucket) const
{ {
@ -1712,7 +1712,7 @@ private:
return nullptr; return nullptr;
} }
template<class K> template <typename K>
size_type count_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const { size_type count_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {
if(find_in_buckets(key, hash, it_bucket) != m_buckets.cend()) { if(find_in_buckets(key, hash, it_bucket) != m_buckets.cend()) {
return 1; return 1;
@ -1725,7 +1725,7 @@ private:
} }
} }
template<class K> template <typename K>
iterator find_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) { iterator find_impl(const K& key, std::size_t hash, iterator_buckets it_bucket) {
auto it = find_in_buckets(key, hash, it_bucket); auto it = find_in_buckets(key, hash, it_bucket);
if(it != m_buckets.end()) { if(it != m_buckets.end()) {
@ -1739,7 +1739,7 @@ private:
return iterator(m_buckets.end(), m_buckets.end(), find_in_overflow(key)); return iterator(m_buckets.end(), m_buckets.end(), find_in_overflow(key));
} }
template<class K> template <typename K>
const_iterator find_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const { const_iterator find_impl(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {
auto it = find_in_buckets(key, hash, it_bucket); auto it = find_in_buckets(key, hash, it_bucket);
if(it != m_buckets.cend()) { if(it != m_buckets.cend()) {
@ -1754,14 +1754,14 @@ private:
return const_iterator(m_buckets.cend(), m_buckets.cend(), find_in_overflow(key)); return const_iterator(m_buckets.cend(), m_buckets.cend(), find_in_overflow(key));
} }
template<class K> template <typename K>
iterator_buckets find_in_buckets(const K& key, std::size_t hash, iterator_buckets it_bucket) { iterator_buckets find_in_buckets(const K& key, std::size_t hash, iterator_buckets it_bucket) {
auto it_find = static_cast<const hopscotch_hash*>(this)->find_in_buckets(key, hash, it_bucket); auto it_find = static_cast<const hopscotch_hash*>(this)->find_in_buckets(key, hash, it_bucket);
return m_buckets.begin() + std::distance(m_buckets.cbegin(), it_find); return m_buckets.begin() + std::distance(m_buckets.cbegin(), it_find);
} }
template<class K> template <typename K>
const_iterator_buckets find_in_buckets(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const { const_iterator_buckets find_in_buckets(const K& key, std::size_t hash, const_iterator_buckets it_bucket) const {
(void) hash; // Avoid warning of unused variable when StoreHash is false; (void) hash; // Avoid warning of unused variable when StoreHash is false;
@ -1791,7 +1791,7 @@ private:
template<class K, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr> template <typename K, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
iterator_overflow find_in_overflow(const K& key) { iterator_overflow find_in_overflow(const K& key) {
return std::find_if(m_overflow_elements.begin(), m_overflow_elements.end(), return std::find_if(m_overflow_elements.begin(), m_overflow_elements.end(),
[&](const value_type& value) { [&](const value_type& value) {
@ -1799,7 +1799,7 @@ private:
}); });
} }
template<class K, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr> template <typename K, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
const_iterator_overflow find_in_overflow(const K& key) const { const_iterator_overflow find_in_overflow(const K& key) const {
return std::find_if(m_overflow_elements.cbegin(), m_overflow_elements.cend(), return std::find_if(m_overflow_elements.cbegin(), m_overflow_elements.cend(),
[&](const value_type& value) { [&](const value_type& value) {
@ -1807,37 +1807,37 @@ private:
}); });
} }
template<class K, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr> template <typename K, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
iterator_overflow find_in_overflow(const K& key) { iterator_overflow find_in_overflow(const K& key) {
return m_overflow_elements.find(key); return m_overflow_elements.find(key);
} }
template<class K, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr> template <typename K, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
const_iterator_overflow find_in_overflow(const K& key) const { const_iterator_overflow find_in_overflow(const K& key) const {
return m_overflow_elements.find(key); return m_overflow_elements.find(key);
} }
template<class... Args, class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr> template <typename... Args, typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
iterator_overflow insert_in_overflow(Args&&... value_type_args) { iterator_overflow insert_in_overflow(Args&&... value_type_args) {
return m_overflow_elements.emplace(m_overflow_elements.end(), std::forward<Args>(value_type_args)...); return m_overflow_elements.emplace(m_overflow_elements.end(), std::forward<Args>(value_type_args)...);
} }
template<class... Args, class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr> template <typename... Args, typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
iterator_overflow insert_in_overflow(Args&&... value_type_args) { iterator_overflow insert_in_overflow(Args&&... value_type_args) {
return m_overflow_elements.emplace(std::forward<Args>(value_type_args)...).first; return m_overflow_elements.emplace(std::forward<Args>(value_type_args)...).first;
} }
template<class U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr> template <typename U = OverflowContainer, typename std::enable_if<!has_key_compare<U>::value>::type* = nullptr>
hopscotch_hash new_hopscotch_hash(size_type bucket_count) { hopscotch_hash new_hopscotch_hash(size_type bucket_count) {
return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this), return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this),
get_allocator(), m_max_load_factor); get_allocator(), m_max_load_factor);
} }
template<class U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr> template <typename U = OverflowContainer, typename std::enable_if<has_key_compare<U>::value>::type* = nullptr>
hopscotch_hash new_hopscotch_hash(size_type bucket_count) { hopscotch_hash new_hopscotch_hash(size_type bucket_count) {
return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this), return hopscotch_hash(bucket_count, static_cast<Hash&>(*this), static_cast<KeyEqual&>(*this),
get_allocator(), m_max_load_factor, m_overflow_elements.key_comp()); get_allocator(), m_max_load_factor, m_overflow_elements.key_comp());

68
dbms/src/Common/tests/hopscotch-map/src/hopscotch_map.h
View File

@ -68,7 +68,7 @@ namespace tsl {
* insert will invalidate the iterators). Or if there is a rehash. * insert will invalidate the iterators). Or if there is a rehash.
* - erase: iterator on the erased element is the only one which become invalid. * - erase: iterator on the erased element is the only one which become invalid.
*/ */
template<class Key, template <typename Key,
class T, class T,
class Hash = std::hash<Key>, class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>, class KeyEqual = std::equal_to<Key>,
@ -78,7 +78,7 @@ template<class Key,
class GrowthPolicy = tsl::power_of_two_growth_policy> class GrowthPolicy = tsl::power_of_two_growth_policy>
class hopscotch_map { class hopscotch_map {
private: private:
template<typename U> template <typename U>
using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>; using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
class KeySelect { class KeySelect {
@ -161,7 +161,7 @@ public:
explicit hopscotch_map(const Allocator& alloc) : hopscotch_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) { explicit hopscotch_map(const Allocator& alloc) : hopscotch_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
} }
template<class InputIt> template <typename InputIt>
hopscotch_map(InputIt first, InputIt last, hopscotch_map(InputIt first, InputIt last,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE, size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash& hash = Hash(), const Hash& hash = Hash(),
@ -171,14 +171,14 @@ public:
insert(first, last); insert(first, last);
} }
template<class InputIt> template <typename InputIt>
hopscotch_map(InputIt first, InputIt last, hopscotch_map(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Allocator& alloc) : hopscotch_map(first, last, bucket_count, Hash(), KeyEqual(), alloc) const Allocator& alloc) : hopscotch_map(first, last, bucket_count, Hash(), KeyEqual(), alloc)
{ {
} }
template<class InputIt> template <typename InputIt>
hopscotch_map(InputIt first, InputIt last, hopscotch_map(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Hash& hash, const Hash& hash,
@ -254,7 +254,7 @@ public:
return m_ht.insert(value); return m_ht.insert(value);
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
std::pair<iterator, bool> insert(P&& value) { std::pair<iterator, bool> insert(P&& value) {
return m_ht.insert(std::forward<P>(value)); return m_ht.insert(std::forward<P>(value));
} }
@ -268,7 +268,7 @@ public:
return m_ht.insert(hint, value); return m_ht.insert(hint, value);
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
iterator insert(const_iterator hint, P&& value) { iterator insert(const_iterator hint, P&& value) {
return m_ht.insert(hint, std::forward<P>(value)); return m_ht.insert(hint, std::forward<P>(value));
} }
@ -278,7 +278,7 @@ public:
} }
template<class InputIt> template <typename InputIt>
void insert(InputIt first, InputIt last) { void insert(InputIt first, InputIt last) {
m_ht.insert(first, last); m_ht.insert(first, last);
} }
@ -290,22 +290,22 @@ public:
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) {
return m_ht.insert_or_assign(k, std::forward<M>(obj)); return m_ht.insert_or_assign(k, std::forward<M>(obj));
} }
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) {
return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj)); return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj));
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) { iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
return m_ht.insert_or_assign(hint, k, std::forward<M>(obj)); return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) { iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj)); return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
} }
@ -319,7 +319,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args) { std::pair<iterator, bool> emplace(Args&&... args) {
return m_ht.emplace(std::forward<Args>(args)...); return m_ht.emplace(std::forward<Args>(args)...);
} }
@ -333,7 +333,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args) { iterator emplace_hint(const_iterator hint, Args&&... args) {
return m_ht.emplace_hint(hint, std::forward<Args>(args)...); return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
} }
@ -341,22 +341,22 @@ public:
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) {
return m_ht.try_emplace(k, std::forward<Args>(args)...); return m_ht.try_emplace(k, std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) { std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...); return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) { iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
return m_ht.try_emplace(hint, k, std::forward<Args>(args)...); return m_ht.try_emplace(hint, k, std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) { iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...); return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...);
} }
@ -381,7 +381,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type erase(const K& key) { return m_ht.erase(key); } size_type erase(const K& key) { return m_ht.erase(key); }
/** /**
@ -390,7 +390,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type erase(const K& key, std::size_t precalculated_hash) { size_type erase(const K& key, std::size_t precalculated_hash) {
return m_ht.erase(key, precalculated_hash); return m_ht.erase(key, precalculated_hash);
} }
@ -424,7 +424,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
T& at(const K& key) { return m_ht.at(key); } T& at(const K& key) { return m_ht.at(key); }
/** /**
@ -433,20 +433,20 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); } T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); }
/** /**
* @copydoc at(const K& key) * @copydoc at(const K& key)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const T& at(const K& key) const { return m_ht.at(key); } const T& at(const K& key) const { return m_ht.at(key); }
/** /**
* @copydoc at(const K& key, std::size_t precalculated_hash) * @copydoc at(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); } const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); }
@ -472,7 +472,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type count(const K& key) const { return m_ht.count(key); } size_type count(const K& key) const { return m_ht.count(key); }
/** /**
@ -481,7 +481,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); } size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
@ -508,7 +508,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
iterator find(const K& key) { return m_ht.find(key); } iterator find(const K& key) { return m_ht.find(key); }
/** /**
@ -517,13 +517,13 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); } iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
/** /**
* @copydoc find(const K& key) * @copydoc find(const K& key)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const_iterator find(const K& key) const { return m_ht.find(key); } const_iterator find(const K& key) const { return m_ht.find(key); }
/** /**
@ -532,7 +532,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const_iterator find(const K& key, std::size_t precalculated_hash) const { const_iterator find(const K& key, std::size_t precalculated_hash) const {
return m_ht.find(key, precalculated_hash); return m_ht.find(key, precalculated_hash);
} }
@ -563,7 +563,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); } std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
@ -573,7 +573,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
} }
@ -581,13 +581,13 @@ public:
/** /**
* @copydoc equal_range(const K& key) * @copydoc equal_range(const K& key)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); } std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
/** /**
* @copydoc equal_range(const K& key, std::size_t precalculated_hash) * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
} }

68
dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_map.h
View File

@ -53,7 +53,7 @@ namespace tsl {
* *
* @copydoc hopscotch_map * @copydoc hopscotch_map
*/ */
template<class Key, template <typename Key,
class T, class T,
class Hash = std::hash<Key>, class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>, class KeyEqual = std::equal_to<Key>,
@ -64,7 +64,7 @@ template<class Key,
class GrowthPolicy = tsl::power_of_two_growth_policy> class GrowthPolicy = tsl::power_of_two_growth_policy>
class hopscotch_sc_map { class hopscotch_sc_map {
private: private:
template<typename U> template <typename U>
using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>; using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
class KeySelect { class KeySelect {
@ -150,7 +150,7 @@ public:
explicit hopscotch_sc_map(const Allocator& alloc) : hopscotch_sc_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) { explicit hopscotch_sc_map(const Allocator& alloc) : hopscotch_sc_map(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_map(InputIt first, InputIt last, hopscotch_sc_map(InputIt first, InputIt last,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE, size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash& hash = Hash(), const Hash& hash = Hash(),
@ -160,14 +160,14 @@ public:
insert(first, last); insert(first, last);
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_map(InputIt first, InputIt last, hopscotch_sc_map(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Allocator& alloc) : hopscotch_sc_map(first, last, bucket_count, Hash(), KeyEqual(), alloc) const Allocator& alloc) : hopscotch_sc_map(first, last, bucket_count, Hash(), KeyEqual(), alloc)
{ {
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_map(InputIt first, InputIt last, hopscotch_sc_map(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Hash& hash, const Hash& hash,
@ -243,7 +243,7 @@ public:
return m_ht.insert(value); return m_ht.insert(value);
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
std::pair<iterator, bool> insert(P&& value) { std::pair<iterator, bool> insert(P&& value) {
return m_ht.insert(std::forward<P>(value)); return m_ht.insert(std::forward<P>(value));
} }
@ -257,7 +257,7 @@ public:
return m_ht.insert(hint, value); return m_ht.insert(hint, value);
} }
template<class P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr> template <typename P, typename std::enable_if<std::is_constructible<value_type, P&&>::value>::type* = nullptr>
iterator insert(const_iterator hint, P&& value) { iterator insert(const_iterator hint, P&& value) {
return m_ht.insert(hint, std::forward<P>(value)); return m_ht.insert(hint, std::forward<P>(value));
} }
@ -267,7 +267,7 @@ public:
} }
template<class InputIt> template <typename InputIt>
void insert(InputIt first, InputIt last) { void insert(InputIt first, InputIt last) {
m_ht.insert(first, last); m_ht.insert(first, last);
} }
@ -279,22 +279,22 @@ public:
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj) {
return m_ht.insert_or_assign(k, std::forward<M>(obj)); return m_ht.insert_or_assign(k, std::forward<M>(obj));
} }
template<class M> template <typename M>
std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) { std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj) {
return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj)); return m_ht.insert_or_assign(std::move(k), std::forward<M>(obj));
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) { iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj) {
return m_ht.insert_or_assign(hint, k, std::forward<M>(obj)); return m_ht.insert_or_assign(hint, k, std::forward<M>(obj));
} }
template<class M> template <typename M>
iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) { iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj) {
return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj)); return m_ht.insert_or_assign(hint, std::move(k), std::forward<M>(obj));
} }
@ -307,7 +307,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args) { std::pair<iterator, bool> emplace(Args&&... args) {
return m_ht.emplace(std::forward<Args>(args)...); return m_ht.emplace(std::forward<Args>(args)...);
} }
@ -321,7 +321,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args) { iterator emplace_hint(const_iterator hint, Args&&... args) {
return m_ht.emplace_hint(hint, std::forward<Args>(args)...); return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
} }
@ -329,22 +329,22 @@ public:
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) { std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args) {
return m_ht.try_emplace(k, std::forward<Args>(args)...); return m_ht.try_emplace(k, std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) { std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args) {
return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...); return m_ht.try_emplace(std::move(k), std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) { iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args) {
return m_ht.try_emplace(hint, k, std::forward<Args>(args)...); return m_ht.try_emplace(hint, k, std::forward<Args>(args)...);
} }
template<class... Args> template <typename... Args>
iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) { iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args) {
return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...); return m_ht.try_emplace(hint, std::move(k), std::forward<Args>(args)...);
} }
@ -370,7 +370,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type erase(const K& key) { return m_ht.erase(key); } size_type erase(const K& key) { return m_ht.erase(key); }
@ -380,7 +380,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); } size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
@ -412,7 +412,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
T& at(const K& key) { return m_ht.at(key); } T& at(const K& key) { return m_ht.at(key); }
@ -422,21 +422,21 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); } T& at(const K& key, std::size_t precalculated_hash) { return m_ht.at(key, precalculated_hash); }
/** /**
* @copydoc at(const K& key) * @copydoc at(const K& key)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const T& at(const K& key) const { return m_ht.at(key); } const T& at(const K& key) const { return m_ht.at(key); }
/** /**
* @copydoc at(const K& key, std::size_t precalculated_hash) * @copydoc at(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); } const T& at(const K& key, std::size_t precalculated_hash) const { return m_ht.at(key, precalculated_hash); }
@ -462,7 +462,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type count(const K& key) const { return m_ht.count(key); } size_type count(const K& key) const { return m_ht.count(key); }
@ -472,7 +472,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); } size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
@ -499,7 +499,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
iterator find(const K& key) { return m_ht.find(key); } iterator find(const K& key) { return m_ht.find(key); }
@ -509,21 +509,21 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); } iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
/** /**
* @copydoc find(const K& key) * @copydoc find(const K& key)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const_iterator find(const K& key) const { return m_ht.find(key); } const_iterator find(const K& key) const { return m_ht.find(key); }
/** /**
* @copydoc find(const K& key, std::size_t precalculated_hash) * @copydoc find(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); } const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
@ -554,7 +554,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); } std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
@ -564,7 +564,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
@ -573,14 +573,14 @@ public:
/** /**
* @copydoc equal_range(const K& key) * @copydoc equal_range(const K& key)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); } std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
/** /**
* @copydoc equal_range(const K& key, std::size_t precalculated_hash) * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);

40
dbms/src/Common/tests/hopscotch-map/src/hopscotch_sc_set.h
View File

@ -53,7 +53,7 @@ namespace tsl {
* *
* @copydoc hopscotch_set * @copydoc hopscotch_set
*/ */
template<class Key, template <typename Key,
class Hash = std::hash<Key>, class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>, class KeyEqual = std::equal_to<Key>,
class Compare = std::less<Key>, class Compare = std::less<Key>,
@ -63,7 +63,7 @@ template<class Key,
class GrowthPolicy = tsl::power_of_two_growth_policy> class GrowthPolicy = tsl::power_of_two_growth_policy>
class hopscotch_sc_set { class hopscotch_sc_set {
private: private:
template<typename U> template <typename U>
using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>; using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
class KeySelect { class KeySelect {
@ -133,7 +133,7 @@ public:
explicit hopscotch_sc_set(const Allocator& alloc) : hopscotch_sc_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) { explicit hopscotch_sc_set(const Allocator& alloc) : hopscotch_sc_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_set(InputIt first, InputIt last, hopscotch_sc_set(InputIt first, InputIt last,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE, size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash& hash = Hash(), const Hash& hash = Hash(),
@ -143,14 +143,14 @@ public:
insert(first, last); insert(first, last);
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_set(InputIt first, InputIt last, hopscotch_sc_set(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Allocator& alloc) : hopscotch_sc_set(first, last, bucket_count, Hash(), KeyEqual(), alloc) const Allocator& alloc) : hopscotch_sc_set(first, last, bucket_count, Hash(), KeyEqual(), alloc)
{ {
} }
template<class InputIt> template <typename InputIt>
hopscotch_sc_set(InputIt first, InputIt last, hopscotch_sc_set(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Hash& hash, const Hash& hash,
@ -228,7 +228,7 @@ public:
iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); } iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); }
iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); } iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); }
template<class InputIt> template <typename InputIt>
void insert(InputIt first, InputIt last) { m_ht.insert(first, last); } void insert(InputIt first, InputIt last) { m_ht.insert(first, last); }
void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); } void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); }
@ -241,7 +241,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); } std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); }
@ -253,7 +253,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args) { iterator emplace_hint(const_iterator hint, Args&&... args) {
return m_ht.emplace_hint(hint, std::forward<Args>(args)...); return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
} }
@ -279,7 +279,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type erase(const K& key) { return m_ht.erase(key); } size_type erase(const K& key) { return m_ht.erase(key); }
@ -289,7 +289,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); } size_type erase(const K& key, std::size_t precalculated_hash) { return m_ht.erase(key, precalculated_hash); }
@ -315,7 +315,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type count(const K& key) const { return m_ht.count(key); } size_type count(const K& key) const { return m_ht.count(key); }
@ -325,7 +325,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); } size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
@ -352,7 +352,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
iterator find(const K& key) { return m_ht.find(key); } iterator find(const K& key) { return m_ht.find(key); }
@ -362,14 +362,14 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); } iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
/** /**
* @copydoc find(const K& key) * @copydoc find(const K& key)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const_iterator find(const K& key) const { return m_ht.find(key); } const_iterator find(const K& key) const { return m_ht.find(key); }
@ -379,7 +379,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); } const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
@ -410,7 +410,7 @@ public:
* and Compare::is_transparent exist. * and Compare::is_transparent exist.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); } std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
@ -420,7 +420,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
@ -429,14 +429,14 @@ public:
/** /**
* @copydoc equal_range(const K& key) * @copydoc equal_range(const K& key)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); } std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
/** /**
* @copydoc equal_range(const K& key, std::size_t precalculated_hash) * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, class CP = Compare, template <typename K, typename KE = KeyEqual, typename CP = Compare,
typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr> typename std::enable_if<has_is_transparent<KE>::value && has_is_transparent<CP>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);

40
dbms/src/Common/tests/hopscotch-map/src/hopscotch_set.h
View File

@ -68,7 +68,7 @@ namespace tsl {
* insert will invalidate the iterators). Or if there is a rehash. * insert will invalidate the iterators). Or if there is a rehash.
* - erase: iterator on the erased element is the only one which become invalid. * - erase: iterator on the erased element is the only one which become invalid.
*/ */
template<class Key, template <typename Key,
class Hash = std::hash<Key>, class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>, class KeyEqual = std::equal_to<Key>,
class Allocator = std::allocator<Key>, class Allocator = std::allocator<Key>,
@ -77,7 +77,7 @@ template<class Key,
class GrowthPolicy = tsl::power_of_two_growth_policy> class GrowthPolicy = tsl::power_of_two_growth_policy>
class hopscotch_set { class hopscotch_set {
private: private:
template<typename U> template <typename U>
using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>; using has_is_transparent = tsl::detail_hopscotch_hash::has_is_transparent<U>;
class KeySelect { class KeySelect {
@ -145,7 +145,7 @@ public:
explicit hopscotch_set(const Allocator& alloc) : hopscotch_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) { explicit hopscotch_set(const Allocator& alloc) : hopscotch_set(ht::DEFAULT_INIT_BUCKETS_SIZE, alloc) {
} }
template<class InputIt> template <typename InputIt>
hopscotch_set(InputIt first, InputIt last, hopscotch_set(InputIt first, InputIt last,
size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE, size_type bucket_count = ht::DEFAULT_INIT_BUCKETS_SIZE,
const Hash& hash = Hash(), const Hash& hash = Hash(),
@ -155,14 +155,14 @@ public:
insert(first, last); insert(first, last);
} }
template<class InputIt> template <typename InputIt>
hopscotch_set(InputIt first, InputIt last, hopscotch_set(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Allocator& alloc) : hopscotch_set(first, last, bucket_count, Hash(), KeyEqual(), alloc) const Allocator& alloc) : hopscotch_set(first, last, bucket_count, Hash(), KeyEqual(), alloc)
{ {
} }
template<class InputIt> template <typename InputIt>
hopscotch_set(InputIt first, InputIt last, hopscotch_set(InputIt first, InputIt last,
size_type bucket_count, size_type bucket_count,
const Hash& hash, const Hash& hash,
@ -240,7 +240,7 @@ public:
iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); } iterator insert(const_iterator hint, const value_type& value) { return m_ht.insert(hint, value); }
iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); } iterator insert(const_iterator hint, value_type&& value) { return m_ht.insert(hint, std::move(value)); }
template<class InputIt> template <typename InputIt>
void insert(InputIt first, InputIt last) { m_ht.insert(first, last); } void insert(InputIt first, InputIt last) { m_ht.insert(first, last); }
void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); } void insert(std::initializer_list<value_type> ilist) { m_ht.insert(ilist.begin(), ilist.end()); }
@ -253,7 +253,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); } std::pair<iterator, bool> emplace(Args&&... args) { return m_ht.emplace(std::forward<Args>(args)...); }
@ -265,7 +265,7 @@ public:
* *
* Mainly here for compatibility with the std::unordered_map interface. * Mainly here for compatibility with the std::unordered_map interface.
*/ */
template<class... Args> template <typename... Args>
iterator emplace_hint(const_iterator hint, Args&&... args) { iterator emplace_hint(const_iterator hint, Args&&... args) {
return m_ht.emplace_hint(hint, std::forward<Args>(args)...); return m_ht.emplace_hint(hint, std::forward<Args>(args)...);
} }
@ -290,7 +290,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type erase(const K& key) { return m_ht.erase(key); } size_type erase(const K& key) { return m_ht.erase(key); }
/** /**
@ -299,7 +299,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup to the value if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type erase(const K& key, std::size_t precalculated_hash) { size_type erase(const K& key, std::size_t precalculated_hash) {
return m_ht.erase(key, precalculated_hash); return m_ht.erase(key, precalculated_hash);
} }
@ -325,7 +325,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type count(const K& key) const { return m_ht.count(key); } size_type count(const K& key) const { return m_ht.count(key); }
/** /**
@ -334,7 +334,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); } size_type count(const K& key, std::size_t precalculated_hash) const { return m_ht.count(key, precalculated_hash); }
@ -359,7 +359,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
iterator find(const K& key) { return m_ht.find(key); } iterator find(const K& key) { return m_ht.find(key); }
/** /**
@ -368,13 +368,13 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); } iterator find(const K& key, std::size_t precalculated_hash) { return m_ht.find(key, precalculated_hash); }
/** /**
* @copydoc find(const K& key) * @copydoc find(const K& key)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const_iterator find(const K& key) const { return m_ht.find(key); } const_iterator find(const K& key) const { return m_ht.find(key); }
/** /**
@ -383,7 +383,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); } const_iterator find(const K& key, std::size_t precalculated_hash) const { return m_ht.find(key, precalculated_hash); }
@ -412,7 +412,7 @@ public:
* This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists. * This overload only participates in the overload resolution if the typedef KeyEqual::is_transparent exists.
* If so, K must be hashable and comparable to Key. * If so, K must be hashable and comparable to Key.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); } std::pair<iterator, iterator> equal_range(const K& key) { return m_ht.equal_range(key); }
/** /**
@ -421,7 +421,7 @@ public:
* Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same * Use the hash value 'precalculated_hash' instead of hashing the key. The hash value should be the same
* as hash_function()(key). Usefull to speed-up the lookup if you already have the hash. * as hash_function()(key). Usefull to speed-up the lookup if you already have the hash.
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) { std::pair<iterator, iterator> equal_range(const K& key, std::size_t precalculated_hash) {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
} }
@ -429,13 +429,13 @@ public:
/** /**
* @copydoc equal_range(const K& key) * @copydoc equal_range(const K& key)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); } std::pair<const_iterator, const_iterator> equal_range(const K& key) const { return m_ht.equal_range(key); }
/** /**
* @copydoc equal_range(const K& key, std::size_t precalculated_hash) * @copydoc equal_range(const K& key, std::size_t precalculated_hash)
*/ */
template<class K, class KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr> template <typename K, typename KE = KeyEqual, typename std::enable_if<has_is_transparent<KE>::value>::type* = nullptr>
std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const { std::pair<const_iterator, const_iterator> equal_range(const K& key, std::size_t precalculated_hash) const {
return m_ht.equal_range(key, precalculated_hash); return m_ht.equal_range(key, precalculated_hash);
} }

48
dbms/src/Core/AccurateComparison.h
View File

@ -161,7 +161,7 @@ inline bool_if_safe_conversion<A, B> greaterOp(A a, B b)
constexpr DB::Int64 MAX_INT64_WITH_EXACT_FLOAT64_REPR = 9007199254740992LL; // 2^53 constexpr DB::Int64 MAX_INT64_WITH_EXACT_FLOAT64_REPR = 9007199254740992LL; // 2^53
template<> template <>
inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i) inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i)
{ {
if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR) if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
@ -171,7 +171,7 @@ inline bool greaterOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 i)
|| (f > static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::min()) && static_cast<DB::Int64>(f) > i); || (f > static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::min()) && static_cast<DB::Int64>(f) > i);
} }
template<> template <>
inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f) inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f)
{ {
if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR) if (-MAX_INT64_WITH_EXACT_FLOAT64_REPR <= i && i <= MAX_INT64_WITH_EXACT_FLOAT64_REPR)
@ -181,7 +181,7 @@ inline bool greaterOp<DB::Int64, DB::Float64>(DB::Int64 i, DB::Float64 f)
|| (f < static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::max()) && i > static_cast<DB::Int64>(f)); || (f < static_cast<DB::Float64>(std::numeric_limits<DB::Int64>::max()) && i > static_cast<DB::Int64>(f));
} }
template<> template <>
inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u) inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
{ {
if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR)) if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
@ -191,7 +191,7 @@ inline bool greaterOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
|| (f >= 0 && static_cast<DB::UInt64>(f) > u); || (f >= 0 && static_cast<DB::UInt64>(f) > u);
} }
template<> template <>
inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f) inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
{ {
if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR)) if (u <= static_cast<DB::UInt64>(MAX_INT64_WITH_EXACT_FLOAT64_REPR))
@ -202,49 +202,49 @@ inline bool greaterOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
} }
// Case 3b for float32 // Case 3b for float32
template<> template <>
inline bool greaterOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 i) inline bool greaterOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 i)
{ {
return greaterOp(static_cast<DB::Float64>(f), i); return greaterOp(static_cast<DB::Float64>(f), i);
} }
template<> template <>
inline bool greaterOp<DB::Int64, DB::Float32>(DB::Int64 i, DB::Float32 f) inline bool greaterOp<DB::Int64, DB::Float32>(DB::Int64 i, DB::Float32 f)
{ {
return greaterOp(i, static_cast<DB::Float64>(f)); return greaterOp(i, static_cast<DB::Float64>(f));
} }
template<> template <>
inline bool greaterOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u) inline bool greaterOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
{ {
return greaterOp(static_cast<DB::Float64>(f), u); return greaterOp(static_cast<DB::Float64>(f), u);
} }
template<> template <>
inline bool greaterOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f) inline bool greaterOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
{ {
return greaterOp(u, static_cast<DB::Float64>(f)); return greaterOp(u, static_cast<DB::Float64>(f));
} }
template<> template <>
inline bool greaterOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u) inline bool greaterOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
{ {
return u.low == 0 && greaterOp(f, u.high); return u.low == 0 && greaterOp(f, u.high);
} }
template<> template <>
inline bool greaterOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f) inline bool greaterOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
{ {
return u.low != 0 || greaterOp(u.high, f); return u.low != 0 || greaterOp(u.high, f);
} }
template<> template <>
inline bool greaterOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u) inline bool greaterOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
{ {
return greaterOp(static_cast<DB::Float64>(f), u); return greaterOp(static_cast<DB::Float64>(f), u);
} }
template<> template <>
inline bool greaterOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f) inline bool greaterOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
{ {
return greaterOp(u, static_cast<DB::Float64>(f)); return greaterOp(u, static_cast<DB::Float64>(f));
@ -262,73 +262,73 @@ inline bool_if_safe_conversion<A, B> equalsOp(A a, B b)
return a == b; return a == b;
} }
template<> template <>
inline bool equalsOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u) inline bool equalsOp<DB::Float64, DB::UInt64>(DB::Float64 f, DB::UInt64 u)
{ {
return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float64>(u); return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float64>(u);
} }
template<> template <>
inline bool equalsOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f) inline bool equalsOp<DB::UInt64, DB::Float64>(DB::UInt64 u, DB::Float64 f)
{ {
return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float64>(u) == f; return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float64>(u) == f;
} }
template<> template <>
inline bool equalsOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 u) inline bool equalsOp<DB::Float64, DB::Int64>(DB::Float64 f, DB::Int64 u)
{ {
return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float64>(u); return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float64>(u);
} }
template<> template <>
inline bool equalsOp<DB::Int64, DB::Float64>(DB::Int64 u, DB::Float64 f) inline bool equalsOp<DB::Int64, DB::Float64>(DB::Int64 u, DB::Float64 f)
{ {
return u == static_cast<DB::Int64>(f) && static_cast<DB::Float64>(u) == f; return u == static_cast<DB::Int64>(f) && static_cast<DB::Float64>(u) == f;
} }
template<> template <>
inline bool equalsOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u) inline bool equalsOp<DB::Float32, DB::UInt64>(DB::Float32 f, DB::UInt64 u)
{ {
return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float32>(u); return static_cast<DB::UInt64>(f) == u && f == static_cast<DB::Float32>(u);
} }
template<> template <>
inline bool equalsOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f) inline bool equalsOp<DB::UInt64, DB::Float32>(DB::UInt64 u, DB::Float32 f)
{ {
return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float32>(u) == f; return u == static_cast<DB::UInt64>(f) && static_cast<DB::Float32>(u) == f;
} }
template<> template <>
inline bool equalsOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 u) inline bool equalsOp<DB::Float32, DB::Int64>(DB::Float32 f, DB::Int64 u)
{ {
return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float32>(u); return static_cast<DB::Int64>(f) == u && f == static_cast<DB::Float32>(u);
} }
template<> template <>
inline bool equalsOp<DB::Int64, DB::Float32>(DB::Int64 u, DB::Float32 f) inline bool equalsOp<DB::Int64, DB::Float32>(DB::Int64 u, DB::Float32 f)
{ {
return u == static_cast<DB::Int64>(f) && static_cast<DB::Float32>(u) == f; return u == static_cast<DB::Int64>(f) && static_cast<DB::Float32>(u) == f;
} }
template<> template <>
inline bool equalsOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f) inline bool equalsOp<DB::UInt128, DB::Float64>(DB::UInt128 u, DB::Float64 f)
{ {
return u.low == 0 && equalsOp(static_cast<UInt64>(u.high), f); return u.low == 0 && equalsOp(static_cast<UInt64>(u.high), f);
} }
template<> template <>
inline bool equalsOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f) inline bool equalsOp<DB::UInt128, DB::Float32>(DB::UInt128 u, DB::Float32 f)
{ {
return equalsOp(u, static_cast<DB::Float64>(f)); return equalsOp(u, static_cast<DB::Float64>(f));
} }
template<> template <>
inline bool equalsOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u) inline bool equalsOp<DB::Float64, DB::UInt128>(DB::Float64 f, DB::UInt128 u)
{ {
return equalsOp(u, f); return equalsOp(u, f);
} }
template<> template <>
inline bool equalsOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u) inline bool equalsOp<DB::Float32, DB::UInt128>(DB::Float32 f, DB::UInt128 u)
{ {
return equalsOp(static_cast<DB::Float64>(f), u); return equalsOp(static_cast<DB::Float64>(f), u);

2
dbms/src/Core/QualifiedTableName.h
View File

@ -36,7 +36,7 @@ struct QualifiedTableName
namespace std namespace std
{ {
template<> struct hash<DB::QualifiedTableName> template <> struct hash<DB::QualifiedTableName>
{ {
using argument_type = DB::QualifiedTableName; using argument_type = DB::QualifiedTableName;
using result_type = size_t; using result_type = size_t;

4
dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp
View File

@ -68,7 +68,7 @@ Block AggregatingSortedBlockInputStream::readImpl()
} }
template<class TSortCursor> template <typename TSortCursor>
void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue) void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
{ {
size_t merged_rows = 0; size_t merged_rows = 0;
@ -133,7 +133,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns,
} }
template <class TSortCursor> template <typename TSortCursor>
void AggregatingSortedBlockInputStream::addRow(TSortCursor & cursor) void AggregatingSortedBlockInputStream::addRow(TSortCursor & cursor)
{ {
for (size_t i = 0, size = column_numbers_to_aggregate.size(); i < size; ++i) for (size_t i = 0, size = column_numbers_to_aggregate.size(); i < size; ++i)

4
dbms/src/DataStreams/AggregatingSortedBlockInputStream.h
View File

@ -70,12 +70,12 @@ private:
/** We support two different cursors - with Collation and without. /** We support two different cursors - with Collation and without.
* Templates are used instead of polymorphic SortCursor and calls to virtual functions. * Templates are used instead of polymorphic SortCursor and calls to virtual functions.
*/ */
template <class TSortCursor> template <typename TSortCursor>
void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue); void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
/** Extract all states of aggregate functions and merge them with the current group. /** Extract all states of aggregate functions and merge them with the current group.
*/ */
template <class TSortCursor> template <typename TSortCursor>
void addRow(TSortCursor & cursor); void addRow(TSortCursor & cursor);
}; };

2
dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp
View File

@ -136,7 +136,7 @@ Block CollapsingSortedBlockInputStream::readImpl()
} }
template<class TSortCursor> template <typename TSortCursor>
void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue) void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
{ {
size_t merged_rows = 0; size_t merged_rows = 0;

2
dbms/src/DataStreams/CollapsingSortedBlockInputStream.h
View File

@ -90,7 +90,7 @@ private:
/** We support two different cursors - with Collation and without. /** We support two different cursors - with Collation and without.
* Templates are used instead of polymorphic SortCursors and calls to virtual functions. * Templates are used instead of polymorphic SortCursors and calls to virtual functions.
*/ */
template<class TSortCursor> template <typename TSortCursor>
void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue); void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
/// Output to result rows for the current primary key. /// Output to result rows for the current primary key.

4
dbms/src/DataStreams/ColumnGathererStream.h
View File

@ -68,7 +68,7 @@ public:
void readSuffixImpl() override; void readSuffixImpl() override;
/// for use in implementations of IColumn::gather() /// for use in implementations of IColumn::gather()
template<typename Column> template <typename Column>
void gather(Column & column_res); void gather(Column & column_res);
private: private:
@ -110,7 +110,7 @@ private:
Poco::Logger * log; Poco::Logger * log;
}; };
template<typename Column> template <typename Column>
void ColumnGathererStream::gather(Column & column_res) void ColumnGathererStream::gather(Column & column_res)
{ {
if (source_to_fully_copy) /// Was set on a previous iteration if (source_to_fully_copy) /// Was set on a previous iteration

2
dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp
View File

@ -218,7 +218,7 @@ void GraphiteRollupSortedBlockInputStream::merge(ColumnPlainPtrs & merged_column
} }
template <class TSortCursor> template <typename TSortCursor>
void GraphiteRollupSortedBlockInputStream::startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern) void GraphiteRollupSortedBlockInputStream::startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern)
{ {
/// Copy unmodified column values. /// Copy unmodified column values.

2
dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.h
View File

@ -199,7 +199,7 @@ private:
void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue); void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
/// Insert the values into the resulting columns, which will not be changed in the future. /// Insert the values into the resulting columns, which will not be changed in the future.
template <class TSortCursor> template <typename TSortCursor>
void startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern); void startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor, const Graphite::Pattern * next_pattern);
/// Insert the calculated `time`, `value`, `version` values into the resulting columns by the last group of rows. /// Insert the calculated `time`, `value`, `version` values into the resulting columns by the last group of rows.

6
dbms/src/DataStreams/MergingSortedBlockInputStream.h
View File

@ -153,7 +153,7 @@ protected:
/// These methods are used in Collapsing/Summing/Aggregating... SortedBlockInputStream-s. /// These methods are used in Collapsing/Summing/Aggregating... SortedBlockInputStream-s.
/// Save the row pointed to by cursor in `row`. /// Save the row pointed to by cursor in `row`.
template <class TSortCursor> template <typename TSortCursor>
void setRow(Row & row, TSortCursor & cursor) void setRow(Row & row, TSortCursor & cursor)
{ {
for (size_t i = 0; i < num_columns; ++i) for (size_t i = 0; i < num_columns; ++i)
@ -185,7 +185,7 @@ protected:
} }
} }
template <class TSortCursor> template <typename TSortCursor>
void setRowRef(RowRef & row_ref, TSortCursor & cursor) void setRowRef(RowRef & row_ref, TSortCursor & cursor)
{ {
row_ref.row_num = cursor.impl->pos; row_ref.row_num = cursor.impl->pos;
@ -195,7 +195,7 @@ protected:
row_ref.columns[i] = cursor->all_columns[i]; row_ref.columns[i] = cursor->all_columns[i];
} }
template <class TSortCursor> template <typename TSortCursor>
void setPrimaryKeyRef(RowRef & row_ref, TSortCursor & cursor) void setPrimaryKeyRef(RowRef & row_ref, TSortCursor & cursor)
{ {
row_ref.row_num = cursor.impl->pos; row_ref.row_num = cursor.impl->pos;

2
dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp
View File

@ -58,7 +58,7 @@ Block ReplacingSortedBlockInputStream::readImpl()
} }
template<class TSortCursor> template <typename TSortCursor>
void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue) void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
{ {
size_t merged_rows = 0; size_t merged_rows = 0;

2
dbms/src/DataStreams/ReplacingSortedBlockInputStream.h
View File

@ -63,7 +63,7 @@ private:
PODArray<RowSourcePart> current_row_sources; /// Sources of rows with the current primary key PODArray<RowSourcePart> current_row_sources; /// Sources of rows with the current primary key
template<class TSortCursor> template <typename TSortCursor>
void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue); void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
/// Output into result the rows for current primary key. /// Output into result the rows for current primary key.

8
dbms/src/DataStreams/SummingSortedBlockInputStream.cpp
View File

@ -176,7 +176,7 @@ Block SummingSortedBlockInputStream::readImpl()
} }
template <class TSortCursor> template <typename TSortCursor>
void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue) void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue)
{ {
size_t merged_rows = 0; size_t merged_rows = 0;
@ -269,7 +269,7 @@ public:
}; };
template <class TSortCursor> template <typename TSortCursor>
bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor) bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor)
{ {
bool non_empty_map_present = false; bool non_empty_map_present = false;
@ -283,7 +283,7 @@ bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor)
} }
template <class TSortCursor> template <typename TSortCursor>
bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row & row, TSortCursor & cursor) bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row & row, TSortCursor & cursor)
{ {
/// Strongly non-optimal. /// Strongly non-optimal.
@ -367,7 +367,7 @@ bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row &
} }
template <class TSortCursor> template <typename TSortCursor>
bool SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor) bool SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor)
{ {
bool res = mergeMaps(row, cursor); /// Is there at least one non-zero number or non-empty array bool res = mergeMaps(row, cursor); /// Is there at least one non-zero number or non-empty array

8
dbms/src/DataStreams/SummingSortedBlockInputStream.h
View File

@ -90,7 +90,7 @@ private:
/** We support two different cursors - with Collation and without. /** We support two different cursors - with Collation and without.
* Templates are used instead of polymorphic SortCursor and calls to virtual functions. * Templates are used instead of polymorphic SortCursor and calls to virtual functions.
*/ */
template <class TSortCursor> template <typename TSortCursor>
void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue); void merge(ColumnPlainPtrs & merged_columns, std::priority_queue<TSortCursor> & queue);
/// Insert the summed row for the current group into the result. /// Insert the summed row for the current group into the result.
@ -99,16 +99,16 @@ private:
/** For nested Map, a merge by key is performed with the ejection of rows of nested arrays, in which /** For nested Map, a merge by key is performed with the ejection of rows of nested arrays, in which
* all items are zero. * all items are zero.
*/ */
template <class TSortCursor> template <typename TSortCursor>
bool mergeMaps(Row & row, TSortCursor & cursor); bool mergeMaps(Row & row, TSortCursor & cursor);
template <class TSortCursor> template <typename TSortCursor>
bool mergeMap(const MapDescription & map, Row & row, TSortCursor & cursor); bool mergeMap(const MapDescription & map, Row & row, TSortCursor & cursor);
/** Add the row under the cursor to the `row`. /** Add the row under the cursor to the `row`.
* Returns false if the result is zero. * Returns false if the result is zero.
*/ */
template <class TSortCursor> template <typename TSortCursor>
bool addRow(Row & row, TSortCursor & cursor); bool addRow(Row & row, TSortCursor & cursor);
}; };

4
dbms/src/DataStreams/UnionBlockInputStream.h
View File

@ -237,13 +237,13 @@ protected:
} }
private: private:
template<StreamUnionMode mode2 = mode> template <StreamUnionMode mode2 = mode>
BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::ExtraInfo>::type * = nullptr) const BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::ExtraInfo>::type * = nullptr) const
{ {
return received_payload.extra_info; return received_payload.extra_info;
} }
template<StreamUnionMode mode2 = mode> template <StreamUnionMode mode2 = mode>
BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::Basic>::type * = nullptr) const BlockExtraInfo doGetBlockExtraInfo(typename std::enable_if<mode2 == StreamUnionMode::Basic>::type * = nullptr) const
{ {
throw Exception("Method getBlockExtraInfo is not supported for mode StreamUnionMode::Basic", throw Exception("Method getBlockExtraInfo is not supported for mode StreamUnionMode::Basic",

60
dbms/src/Dictionaries/DictionaryBlockInputStream.h
View File

@ -19,7 +19,7 @@ namespace DB
* BlockInputStream implementation for external dictionaries * BlockInputStream implementation for external dictionaries
* read() returns single block consisting of the in-memory contents of the dictionaries * read() returns single block consisting of the in-memory contents of the dictionaries
*/ */
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
class DictionaryBlockInputStream : public DictionaryBlockInputStreamBase class DictionaryBlockInputStream : public DictionaryBlockInputStreamBase
{ {
public: public:
@ -51,13 +51,13 @@ protected:
private: private:
// pointer types to getXXX functions // pointer types to getXXX functions
// for single key dictionaries // for single key dictionaries
template <class Type> template <typename Type>
using DictionaryGetter = void (DictionaryType::*)( using DictionaryGetter = void (DictionaryType::*)(
const std::string &, const PaddedPODArray<Key> &, PaddedPODArray<Type> &) const; const std::string &, const PaddedPODArray<Key> &, PaddedPODArray<Type> &) const;
using DictionaryStringGetter = void (DictionaryType::*)( using DictionaryStringGetter = void (DictionaryType::*)(
const std::string &, const PaddedPODArray<Key> &, ColumnString *) const; const std::string &, const PaddedPODArray<Key> &, ColumnString *) const;
// for complex complex key dictionaries // for complex complex key dictionaries
template <class Type> template <typename Type>
using GetterByKey = void (DictionaryType::*)( using GetterByKey = void (DictionaryType::*)(
const std::string &, const Columns &, const DataTypes &, PaddedPODArray<Type> & out) const; const std::string &, const Columns &, const DataTypes &, PaddedPODArray<Type> & out) const;
using StringGetterByKey = void (DictionaryType::*)( using StringGetterByKey = void (DictionaryType::*)(
@ -65,34 +65,34 @@ private:
// call getXXX // call getXXX
// for single key dictionaries // for single key dictionaries
template <class Type, class Container> template <typename Type, typename Container>
void callGetter(DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids, void callGetter(DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const; Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
template <class Container> template <typename Container>
void callGetter(DictionaryStringGetter getter, const PaddedPODArray<Key> & ids, void callGetter(DictionaryStringGetter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const; Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
// for complex complex key dictionaries // for complex complex key dictionaries
template <class Type, class Container> template <typename Type, typename Container>
void callGetter(GetterByKey<Type> getter, const PaddedPODArray<Key> & ids, void callGetter(GetterByKey<Type> getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const; Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
template <class Container> template <typename Container>
void callGetter(StringGetterByKey getter, const PaddedPODArray<Key> & ids, void callGetter(StringGetterByKey getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const; Container & container, const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
template <template <class> class Getter, class StringGetter> template <template <typename> class Getter, typename StringGetter>
Block fillBlock(const PaddedPODArray<Key> & ids, const Columns & keys, Block fillBlock(const PaddedPODArray<Key> & ids, const Columns & keys,
const DataTypes & types, ColumnsWithTypeAndName && view) const; const DataTypes & types, ColumnsWithTypeAndName && view) const;
template <class AttributeType, class Getter> template <typename AttributeType, typename Getter>
ColumnPtr getColumnFromAttribute(Getter getter, const PaddedPODArray<Key> & ids, ColumnPtr getColumnFromAttribute(Getter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
const DictionaryAttribute & attribute, const DictionaryType & dictionary) const; const DictionaryAttribute & attribute, const DictionaryType & dictionary) const;
template <class Getter> template <typename Getter>
ColumnPtr getColumnFromStringAttribute(Getter getter, const PaddedPODArray<Key> & ids, ColumnPtr getColumnFromStringAttribute(Getter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
const DictionaryAttribute& attribute, const DictionaryType& dictionary) const; const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
@ -115,7 +115,7 @@ private:
GetColumnsFunction get_view_columns_function; GetColumnsFunction get_view_columns_function;
}; };
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream( DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size, std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
PaddedPODArray<Key> && ids, const Names& column_names) PaddedPODArray<Key> && ids, const Names& column_names)
@ -127,7 +127,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
{ {
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream( DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size, std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
const std::vector<StringRef> & keys, const Names& column_names) const std::vector<StringRef> & keys, const Names& column_names)
@ -140,7 +140,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
fillKeyColumns(keys, 0, keys.size(), dictionaty_structure, key_columns); fillKeyColumns(keys, 0, keys.size(), dictionaty_structure, key_columns);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream( DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size, std::shared_ptr<const IDictionaryBase> dictionary, size_t max_block_size,
const Columns & data_columns, const Names & column_names, const Columns & data_columns, const Names & column_names,
@ -155,7 +155,7 @@ DictionaryBlockInputStream<DictionaryType, Key>::DictionaryBlockInputStream(
{ {
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
Block DictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const Block DictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const
{ {
if (!key_columns.empty()) if (!key_columns.empty())
@ -197,8 +197,8 @@ Block DictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, si
} }
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class Type, class Container> template <typename Type, typename Container>
void DictionaryBlockInputStream<DictionaryType, Key>::callGetter( void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids, DictionaryGetter<Type> getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -207,8 +207,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
(dictionary.*getter)(attribute.name, ids, container); (dictionary.*getter)(attribute.name, ids, container);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class Container> template <typename Container>
void DictionaryBlockInputStream<DictionaryType, Key>::callGetter( void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
DictionaryStringGetter getter, const PaddedPODArray<Key> & ids, DictionaryStringGetter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -217,8 +217,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
(dictionary.*getter)(attribute.name, ids, container); (dictionary.*getter)(attribute.name, ids, container);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class Type, class Container> template <typename Type, typename Container>
void DictionaryBlockInputStream<DictionaryType, Key>::callGetter( void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
GetterByKey<Type> getter, const PaddedPODArray<Key> & ids, GetterByKey<Type> getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -227,8 +227,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
(dictionary.*getter)(attribute.name, keys, data_types, container); (dictionary.*getter)(attribute.name, keys, data_types, container);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class Container> template <typename Container>
void DictionaryBlockInputStream<DictionaryType, Key>::callGetter( void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
StringGetterByKey getter, const PaddedPODArray<Key> & ids, StringGetterByKey getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -237,8 +237,8 @@ void DictionaryBlockInputStream<DictionaryType, Key>::callGetter(
(dictionary.*getter)(attribute.name, keys, data_types, container); (dictionary.*getter)(attribute.name, keys, data_types, container);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <template <class> class Getter, class StringGetter> template <template <typename> class Getter, typename StringGetter>
Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock( Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
const PaddedPODArray<Key>& ids, const Columns& keys, const DataTypes & types, ColumnsWithTypeAndName && view) const const PaddedPODArray<Key>& ids, const Columns& keys, const DataTypes & types, ColumnsWithTypeAndName && view) const
{ {
@ -317,8 +317,8 @@ Block DictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
return Block(block_columns); return Block(block_columns);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class AttributeType, class Getter> template <typename AttributeType, typename Getter>
ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute( ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute(
Getter getter, const PaddedPODArray<Key> & ids, Getter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -332,8 +332,8 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribut
return ColumnPtr(std::move(column_vector)); return ColumnPtr(std::move(column_vector));
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class Getter> template <typename Getter>
ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromStringAttribute( ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromStringAttribute(
Getter getter, const PaddedPODArray<Key> & ids, Getter getter, const PaddedPODArray<Key> & ids,
const Columns & keys, const DataTypes & data_types, const Columns & keys, const DataTypes & data_types,
@ -345,7 +345,7 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromStringAt
return column_string; return column_string;
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromIds(const PaddedPODArray<Key>& ids) const ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromIds(const PaddedPODArray<Key>& ids) const
{ {
auto column_vector = std::make_shared<ColumnVector<UInt64>>(); auto column_vector = std::make_shared<ColumnVector<UInt64>>();
@ -357,7 +357,7 @@ ColumnPtr DictionaryBlockInputStream<DictionaryType, Key>::getColumnFromIds(cons
return column_vector; return column_vector;
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
void DictionaryBlockInputStream<DictionaryType, Key>::fillKeyColumns( void DictionaryBlockInputStream<DictionaryType, Key>::fillKeyColumns(
const std::vector<StringRef> & keys, size_t start, size_t size, const std::vector<StringRef> & keys, size_t start, size_t size,
const DictionaryStructure& dictionary_structure, ColumnsWithTypeAndName & columns) const const DictionaryStructure& dictionary_structure, ColumnsWithTypeAndName & columns) const

30
dbms/src/Dictionaries/RangeDictionaryBlockInputStream.h
View File

@ -17,7 +17,7 @@ namespace DB
* BlockInputStream implementation for external dictionaries * BlockInputStream implementation for external dictionaries
* read() returns single block consisting of the in-memory contents of the dictionaries * read() returns single block consisting of the in-memory contents of the dictionaries
*/ */
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
class RangeDictionaryBlockInputStream : public DictionaryBlockInputStreamBase class RangeDictionaryBlockInputStream : public DictionaryBlockInputStreamBase
{ {
public: public:
@ -35,20 +35,20 @@ protected:
Block getBlock(size_t start, size_t length) const override; Block getBlock(size_t start, size_t length) const override;
private: private:
template <class Type> template <typename Type>
using DictionaryGetter = void (DictionaryType::*)(const std::string &, const PaddedPODArray<Key> &, using DictionaryGetter = void (DictionaryType::*)(const std::string &, const PaddedPODArray<Key> &,
const PaddedPODArray<UInt16> &, PaddedPODArray<Type> &) const; const PaddedPODArray<UInt16> &, PaddedPODArray<Type> &) const;
template <class AttributeType> template <typename AttributeType>
ColumnPtr getColumnFromAttribute(DictionaryGetter<AttributeType> getter, ColumnPtr getColumnFromAttribute(DictionaryGetter<AttributeType> getter,
const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates, const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
const DictionaryAttribute& attribute, const DictionaryType& dictionary) const; const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
ColumnPtr getColumnFromAttributeString(const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates, ColumnPtr getColumnFromAttributeString(const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
const DictionaryAttribute& attribute, const DictionaryType& dictionary) const; const DictionaryAttribute& attribute, const DictionaryType& dictionary) const;
template <class T> template <typename T>
ColumnPtr getColumnFromPODArray(const PaddedPODArray<T>& array) const; ColumnPtr getColumnFromPODArray(const PaddedPODArray<T>& array) const;
template <class T> template <typename T>
void addSpecialColumn( void addSpecialColumn(
const std::experimental::optional<DictionarySpecialAttribute>& attribute, DataTypePtr type, const std::experimental::optional<DictionarySpecialAttribute>& attribute, DataTypePtr type,
const std::string & default_name, const std::unordered_set<std::string> & column_names, const std::string & default_name, const std::unordered_set<std::string> & column_names,
@ -65,7 +65,7 @@ private:
}; };
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
RangeDictionaryBlockInputStream<DictionaryType, Key>::RangeDictionaryBlockInputStream( RangeDictionaryBlockInputStream<DictionaryType, Key>::RangeDictionaryBlockInputStream(
DictionatyPtr dictionary, size_t max_column_size, const Names & column_names, PaddedPODArray<Key> && ids, DictionatyPtr dictionary, size_t max_column_size, const Names & column_names, PaddedPODArray<Key> && ids,
PaddedPODArray<UInt16> && start_dates, PaddedPODArray<UInt16> && end_dates) PaddedPODArray<UInt16> && start_dates, PaddedPODArray<UInt16> && end_dates)
@ -75,7 +75,7 @@ RangeDictionaryBlockInputStream<DictionaryType, Key>::RangeDictionaryBlockInputS
{ {
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
Block RangeDictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const Block RangeDictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t start, size_t length) const
{ {
PaddedPODArray<Key> block_ids; PaddedPODArray<Key> block_ids;
@ -95,8 +95,8 @@ Block RangeDictionaryBlockInputStream<DictionaryType, Key>::getBlock(size_t star
return fillBlock(block_ids, block_start_dates, block_end_dates); return fillBlock(block_ids, block_start_dates, block_end_dates);
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class AttributeType> template <typename AttributeType>
ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute( ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttribute(
DictionaryGetter<AttributeType> getter, const PaddedPODArray<Key>& ids, DictionaryGetter<AttributeType> getter, const PaddedPODArray<Key>& ids,
const PaddedPODArray<UInt16> & dates, const DictionaryAttribute& attribute, const DictionaryType& dictionary) const const PaddedPODArray<UInt16> & dates, const DictionaryAttribute& attribute, const DictionaryType& dictionary) const
@ -106,7 +106,7 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAtt
return ColumnPtr(std::move(column_vector)); return ColumnPtr(std::move(column_vector));
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttributeString( ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAttributeString(
const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates, const PaddedPODArray<Key>& ids, const PaddedPODArray<UInt16> & dates,
const DictionaryAttribute& attribute, const DictionaryType& dictionary) const const DictionaryAttribute& attribute, const DictionaryType& dictionary) const
@ -116,8 +116,8 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromAtt
return ColumnPtr(std::move(column_string)); return ColumnPtr(std::move(column_string));
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class T> template <typename T>
ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromPODArray(const PaddedPODArray<T>& array) const ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromPODArray(const PaddedPODArray<T>& array) const
{ {
auto column_vector = std::make_unique<ColumnVector<T>>(); auto column_vector = std::make_unique<ColumnVector<T>>();
@ -130,8 +130,8 @@ ColumnPtr RangeDictionaryBlockInputStream<DictionaryType, Key>::getColumnFromPOD
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
template <class T> template <typename T>
void RangeDictionaryBlockInputStream<DictionaryType, Key>::addSpecialColumn( void RangeDictionaryBlockInputStream<DictionaryType, Key>::addSpecialColumn(
const std::experimental::optional<DictionarySpecialAttribute> & attribute, DataTypePtr type, const std::experimental::optional<DictionarySpecialAttribute> & attribute, DataTypePtr type,
const std::string& default_name, const std::unordered_set<std::string> & column_names, const std::string& default_name, const std::unordered_set<std::string> & column_names,
@ -146,7 +146,7 @@ void RangeDictionaryBlockInputStream<DictionaryType, Key>::addSpecialColumn(
} }
} }
template <class DictionaryType, class Key> template <typename DictionaryType, typename Key>
Block RangeDictionaryBlockInputStream<DictionaryType, Key>::fillBlock( Block RangeDictionaryBlockInputStream<DictionaryType, Key>::fillBlock(
const PaddedPODArray<Key>& ids, const PaddedPODArray<Key>& ids,
const PaddedPODArray<UInt16> & start_dates, const PaddedPODArray<UInt16> & end_dates) const const PaddedPODArray<UInt16> & start_dates, const PaddedPODArray<UInt16> & end_dates) const

2
dbms/src/Functions/FunctionsComparison.h
View File

@ -90,7 +90,7 @@ template <typename A, typename B> struct GreaterOrEqualsOp
}; };
template<typename A, typename B, typename Op> template <typename A, typename B, typename Op>
struct NumComparisonImpl struct NumComparisonImpl
{ {
/// If you don't specify NO_INLINE, the compiler will inline this function, but we don't need this as this function contains tight loop inside. /// If you don't specify NO_INLINE, the compiler will inline this function, but we don't need this as this function contains tight loop inside.

8
dbms/src/Functions/FunctionsConversion.h
View File

@ -705,7 +705,7 @@ private:
} }
} }
template<typename ToDataType2 = ToDataType, typename Name2 = Name> template <typename ToDataType2 = ToDataType, typename Name2 = Name>
DataTypePtr getReturnTypeInternal(const DataTypes & arguments, DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
typename std::enable_if<!(std::is_same<ToDataType2, DataTypeString>::value || typename std::enable_if<!(std::is_same<ToDataType2, DataTypeString>::value ||
std::is_same<Name2, NameToUnixTimestamp>::value || std::is_same<Name2, NameToUnixTimestamp>::value ||
@ -721,7 +721,7 @@ private:
/** Conversion of anything to String. For DateTime, it allows second optional argument - time zone. /** Conversion of anything to String. For DateTime, it allows second optional argument - time zone.
*/ */
template<typename ToDataType2 = ToDataType, typename Name2 = Name> template <typename ToDataType2 = ToDataType, typename Name2 = Name>
DataTypePtr getReturnTypeInternal(const DataTypes & arguments, DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
typename std::enable_if<std::is_same<ToDataType2, DataTypeString>::value>::type * = nullptr) const typename std::enable_if<std::is_same<ToDataType2, DataTypeString>::value>::type * = nullptr) const
{ {
@ -747,7 +747,7 @@ private:
return std::make_shared<ToDataType2>(); return std::make_shared<ToDataType2>();
} }
template<typename ToDataType2 = ToDataType, typename Name2 = Name> template <typename ToDataType2 = ToDataType, typename Name2 = Name>
DataTypePtr getReturnTypeInternal(const DataTypes & arguments, DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
typename std::enable_if<std::is_same<Name2, NameToUnixTimestamp>::value, void>::type * = nullptr) const typename std::enable_if<std::is_same<Name2, NameToUnixTimestamp>::value, void>::type * = nullptr) const
{ {
@ -773,7 +773,7 @@ private:
return std::make_shared<ToDataType2>(); return std::make_shared<ToDataType2>();
} }
template<typename ToDataType2 = ToDataType, typename Name2 = Name> template <typename ToDataType2 = ToDataType, typename Name2 = Name>
DataTypePtr getReturnTypeInternal(const DataTypes & arguments, DataTypePtr getReturnTypeInternal(const DataTypes & arguments,
typename std::enable_if<std::is_same<Name2, NameToDate>::value>::type * = nullptr) const typename std::enable_if<std::is_same<Name2, NameToDate>::value>::type * = nullptr) const
{ {

2
dbms/src/Functions/FunctionsDateTime.h
View File

@ -466,7 +466,7 @@ struct ToYYYYMMDDhhmmssImpl
}; };
template<typename FromType, typename ToType, typename Transform> template <typename FromType, typename ToType, typename Transform>
struct Transformer struct Transformer
{ {
static void vector(const PaddedPODArray<FromType> & vec_from, PaddedPODArray<ToType> & vec_to, const DateLUTImpl & time_zone) static void vector(const PaddedPODArray<FromType> & vec_from, PaddedPODArray<ToType> & vec_to, const DateLUTImpl & time_zone)

6
dbms/src/Functions/FunctionsFindCluster.h
View File

@ -167,7 +167,7 @@ protected:
// Match the type of the centrods array and convert them to Float64, because we // Match the type of the centrods array and convert them to Float64, because we
// don't want to have problems calculating negative distances of UInts // don't want to have problems calculating negative distances of UInts
template<typename CentroidsType> template <typename CentroidsType>
bool fillCentroids(const IColumn * centroids_array_untyped, std::vector<Float64> & centroids) bool fillCentroids(const IColumn * centroids_array_untyped, std::vector<Float64> & centroids)
{ {
const ColumnConst * const_centroids_array = checkAndGetColumnConst<ColumnVector<Array>>(centroids_array_untyped); const ColumnConst * const_centroids_array = checkAndGetColumnConst<ColumnVector<Array>>(centroids_array_untyped);
@ -191,7 +191,7 @@ protected:
return true; return true;
} }
template<typename CentroidsType, typename OutputType> template <typename CentroidsType, typename OutputType>
bool executeOperation(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * centroids_array_untyped) bool executeOperation(const IColumn * in_untyped, IColumn * out_untyped, const IColumn * centroids_array_untyped)
{ {
// Match the type of the output // Match the type of the output
@ -220,7 +220,7 @@ protected:
return true; return true;
} }
template<typename InputType, typename OutputType, typename CentroidsType> template <typename InputType, typename OutputType, typename CentroidsType>
bool executeOperationTyped(const IColumn * in_untyped, PaddedPODArray<OutputType> & dst, const IColumn * centroids_array_untyped) bool executeOperationTyped(const IColumn * in_untyped, PaddedPODArray<OutputType> & dst, const IColumn * centroids_array_untyped)
{ {
const auto maybe_const = in_untyped->convertToFullColumnIfConst(); const auto maybe_const = in_untyped->convertToFullColumnIfConst();

2
dbms/src/Functions/FunctionsHigherOrder.h
View File

@ -331,7 +331,7 @@ struct ArraySumImpl
throw Exception("arraySum cannot add values of type " + expression_return->getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); throw Exception("arraySum cannot add values of type " + expression_return->getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
} }
template <class Element, class Result> template <typename Element, typename Result>
static bool executeType(const ColumnPtr & mapped, const ColumnArray::Offsets_t & offsets, ColumnPtr & res_ptr) static bool executeType(const ColumnPtr & mapped, const ColumnArray::Offsets_t & offsets, ColumnPtr & res_ptr)
{ {
const ColumnVector<Element> * column = checkAndGetColumn<ColumnVector<Element>>(&*mapped); const ColumnVector<Element> * column = checkAndGetColumn<ColumnVector<Element>>(&*mapped);

8
dbms/src/Functions/FunctionsLogical.h
View File

@ -24,7 +24,7 @@ namespace ErrorCodes
* Accept any numeric types, return a UInt8 containing 0 or 1. * Accept any numeric types, return a UInt8 containing 0 or 1.
*/ */
template<typename B> template <typename B>
struct AndImpl struct AndImpl
{ {
static inline bool isSaturable() static inline bool isSaturable()
@ -43,7 +43,7 @@ struct AndImpl
} }
}; };
template<typename B> template <typename B>
struct OrImpl struct OrImpl
{ {
static inline bool isSaturable() static inline bool isSaturable()
@ -62,7 +62,7 @@ struct OrImpl
} }
}; };
template<typename B> template <typename B>
struct XorImpl struct XorImpl
{ {
static inline bool isSaturable() static inline bool isSaturable()
@ -81,7 +81,7 @@ struct XorImpl
} }
}; };
template<typename A> template <typename A>
struct NotImpl struct NotImpl
{ {
using ResultType = UInt8; using ResultType = UInt8;

6
dbms/src/Functions/FunctionsReinterpret.h
View File

@ -27,7 +27,7 @@ namespace ErrorCodes
*/ */
template<typename Name> template <typename Name>
class FunctionReinterpretAsStringImpl : public IFunction class FunctionReinterpretAsStringImpl : public IFunction
{ {
public: public:
@ -52,7 +52,7 @@ public:
return std::make_shared<DataTypeString>(); return std::make_shared<DataTypeString>();
} }
template<typename T> template <typename T>
bool executeType(Block & block, const ColumnNumbers & arguments, size_t result) bool executeType(Block & block, const ColumnNumbers & arguments, size_t result)
{ {
if (auto col_from = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get())) if (auto col_from = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get()))
@ -112,7 +112,7 @@ public:
}; };
template<typename ToDataType, typename Name> template <typename ToDataType, typename Name>
class FunctionReinterpretStringAs : public IFunction class FunctionReinterpretStringAs : public IFunction
{ {
public: public:

86
dbms/src/Functions/FunctionsRound.h
View File

@ -37,7 +37,7 @@ namespace ErrorCodes
* - N = 0: round to an integer * - N = 0: round to an integer
*/ */
template<typename A> template <typename A>
struct RoundToExp2Impl struct RoundToExp2Impl
{ {
using ResultType = A; using ResultType = A;
@ -48,7 +48,7 @@ struct RoundToExp2Impl
} }
}; };
template<> template <>
struct RoundToExp2Impl<Float32> struct RoundToExp2Impl<Float32>
{ {
using ResultType = Float32; using ResultType = Float32;
@ -59,7 +59,7 @@ struct RoundToExp2Impl<Float32>
} }
}; };
template<> template <>
struct RoundToExp2Impl<Float64> struct RoundToExp2Impl<Float64>
{ {
using ResultType = Float64; using ResultType = Float64;
@ -70,7 +70,7 @@ struct RoundToExp2Impl<Float64>
} }
}; };
template<typename A> template <typename A>
struct RoundDurationImpl struct RoundDurationImpl
{ {
using ResultType = UInt16; using ResultType = UInt16;
@ -96,7 +96,7 @@ struct RoundDurationImpl
} }
}; };
template<typename A> template <typename A>
struct RoundAgeImpl struct RoundAgeImpl
{ {
using ResultType = UInt8; using ResultType = UInt8;
@ -116,17 +116,17 @@ struct RoundAgeImpl
/** Quick calculation of the remainder of the division to apply to the rounding of integers. /** Quick calculation of the remainder of the division to apply to the rounding of integers.
* Without verification, because the divisor is always positive. * Without verification, because the divisor is always positive.
*/ */
template<typename T, typename Enable = void> template <typename T, typename Enable = void>
struct FastModulo; struct FastModulo;
template<typename T> template <typename T>
struct FastModulo<T, typename std::enable_if<std::is_integral<T>::value>::type> struct FastModulo<T, typename std::enable_if<std::is_integral<T>::value>::type>
{ {
private: private:
template<typename InputType, typename Enable = void> template <typename InputType, typename Enable = void>
struct Extend; struct Extend;
template<typename InputType> template <typename InputType>
struct Extend<InputType, struct Extend<InputType,
typename std::enable_if<std::is_same<InputType, Int8>::value typename std::enable_if<std::is_same<InputType, Int8>::value
|| std::is_same<InputType, Int16>::value>::type> || std::is_same<InputType, Int16>::value>::type>
@ -134,7 +134,7 @@ private:
using Type = Int64; using Type = Int64;
}; };
template<typename InputType> template <typename InputType>
struct Extend<InputType, struct Extend<InputType,
typename std::enable_if<std::is_same<InputType, UInt8>::value typename std::enable_if<std::is_same<InputType, UInt8>::value
|| std::is_same<InputType, UInt16>::value>::type> || std::is_same<InputType, UInt16>::value>::type>
@ -142,7 +142,7 @@ private:
using Type = UInt64; using Type = UInt64;
}; };
template<typename InputType> template <typename InputType>
struct Extend<InputType, struct Extend<InputType,
typename std::enable_if<std::is_integral<InputType>::value typename std::enable_if<std::is_integral<InputType>::value
&& (sizeof(InputType) >= 4)>::type> && (sizeof(InputType) >= 4)>::type>
@ -186,10 +186,10 @@ enum ScaleMode
/** Implementing low-level rounding functions for integer values. /** Implementing low-level rounding functions for integer values.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void> template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
struct IntegerRoundingComputation; struct IntegerRoundingComputation;
template<typename T, int rounding_mode, ScaleMode scale_mode> template <typename T, int rounding_mode, ScaleMode scale_mode>
struct IntegerRoundingComputation<T, rounding_mode, scale_mode, struct IntegerRoundingComputation<T, rounding_mode, scale_mode,
typename std::enable_if<std::is_integral<T>::value typename std::enable_if<std::is_integral<T>::value
&& ((scale_mode == PositiveScale) || (scale_mode == ZeroScale))>::type> && ((scale_mode == PositiveScale) || (scale_mode == ZeroScale))>::type>
@ -207,7 +207,7 @@ struct IntegerRoundingComputation<T, rounding_mode, scale_mode,
} }
}; };
template<typename T> template <typename T>
struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale, struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale,
typename std::enable_if<std::is_integral<T>::value>::type> typename std::enable_if<std::is_integral<T>::value>::type>
{ {
@ -234,7 +234,7 @@ struct IntegerRoundingComputation<T, _MM_FROUND_NINT, NegativeScale,
} }
}; };
template<typename T> template <typename T>
struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale, struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale,
typename std::enable_if<std::is_integral<T>::value>::type> typename std::enable_if<std::is_integral<T>::value>::type>
{ {
@ -256,7 +256,7 @@ struct IntegerRoundingComputation<T, _MM_FROUND_CEIL, NegativeScale,
} }
}; };
template<typename T> template <typename T>
struct IntegerRoundingComputation<T, _MM_FROUND_FLOOR, NegativeScale, struct IntegerRoundingComputation<T, _MM_FROUND_FLOOR, NegativeScale,
typename std::enable_if<std::is_integral<T>::value>::type> typename std::enable_if<std::is_integral<T>::value>::type>
{ {
@ -360,10 +360,10 @@ protected:
/** Implementation of low-level round-off functions for floating-point values. /** Implementation of low-level round-off functions for floating-point values.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode> template <typename T, int rounding_mode, ScaleMode scale_mode>
class FloatRoundingComputation; class FloatRoundingComputation;
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float32, rounding_mode, PositiveScale> class FloatRoundingComputation<Float32, rounding_mode, PositiveScale>
: public BaseFloatRoundingComputation<Float32> : public BaseFloatRoundingComputation<Float32>
{ {
@ -389,7 +389,7 @@ public:
} }
}; };
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float32, rounding_mode, NegativeScale> class FloatRoundingComputation<Float32, rounding_mode, NegativeScale>
: public BaseFloatRoundingComputation<Float32> : public BaseFloatRoundingComputation<Float32>
{ {
@ -433,7 +433,7 @@ private:
} }
}; };
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float32, rounding_mode, ZeroScale> class FloatRoundingComputation<Float32, rounding_mode, ZeroScale>
: public BaseFloatRoundingComputation<Float32> : public BaseFloatRoundingComputation<Float32>
{ {
@ -454,7 +454,7 @@ public:
} }
}; };
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float64, rounding_mode, PositiveScale> class FloatRoundingComputation<Float64, rounding_mode, PositiveScale>
: public BaseFloatRoundingComputation<Float64> : public BaseFloatRoundingComputation<Float64>
{ {
@ -480,7 +480,7 @@ public:
} }
}; };
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float64, rounding_mode, NegativeScale> class FloatRoundingComputation<Float64, rounding_mode, NegativeScale>
: public BaseFloatRoundingComputation<Float64> : public BaseFloatRoundingComputation<Float64>
{ {
@ -524,7 +524,7 @@ private:
} }
}; };
template<int rounding_mode> template <int rounding_mode>
class FloatRoundingComputation<Float64, rounding_mode, ZeroScale> class FloatRoundingComputation<Float64, rounding_mode, ZeroScale>
: public BaseFloatRoundingComputation<Float64> : public BaseFloatRoundingComputation<Float64>
{ {
@ -622,12 +622,12 @@ public:
/** Implementing high-level rounding functions. /** Implementing high-level rounding functions.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void> template <typename T, int rounding_mode, ScaleMode scale_mode, typename Enable = void>
struct FunctionRoundingImpl; struct FunctionRoundingImpl;
/** Implement high-level rounding functions for integer values. /** Implement high-level rounding functions for integer values.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode> template <typename T, int rounding_mode, ScaleMode scale_mode>
struct FunctionRoundingImpl<T, rounding_mode, scale_mode, struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
typename std::enable_if<std::is_integral<T>::value && (scale_mode != NullScale)>::type> typename std::enable_if<std::is_integral<T>::value && (scale_mode != NullScale)>::type>
{ {
@ -659,7 +659,7 @@ public:
/** Implement high-level round-off functions for floating-point values. /** Implement high-level round-off functions for floating-point values.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode> template <typename T, int rounding_mode, ScaleMode scale_mode>
struct FunctionRoundingImpl<T, rounding_mode, scale_mode, struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != NullScale)>::type> typename std::enable_if<std::is_floating_point<T>::value && (scale_mode != NullScale)>::type>
{ {
@ -739,7 +739,7 @@ public:
/** Implementation of high-level rounding functions in the case when a zero value is returned. /** Implementation of high-level rounding functions in the case when a zero value is returned.
*/ */
template<typename T, int rounding_mode, ScaleMode scale_mode> template <typename T, int rounding_mode, ScaleMode scale_mode>
struct FunctionRoundingImpl<T, rounding_mode, scale_mode, struct FunctionRoundingImpl<T, rounding_mode, scale_mode,
typename std::enable_if<scale_mode == NullScale>::type> typename std::enable_if<scale_mode == NullScale>::type>
{ {
@ -761,13 +761,13 @@ namespace
{ {
/// Individual degrees of the number 10. /// Individual degrees of the number 10.
template<size_t N> template <size_t N>
struct PowerOf10 struct PowerOf10
{ {
static const size_t value = 10 * PowerOf10<N - 1>::value; static const size_t value = 10 * PowerOf10<N - 1>::value;
}; };
template<> template <>
struct PowerOf10<0> struct PowerOf10<0>
{ {
static const size_t value = 1; static const size_t value = 1;
@ -776,30 +776,30 @@ namespace
/// Declaring and defining a container containing a table of powers of 10. /// Declaring and defining a container containing a table of powers of 10.
template<size_t... TArgs> template <size_t... TArgs>
struct TableContainer struct TableContainer
{ {
static const std::array<size_t, sizeof...(TArgs)> values; static const std::array<size_t, sizeof...(TArgs)> values;
}; };
template<size_t... TArgs> template <size_t... TArgs>
const std::array<size_t, sizeof...(TArgs)> TableContainer<TArgs...>::values {{ TArgs... }}; const std::array<size_t, sizeof...(TArgs)> TableContainer<TArgs...>::values {{ TArgs... }};
/// The generator of the first N degrees. /// The generator of the first N degrees.
template<size_t N, size_t... TArgs> template <size_t N, size_t... TArgs>
struct FillArrayImpl struct FillArrayImpl
{ {
using result = typename FillArrayImpl<N - 1, PowerOf10<N>::value, TArgs...>::result; using result = typename FillArrayImpl<N - 1, PowerOf10<N>::value, TArgs...>::result;
}; };
template<size_t... TArgs> template <size_t... TArgs>
struct FillArrayImpl<0, TArgs...> struct FillArrayImpl<0, TArgs...>
{ {
using result = TableContainer<PowerOf10<0>::value, TArgs...>; using result = TableContainer<PowerOf10<0>::value, TArgs...>;
}; };
template<size_t N> template <size_t N>
struct FillArray struct FillArray
{ {
using result = typename FillArrayImpl<N - 1>::result; using result = typename FillArrayImpl<N - 1>::result;
@ -809,10 +809,10 @@ struct FillArray
* then converts it to a value that can be used in operations of * then converts it to a value that can be used in operations of
* multiplication and division. Therefore, it is called a scale. * multiplication and division. Therefore, it is called a scale.
*/ */
template<typename T, typename U, typename Enable = void> template <typename T, typename U, typename Enable = void>
struct ScaleForRightType; struct ScaleForRightType;
template<typename T, typename U> template <typename T, typename U>
struct ScaleForRightType<T, U, struct ScaleForRightType<T, U,
typename std::enable_if< typename std::enable_if<
std::is_floating_point<T>::value std::is_floating_point<T>::value
@ -857,7 +857,7 @@ struct ScaleForRightType<T, U,
} }
}; };
template<typename T, typename U> template <typename T, typename U>
struct ScaleForRightType<T, U, struct ScaleForRightType<T, U,
typename std::enable_if< typename std::enable_if<
std::is_floating_point<T>::value std::is_floating_point<T>::value
@ -888,7 +888,7 @@ struct ScaleForRightType<T, U,
} }
}; };
template<typename T, typename U> template <typename T, typename U>
struct ScaleForRightType<T, U, struct ScaleForRightType<T, U,
typename std::enable_if< typename std::enable_if<
std::is_integral<T>::value std::is_integral<T>::value
@ -925,7 +925,7 @@ struct ScaleForRightType<T, U,
} }
}; };
template<typename T, typename U> template <typename T, typename U>
struct ScaleForRightType<T, U, struct ScaleForRightType<T, U,
typename std::enable_if< typename std::enable_if<
std::is_integral<T>::value std::is_integral<T>::value
@ -946,7 +946,7 @@ struct ScaleForRightType<T, U,
/** Turn the precision parameter into a scale. /** Turn the precision parameter into a scale.
*/ */
template<typename T> template <typename T>
struct ScaleForLeftType struct ScaleForLeftType
{ {
static inline void apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale) static inline void apply(const ColumnPtr & column, ScaleMode & scale_mode, size_t & scale)
@ -1025,7 +1025,7 @@ struct Dispatcher
* (U)Int8/16/32/64 or Float32/64, and accept an additional optional * (U)Int8/16/32/64 or Float32/64, and accept an additional optional
* parameter (default is 0). * parameter (default is 0).
*/ */
template<typename Name, int rounding_mode> template <typename Name, int rounding_mode>
class FunctionRounding : public IFunction class FunctionRounding : public IFunction
{ {
public: public:
@ -1033,13 +1033,13 @@ public:
static FunctionPtr create(const Context & context) { return std::make_shared<FunctionRounding>(); } static FunctionPtr create(const Context & context) { return std::make_shared<FunctionRounding>(); }
private: private:
template<typename T> template <typename T>
bool checkType(const IDataType * type) const bool checkType(const IDataType * type) const
{ {
return typeid_cast<const T *>(type); return typeid_cast<const T *>(type);
} }
template<typename T> template <typename T>
bool executeForType(Block & block, const ColumnNumbers & arguments, size_t result) bool executeForType(Block & block, const ColumnNumbers & arguments, size_t result)
{ {
if (auto col = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get())) if (auto col = checkAndGetColumn<ColumnVector<T>>(block.getByPosition(arguments[0]).column.get()))

4
dbms/src/Functions/FunctionsVisitParam.h
View File

@ -49,7 +49,7 @@ struct HasParam
} }
}; };
template<typename NumericType> template <typename NumericType>
struct ExtractNumericType struct ExtractNumericType
{ {
using ResultType = NumericType; using ResultType = NumericType;
@ -239,7 +239,7 @@ struct ExtractParamImpl
/** For the case where the type of field to extract is a string. /** For the case where the type of field to extract is a string.
*/ */
template<typename ParamExtractor> template <typename ParamExtractor>
struct ExtractParamToStringImpl struct ExtractParamToStringImpl
{ {
static void vector(const ColumnString::Chars_t & data, const ColumnString::Offsets_t & offsets, static void vector(const ColumnString::Chars_t & data, const ColumnString::Offsets_t & offsets,

6
dbms/src/Functions/tests/logical_functions_performance.cpp
View File

@ -18,7 +18,7 @@ namespace ErrorCodes
} }
template<typename B> template <typename B>
struct AndImpl struct AndImpl
{ {
static inline UInt8 apply(UInt8 a, B b) static inline UInt8 apply(UInt8 a, B b)
@ -27,7 +27,7 @@ struct AndImpl
} }
}; };
template<typename B> template <typename B>
struct OrImpl struct OrImpl
{ {
static inline UInt8 apply(UInt8 a, B b) static inline UInt8 apply(UInt8 a, B b)
@ -36,7 +36,7 @@ struct OrImpl
} }
}; };
template<typename B> template <typename B>
struct XorImpl struct XorImpl
{ {
static inline UInt8 apply(UInt8 a, B b) static inline UInt8 apply(UInt8 a, B b)

2
dbms/src/IO/HashingWriteBuffer.cpp
View File

@ -7,7 +7,7 @@ namespace DB
/// computation of the hash depends on the partitioning of blocks /// computation of the hash depends on the partitioning of blocks
/// so you need to compute a hash of n complete pieces and one incomplete /// so you need to compute a hash of n complete pieces and one incomplete
template <class Buffer> template <typename Buffer>
void IHashingBuffer<Buffer>::calculateHash(DB::BufferBase::Position data, size_t len) void IHashingBuffer<Buffer>::calculateHash(DB::BufferBase::Position data, size_t len)
{ {
if (len) if (len)

2
dbms/src/IO/HashingWriteBuffer.h
View File

@ -11,7 +11,7 @@
namespace DB namespace DB
{ {
template <class Buffer> template <typename Buffer>
class IHashingBuffer : public BufferWithOwnMemory<Buffer> class IHashingBuffer : public BufferWithOwnMemory<Buffer>
{ {
public: public:

2
dbms/src/IO/ReadHelpers.cpp
View File

@ -19,7 +19,7 @@ namespace ErrorCodes
extern const int INCORRECT_DATA; extern const int INCORRECT_DATA;
} }
template <class IteratorSrc, class IteratorDst> template <typename IteratorSrc, typename IteratorDst>
void parseHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes) void parseHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes)
{ {
size_t src_pos = 0; size_t src_pos = 0;

10
dbms/src/IO/ReadHelpers.h
View File

@ -344,14 +344,14 @@ void readIntTextUnsafe(T & x, ReadBuffer & buf)
x = -x; x = -x;
} }
template<typename T> template <typename T>
void tryReadIntTextUnsafe(T & x, ReadBuffer & buf) void tryReadIntTextUnsafe(T & x, ReadBuffer & buf)
{ {
return readIntTextUnsafe<T, false>(x, buf); return readIntTextUnsafe<T, false>(x, buf);
} }
template <bool throw_exception, class ExcepFun, class NoExcepFun, class... Args> template <bool throw_exception, typename ExcepFun, typename NoExcepFun, typename... Args>
bool exceptionPolicySelector(ExcepFun && excep_f, NoExcepFun && no_excep_f, Args &&... args) bool exceptionPolicySelector(ExcepFun && excep_f, NoExcepFun && no_excep_f, Args &&... args)
{ {
if (throw_exception) if (throw_exception)
@ -482,13 +482,13 @@ ReturnType readFloatTextImpl(T & x, ReadBuffer & buf)
return ReturnType(true); return ReturnType(true);
} }
template <class T> template <typename T>
inline bool tryReadFloatText(T & x, ReadBuffer & buf) inline bool tryReadFloatText(T & x, ReadBuffer & buf)
{ {
return readFloatTextImpl<T, bool>(x, buf); return readFloatTextImpl<T, bool>(x, buf);
} }
template <class T> template <typename T>
inline void readFloatText(T & x, ReadBuffer & buf) inline void readFloatText(T & x, ReadBuffer & buf)
{ {
readFloatTextImpl<T, void>(x, buf); readFloatTextImpl<T, void>(x, buf);
@ -569,7 +569,7 @@ struct NullSink
void parseUUID(const UInt8 * src36, UInt8 * dst16); void parseUUID(const UInt8 * src36, UInt8 * dst16);
void parseUUID(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16); void parseUUID(const UInt8 * src36, std::reverse_iterator<UInt8 *> dst16);
template<class IteratorSrc, class IteratorDst> template <typename IteratorSrc, typename IteratorDst>
void formatHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes); void formatHex(IteratorSrc src, IteratorDst dst, const size_t num_bytes);
/// In YYYY-MM-DD format /// In YYYY-MM-DD format

8
dbms/src/Parsers/ParserCreateQuery.h
View File

@ -56,7 +56,7 @@ protected:
}; };
template <class NameParser> template <typename NameParser>
class IParserNameTypePair : public IParserBase class IParserNameTypePair : public IParserBase
{ {
protected: protected:
@ -69,7 +69,7 @@ using ParserNameTypePair = IParserNameTypePair<ParserIdentifier>;
/** Name and type separated by a space. The name can contain a dot. For example, Hits.URL String. */ /** Name and type separated by a space. The name can contain a dot. For example, Hits.URL String. */
using ParserCompoundNameTypePair = IParserNameTypePair<ParserCompoundIdentifier>; using ParserCompoundNameTypePair = IParserNameTypePair<ParserCompoundIdentifier>;
template <class NameParser> template <typename NameParser>
bool IParserNameTypePair<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected) bool IParserNameTypePair<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{ {
NameParser name_parser; NameParser name_parser;
@ -101,7 +101,7 @@ protected:
}; };
template <class NameParser> template <typename NameParser>
class IParserColumnDeclaration : public IParserBase class IParserColumnDeclaration : public IParserBase
{ {
protected: protected:
@ -112,7 +112,7 @@ protected:
using ParserColumnDeclaration = IParserColumnDeclaration<ParserIdentifier>; using ParserColumnDeclaration = IParserColumnDeclaration<ParserIdentifier>;
using ParserCompoundColumnDeclaration = IParserColumnDeclaration<ParserCompoundIdentifier>; using ParserCompoundColumnDeclaration = IParserColumnDeclaration<ParserCompoundIdentifier>;
template <class NameParser> template <typename NameParser>
bool IParserColumnDeclaration<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected) bool IParserColumnDeclaration<NameParser>::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
{ {
NameParser name_parser; NameParser name_parser;

2
dbms/src/Storages/ColumnDefault.h
View File

@ -21,7 +21,7 @@ enum class ColumnDefaultType
namespace std namespace std
{ {
template<> struct hash<DB::ColumnDefaultType> template <> struct hash<DB::ColumnDefaultType>
{ {
size_t operator()(const DB::ColumnDefaultType type) const size_t operator()(const DB::ColumnDefaultType type) const
{ {

2
dbms/src/Storages/MarkCache.h
View File

@ -53,7 +53,7 @@ public:
return key; return key;
} }
template<typename LoadFunc> template <typename LoadFunc>
MappedPtr getOrSet(const Key & key, LoadFunc && load) MappedPtr getOrSet(const Key & key, LoadFunc && load)
{ {
auto result = Base::getOrSet(key, load); auto result = Base::getOrSet(key, load);

2
dbms/src/Storages/StorageDictionary.h
View File

@ -69,7 +69,7 @@ private:
void checkNamesAndTypesCompatibleWithDictionary(const DictionaryStructure & dictionaryStructure) const; void checkNamesAndTypesCompatibleWithDictionary(const DictionaryStructure & dictionaryStructure) const;
template <class ForwardIterator> template <typename ForwardIterator>
std::string generateNamesAndTypesDescription(ForwardIterator begin, ForwardIterator end) const std::string generateNamesAndTypesDescription(ForwardIterator begin, ForwardIterator end) const
{ {
if (begin == end) if (begin == end)