Skip to content

Commit 4cb507b

Browse files
author
Jimmy Jia
committed
Minor fixes to enable building with clang on OS X
For #55
1 parent 5ac5af5 commit 4cb507b

File tree

12 files changed

+102
-56
lines changed

12 files changed

+102
-56
lines changed

‎cppwamp/include/cppwamp/codec.hpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515

1616
#include <set>
1717
#include <stdexcept>
18+
#include <string>
1819

1920
namespace wamp
2021
{

‎cppwamp/include/cppwamp/internal/endian.ipp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
http://www.boost.org/LICENSE_1_0.txt)
66
------------------------------------------------------------------------------*/
77

8-
#include "endian.h"
8+
#include "endian.hpp"
99
#include <boost/endian/conversion.hpp>
1010

1111

‎cppwamp/include/cppwamp/internal/msgpack.ipp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,7 @@ void Msgpack::decodeBuffer(const TBuffer& from, Variant& to)
152152
{
153153
using namespace msgpack;
154154
auto result = unpack(from.data(), from.length(),
155-
[] (type::object_type, uint64_t, void*) {return true;});
155+
[] (type::object_type, std::size_t, void*) {return true;});
156156
const auto& obj = result.get();
157157

158158
Variant v;

‎cppwamp/include/cppwamp/internal/options.ipp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -71,7 +71,7 @@ Options<D>::optionOr(
7171
{
7272
auto iter = options_.find(key);
7373
if (iter != options_.end())
74-
return iter->second.to<ValueTypeOf<T>>();
74+
return iter->second.template to<ValueTypeOf<T>>();
7575
else
7676
return std::forward<T>(fallback);
7777
}

‎cppwamp/include/cppwamp/internal/udsconnector.ipp‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,6 @@
99
#include "asioconnector.hpp"
1010
#include "client.hpp"
1111
#include "config.hpp"
12-
#include "udsopener.hpp"
1312

1413
namespace wamp
1514
{

‎cppwamp/include/cppwamp/internal/variant.ipp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -477,7 +477,7 @@ template <typename TField, typename V> TField& Variant::get(V&& variant)
477477
{
478478
using FieldType = typename std::remove_const<TField>::type;
479479
static_assert(FieldTraits<FieldType>::isValid, "Invalid field type");
480-
if (!variant.is<FieldType>())
480+
if (!variant.template is<FieldType>())
481481
throw error::Access(wamp::typeNameOf(variant),
482482
FieldTraits<FieldType>::typeName());
483483
return Access<FieldType>::get(&variant.field_);

‎cppwamp/include/cppwamp/internal/varianttraits.hpp‎

Lines changed: 15 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -21,24 +21,33 @@ namespace wamp
2121
namespace internal
2222
{
2323

24+
//------------------------------------------------------------------------------
25+
template <typename T> constexpr bool isBool()
26+
{
27+
// std::vector<bool>::const_reference is not just bool in clang/libc++.
28+
return std::is_same<T, Bool>::value ||
29+
std::is_same<T, std::vector<bool>::reference>::value ||
30+
std::is_same<T, std::vector<bool>::const_reference>::value;
31+
}
32+
2433
//------------------------------------------------------------------------------
2534
template <typename T> constexpr bool isNumber()
2635
{
27-
return std::is_arithmetic<T>::value && !std::is_same<T, bool>::value;
36+
return std::is_arithmetic<T>::value && !std::is_same<T, Bool>::value;
2837
}
2938

3039
//------------------------------------------------------------------------------
3140
template <typename T> constexpr bool isSignedInteger()
3241
{
3342
return std::is_integral<T>::value && std::is_signed<T>::value &&
34-
!std::is_same<T,Bool>::value;
43+
!std::is_same<T, Bool>::value;
3544
}
3645

3746
//------------------------------------------------------------------------------
3847
template <typename T> constexpr bool isUnsignedInteger()
3948
{
4049
return std::is_integral<T>::value && !std::is_signed<T>::value &&
41-
!std::is_same<T,Bool>::value;
50+
!std::is_same<T, Bool>::value;
4251
}
4352

4453
//------------------------------------------------------------------------------
@@ -132,20 +141,15 @@ template <> struct ArgTraits<Null>
132141
using FieldType = Null;
133142
};
134143

135-
template <> struct ArgTraits<Bool>
144+
template <typename TField>
145+
struct ArgTraits<TField, typename std::enable_if<
146+
isBool<TField>() >::type >
136147
{
137148
static constexpr bool isValid = true;
138149
static String typeName() {return "Bool";}
139150
using FieldType = Bool;
140151
};
141152

142-
template <> struct ArgTraits<std::vector<bool>::reference>
143-
{
144-
static constexpr bool isValid = true;
145-
static String typeName() {return "std::vector<bool>::reference>";}
146-
using FieldType = Bool;
147-
};
148-
149153
template <typename TField>
150154
struct ArgTraits<TField, typename std::enable_if<
151155
isSignedInteger<TField>() >::type >

‎cppwamp/include/cppwamp/internal/varianttuple.ipp‎

Lines changed: 36 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,16 @@ namespace wamp
1414
namespace internal
1515
{
1616

17-
template<typename TResult, std::size_t N, typename... Ts>
18-
using TupleResult = typename std::enable_if<N != sizeof...(Ts), TResult>::type;
17+
//------------------------------------------------------------------------------
18+
// This should be possible with return type deduction, but clang doesn't like
19+
// that for some reason: http://stackoverflow.com/q/24454664.
20+
template <std::size_t N, typename... Ts>
21+
using EnableIfTupleElement =
22+
typename std::enable_if<N != sizeof...(Ts), int>::type;
1923

20-
template<typename TResult, std::size_t N, typename... Ts>
21-
using TupleLastResult =
22-
typename std::enable_if<N == sizeof...(Ts), TResult>::type;
24+
template <std::size_t N, typename... Ts>
25+
using EnableIfTupleEnd =
26+
typename std::enable_if<N == sizeof...(Ts), int>::type;
2327

2428
//------------------------------------------------------------------------------
2529
template <typename T>
@@ -36,12 +40,11 @@ void assignFromTupleElement(Variant& v, std::tuple<Ts...>&& tuple)
3640
v = toArray(std::move(tuple));
3741
}
3842

39-
template<std::size_t N=0, typename... Ts>
40-
TupleLastResult<void,N,Ts...> assignFromTuple(Array&, std::tuple<Ts...>&&) { }
43+
template<std::size_t N = 0, typename... Ts, EnableIfTupleEnd<N, Ts...> = 0>
44+
void assignFromTuple(Array&, std::tuple<Ts...>&&) {}
4145

42-
template<std::size_t N=0, typename... Ts>
43-
TupleResult<void,N,Ts...> assignFromTuple(Array& array,
44-
std::tuple<Ts...>&& tuple)
46+
template<std::size_t N = 0, typename... Ts, EnableIfTupleElement<N, Ts...> = 0>
47+
void assignFromTuple(Array& array, std::tuple<Ts...>&& tuple)
4548
{
4649
array.push_back(Variant());
4750
assignFromTupleElement(array.back(), std::get<N>(std::move(tuple)));
@@ -70,12 +73,11 @@ void assignToTupleElement(const Variant& v, std::tuple<Ts...>& tuple)
7073
toTuple(v.as<Array>(), tuple);
7174
}
7275

73-
template<std::size_t N=0, typename... Ts>
74-
TupleLastResult<void,N,Ts...> assignToTuple(const Array&, std::tuple<Ts...>&) {}
76+
template<std::size_t N = 0, typename... Ts, EnableIfTupleEnd<N, Ts...> = 0>
77+
void assignToTuple(const Array&, std::tuple<Ts...>&) {}
7578

76-
template<std::size_t N=0, typename... Ts>
77-
TupleResult<void,N,Ts...> assignToTuple(const Array& array,
78-
std::tuple<Ts...>& tuple)
79+
template<std::size_t N = 0, typename... Ts, EnableIfTupleElement<N, Ts...> = 0>
80+
void assignToTuple(const Array& array, std::tuple<Ts...>& tuple)
7981
{
8082
using ElemType = typename std::tuple_element<N, std::tuple<Ts...>>::type;
8183
static_assert(ArgTraits<ElemType>::isValid,
@@ -97,9 +99,12 @@ TupleResult<void,N,Ts...> assignToTuple(const Array& array,
9799
//------------------------------------------------------------------------------
98100
template <typename T> struct TupleTag {};
99101

100-
// Foward declaration
101-
template<std::size_t N=0, typename... Ts>
102-
TupleResult<bool,N,Ts...> isConvertibleToTuple(const Array& array);
102+
// Forward declarations.
103+
template<std::size_t N = 0, typename... Ts, EnableIfTupleEnd<N, Ts...> = 0>
104+
bool isConvertibleToTuple(const Array& array);
105+
106+
template<std::size_t N = 0, typename... Ts, EnableIfTupleElement<N, Ts...> = 0>
107+
bool isConvertibleToTuple(const Array& array);
103108

104109
template <typename T>
105110
bool isConvertibleToTupleElement(const Variant& v, TupleTag<T>)
@@ -114,11 +119,12 @@ bool isConvertibleToTupleElement(const Variant& v, TupleTag<std::tuple<Ts...>>)
114119
isConvertibleToTuple<0,Ts...>(v.as<Array>());
115120
}
116121

117-
template<std::size_t N=0, typename... Ts>
118-
TupleLastResult<bool,N,Ts...> isConvertibleToTuple(const Array&) {return true;}
122+
// Template defaults given in forward declaration.
123+
template<std::size_t N, typename... Ts, EnableIfTupleEnd<N, Ts...>>
124+
bool isConvertibleToTuple(const Array&) {return true;}
119125

120-
template<std::size_t N=0, typename... Ts>
121-
TupleResult<bool,N,Ts...> isConvertibleToTuple(const Array& array)
126+
template<std::size_t N, typename... Ts, EnableIfTupleElement<N, Ts...>>
127+
bool isConvertibleToTuple(const Array& array)
122128
{
123129
using ElemType = typename std::tuple_element<N, std::tuple<Ts...>>::type;
124130
bool result = isConvertibleToTupleElement(array.at(N),
@@ -128,16 +134,14 @@ TupleResult<bool,N,Ts...> isConvertibleToTuple(const Array& array)
128134

129135

130136
//------------------------------------------------------------------------------
131-
template<std::size_t N=0, typename... Ts>
132-
TupleLastResult<bool,N,Ts...> equalsTuple(const Array&,
133-
const std::tuple<Ts...>&)
137+
template<std::size_t N = 0, typename... Ts, EnableIfTupleEnd<N, Ts...> = 0>
138+
bool equalsTuple(const Array&, const std::tuple<Ts...>&)
134139
{
135140
return true;
136141
}
137142

138-
template<std::size_t N=0, typename... Ts>
139-
TupleResult<bool,N,Ts...> equalsTuple(const Array& array,
140-
const std::tuple<Ts...>& tuple)
143+
template<std::size_t N = 0, typename... Ts, EnableIfTupleElement<N, Ts...> = 0>
144+
bool equalsTuple(const Array& array, const std::tuple<Ts...>& tuple)
141145
{
142146
using ElemType = typename std::tuple_element<N, std::tuple<Ts...>>::type;
143147
static_assert(ArgTraits<ElemType>::isValid,
@@ -149,16 +153,14 @@ TupleResult<bool,N,Ts...> equalsTuple(const Array& array,
149153
}
150154

151155
//------------------------------------------------------------------------------
152-
template<std::size_t N=0, typename... Ts>
153-
TupleLastResult<bool,N,Ts...> notEqualsTuple(const Array&,
154-
const std::tuple<Ts...>&)
156+
template<std::size_t N = 0, typename... Ts, EnableIfTupleEnd<N, Ts...> = 0>
157+
bool notEqualsTuple(const Array&, const std::tuple<Ts...>&)
155158
{
156159
return false;
157160
}
158161

159-
template<std::size_t N=0, typename... Ts>
160-
TupleResult<bool,N,Ts...> notEqualsTuple(const Array& array,
161-
const std::tuple<Ts...>& tuple)
162+
template<std::size_t N = 0, typename... Ts, EnableIfTupleElement<N, Ts...> = 0>
163+
bool notEqualsTuple(const Array& array, const std::tuple<Ts...>& tuple)
162164
{
163165
using ElemType = typename std::tuple_element<N, std::tuple<Ts...>>::type;
164166
static_assert(ArgTraits<ElemType>::isValid,

‎cppwamp/include/cppwamp/internal/variantvisitors.hpp‎

Lines changed: 33 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -24,6 +24,14 @@ namespace internal
2424
{
2525

2626
//------------------------------------------------------------------------------
27+
// The !std::is_same is required because std::vector<bool>::const_reference may
28+
// or may not just be bool.
29+
template <typename T>
30+
using EnableIfBoolRef =
31+
typename std::enable_if<
32+
isBool<T>() && !std::is_same<T, bool>::value, int
33+
>::type;
34+
2735
template <typename T, typename U>
2836
constexpr bool bothAreNumbers() {return isNumber<T>() && isNumber<U>();}
2937

@@ -63,19 +71,30 @@ class EquivalentTo : public Visitor<bool>
6371
bool operator()(const TField& lhs, const TField& rhs) const
6472
{return lhs == rhs;}
6573

74+
template <typename TArg, EnableIfBoolRef<TArg> = 0>
75+
bool operator()(const bool lhs, const TArg rhs) const
76+
{return lhs == bool(rhs);}
77+
6678
template <typename TField, typename TArg,
6779
DisableIfBothAreNumbers<TField,TArg> = 0>
6880
bool operator()(const TField&, const TArg&) const {return false;}
6981

7082
template <typename TField, typename TArg,
7183
EnableIfBothAreNumbers<TField,TArg> = 0>
72-
bool operator()(TField lhs, TArg rhs) const {return lhs == rhs;}
84+
bool operator()(const TField lhs, const TArg rhs) const
85+
{return lhs == rhs;}
7386

7487
template <typename TElem, EnableIfNotVariant<TElem> = 0>
7588
bool operator()(const Array& lhs, const std::vector<TElem>& rhs) const
7689
{
77-
return (lhs.size() == rhs.size()) ?
78-
std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin()) : false;
90+
using VecConstRef = typename std::vector<TElem>::const_reference;
91+
// clang libc++ parameterizes equality comparison for default binary
92+
// predicate on iterator value type instead of const reference type,
93+
// which leads to an ambiguous function resolution.
94+
return (lhs.size() != rhs.size()) ? false :
95+
std::equal(lhs.cbegin(), lhs.cend(), rhs.cbegin(),
96+
[](const Variant& lElem, VecConstRef rElem)
97+
{return lElem == rElem;});
7998
}
8099

81100
template <typename TValue, EnableIfNotVariant<TValue> = 0>
@@ -103,6 +122,10 @@ class NotEquivalentTo : public Visitor<bool>
103122
bool operator()(const TField& lhs, const TField& rhs) const
104123
{return lhs != rhs;}
105124

125+
template <typename TArg, EnableIfBoolRef<TArg> = 0>
126+
bool operator()(const bool lhs, const TArg rhs) const
127+
{return lhs != rhs;}
128+
106129
template <typename TField, typename TArg,
107130
DisableIfBothAreNumbers<TField,TArg> = 0>
108131
bool operator()(const TField&, const TArg&) const {return true;}
@@ -114,9 +137,14 @@ class NotEquivalentTo : public Visitor<bool>
114137
template <typename TElem, EnableIfNotVariant<TElem> = 0>
115138
bool operator()(const Array& lhs, const std::vector<TElem>& rhs) const
116139
{
140+
using VecConstRef = typename std::vector<TElem>::const_reference;
141+
// clang libc++ parameterizes equality comparison for default binary
142+
// predicate on iterator value type instead of const reference type,
143+
// which leads to an ambiguous function resolution.
117144
return (lhs.size() != rhs.size()) ? true :
118-
( std::mismatch(lhs.cbegin(), lhs.cend(), rhs.cbegin()).first !=
119-
lhs.end() );
145+
std::mismatch(lhs.cbegin(), lhs.cend(), rhs.cbegin(),
146+
[](const Variant& lElem, VecConstRef rElem)
147+
{return lElem == rElem;}).first != lhs.cend();
120148
}
121149

122150
template <typename TValue, EnableIfNotVariant<TValue> = 0>

‎cppwamp/include/cppwamp/null.hpp‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -35,6 +35,9 @@ namespace wamp
3535
//------------------------------------------------------------------------------
3636
struct Null
3737
{
38+
/// Default constructor. For instantiating const object.
39+
constexpr Null() {}
40+
3841
/// Compares two `Null` objects for equality. @return always `true`.
3942
bool operator==(Null) const;
4043

0 commit comments

Comments
 (0)