Commit be1283e3 authored by Kip Warner's avatar Kip Warner

Fixed a lot of compiler warnings.

parent 957198b8
......@@ -37,3 +37,49 @@ if (PISTACHE_BUILD_TESTS)
enable_testing()
add_subdirectory(tests)
endif()
# Set version...
# Major and minor version...
set(VERSION_MAJOR 0)
set(VERSION_MINOR 0)
# Make available in a header file...
configure_file (
"include/pistache/version.h.in"
"include/pistache/version.h"
@ONLY
)
# Install header...
install (
FILES
${CMAKE_BINARY_DIR}/include/pistache/version.h
DESTINATION
include/pistache/
)
# Configure the pkg-config metadata...
# Initialize the metadata variables to support remote builds...
set(prefix ${CMAKE_INSTALL_PREFIX})
set(exec_prefix ${CMAKE_INSTALL_PREFIX}/bin)
set(libdir ${CMAKE_INSTALL_PREFIX}/lib)
set(includedir ${CMAKE_INSTALL_PREFIX}/include)
set(version ${VERSION_MAJOR}.${VERSION_MINOR})
# Perform substitutions...
configure_file (
"libpistache.pc.in"
"libpistache.pc"
@ONLY
)
# Install pkg-config metadata into standard location within the prefix...
install (
FILES
${CMAKE_BINARY_DIR}/libpistache.pc
DESTINATION
lib/pkgconfig/
)
......@@ -136,8 +136,8 @@ namespace Async {
namespace Private {
struct InternalRethrow {
InternalRethrow(std::exception_ptr exc)
: exc(std::move(exc))
InternalRethrow(std::exception_ptr _exc)
: exc(std::move(_exc))
{ }
std::exception_ptr exc;
......@@ -166,9 +166,9 @@ namespace Async {
};
struct Core {
Core(State state, TypeId id)
: state(state)
, id(id)
Core(State _state, TypeId _id)
: state(_state)
, id(_id)
{ }
State state;
......@@ -839,9 +839,9 @@ namespace Async {
Deferred(Deferred&& other) = default;
Deferred& operator=(Deferred&& other) = default;
Deferred(Resolver resolver, Rejection reject)
: resolver(std::move(resolver))
, rejection(std::move(reject))
Deferred(Resolver _resolver, Rejection _reject)
: resolver(std::move(_resolver))
, rejection(std::move(_reject))
{ }
template<typename U>
......@@ -888,9 +888,9 @@ namespace Async {
Deferred(Deferred&& other) = default;
Deferred& operator=(Deferred&& other) = default;
Deferred(Resolver resolver, Rejection reject)
: resolver(std::move(resolver))
, rejection(std::move(reject))
Deferred(Resolver _resolver, Rejection _reject)
: resolver(std::move(_resolver))
, rejection(std::move(_reject))
{ }
void resolve() {
......@@ -898,8 +898,8 @@ namespace Async {
}
template<typename Exc>
void reject(Exc exc) {
rejection(std::move(exc));
void reject(Exc _exc) {
rejection(std::move(_exc));
}
private:
......@@ -1138,12 +1138,12 @@ namespace Async {
struct All {
struct Data {
Data(const size_t total, Resolver resolver, Rejection rejection)
: total(total)
Data(const size_t _total, Resolver _resolver, Rejection _rejection)
: total(_total)
, resolved(0)
, rejected(false)
, resolve(std::move(resolver))
, reject(std::move(rejection))
, resolve(std::move(_resolver))
, reject(std::move(_rejection))
{ }
const size_t total;
......@@ -1245,8 +1245,8 @@ namespace Async {
private:
template<typename T, size_t Index, typename Data>
struct WhenContinuation {
WhenContinuation(Data data)
: data(std::move(data))
WhenContinuation(Data _data)
: data(std::move(_data))
{ }
void operator()(const T& val) const {
......@@ -1258,8 +1258,8 @@ namespace Async {
template<size_t Index, typename Data>
struct WhenContinuation<void, Index, Data> {
WhenContinuation(Data data)
: data(std::move(data))
WhenContinuation(Data _data)
: data(std::move(_data))
{ }
void operator()() const {
......@@ -1341,9 +1341,9 @@ namespace Async {
>
struct WhenAllRange {
WhenAllRange(Resolver resolve, Rejection reject)
: resolve(std::move(resolve))
, reject(std::move(reject))
WhenAllRange(Resolver _resolve, Rejection _reject)
: resolve(std::move(_resolve))
, reject(std::move(_reject))
{ }
template<typename Iterator>
......@@ -1373,12 +1373,12 @@ namespace Async {
private:
struct Data {
Data(size_t total, Resolver resolver, Rejection rejection)
: total(total)
Data(size_t _total, Resolver _resolver, Rejection _rejection)
: total(_total)
, resolved(0)
, rejected(false)
, resolve(std::move(resolver))
, reject(std::move(rejection))
, resolve(std::move(_resolver))
, reject(std::move(_rejection))
{ }
const size_t total;
......@@ -1419,9 +1419,9 @@ namespace Async {
typedef std::shared_ptr<DataT<ValueType>> D;
WhenContinuation(const D& data, size_t index)
: data(data)
, index(index)
WhenContinuation(const D& _data, size_t _index)
: data(_data)
, index(_index)
{ }
void operator()(const ValueType& val) const {
......@@ -1444,8 +1444,8 @@ namespace Async {
typedef std::shared_ptr<DataT<void>> D;
WhenContinuation(const D& data, size_t)
: data(data)
WhenContinuation(const D& _data, size_t)
: data(_data)
{ }
void operator()() const {
......
......@@ -49,6 +49,9 @@
#define unreachable() __builtin_unreachable()
// Until we require C++17 compiler with [[maybe_unused]]
#define UNUSED(x) (void)(x);
namespace Pistache {
namespace Const {
......
......@@ -44,8 +44,8 @@ public:
typedef std::unordered_map<std::string, Cookie> Storage;
struct iterator : std::iterator<std::bidirectional_iterator_tag, Cookie> {
iterator(const Storage::const_iterator& iterator)
: it_(iterator)
iterator(const Storage::const_iterator& _iterator)
: it_(_iterator)
{ }
Cookie operator*() const {
......
......@@ -379,8 +379,8 @@ public:
Description& basePath(std::string value);
template<typename... Schemes>
Description& schemes(Schemes... schemes) {
Scheme s[sizeof...(Schemes)] = { schemes... };
Description& schemes(Schemes... _schemes) {
Scheme s[sizeof...(Schemes)] = { _schemes... };
std::copy(std::begin(s), std::end(s), std::back_inserter(schemes_));
return *this;
}
......
......@@ -58,7 +58,7 @@ public:
Flags() : val(T::None) {
}
Flags(T val) : val(val)
Flags(T _val) : val(_val)
{
}
......
......@@ -230,19 +230,19 @@ public:
private:
Timeout(const Timeout& other)
: transport(other.transport)
, handler(other.handler)
: handler(other.handler)
, request(other.request)
, transport(other.transport)
, armed(other.armed)
, timerFd(other.timerFd)
{ }
Timeout(Tcp::Transport* transport,
Handler* handler,
Request request)
: transport(transport)
, handler(handler)
, request(std::move(request))
Timeout(Tcp::Transport* transport_,
Handler* handler_,
Request request_)
: handler(handler_)
, request(std::move(request_))
, transport(transport_)
, armed(false)
, timerFd(-1)
{
......@@ -517,7 +517,8 @@ public:
return &buf_;
}
DynamicStreamBuf *rdbuf(DynamicStreamBuf* other) {
DynamicStreamBuf *rdbuf([[maybe_unused]] DynamicStreamBuf* other) {
UNUSED(other)
throw std::domain_error("Unimplemented");
}
......@@ -613,9 +614,9 @@ namespace Private {
};
struct BodyStep : public Step {
BodyStep(Message* message)
: Step(message)
, chunk(message)
BodyStep(Message* message_)
: Step(message_)
, chunk(message_)
, bytesRead(0)
{ }
......@@ -625,8 +626,8 @@ namespace Private {
struct Chunk {
enum Result { Complete, Incomplete, Final };
Chunk(Message* message)
: message(message)
Chunk(Message* message_)
: message(message_)
, bytesRead(0)
, size(-1)
{ }
......@@ -653,15 +654,17 @@ namespace Private {
struct ParserBase {
ParserBase()
: currentStep(0)
, cursor(&buffer)
: cursor(&buffer)
, currentStep(0)
{
}
ParserBase(const char* data, size_t len)
: currentStep(0)
, cursor(&buffer)
: cursor(&buffer)
, currentStep(0)
{
UNUSED(data)
UNUSED(len)
}
ParserBase(const ParserBase& other) = delete;
......
......@@ -14,8 +14,8 @@ struct FlatMapIteratorAdapter {
typedef typename Map::mapped_type Value;
typedef typename Map::const_iterator const_iterator;
FlatMapIteratorAdapter(const_iterator it)
: it(it)
FlatMapIteratorAdapter(const_iterator _it)
: it(_it)
{ }
FlatMapIteratorAdapter operator++() {
......
......@@ -90,14 +90,14 @@ public:
}
T *post(T *newData) {
auto *ret = Mailbox<T>::post(newData);
auto *_ret = Mailbox<T>::post(newData);
if (isBound()) {
uint64_t val = 1;
TRY(write(event_fd, &val, sizeof val));
}
return ret;
return _ret;
}
T *clear() {
......
......@@ -227,7 +227,7 @@ public:
private:
T *const constData() const {
T *constData() const {
return const_cast<T *const>(reinterpret_cast<const T *const>(bytes));
}
......
......@@ -87,8 +87,8 @@ inline constexpr bool operator==(Tag lhs, Tag rhs) {
}
struct Event {
explicit Event(Tag tag) :
tag(tag)
explicit Event(Tag _tag) :
tag(_tag)
{ }
Flags<NotifyOn> flags;
......
......@@ -204,7 +204,7 @@ public:
};
virtual void onReady(const FdSet& fds) = 0;
virtual void registerPoller(Polling::Epoll& poller) { }
virtual void registerPoller(Polling::Epoll& poller) { UNUSED(poller) }
Reactor* reactor() const {
return reactor_;
......
......@@ -228,7 +228,7 @@ namespace Routes {
template<typename... Args>
void static_checks() {
static_assert(sizeof...(Args) == 2, "Function should take 2 parameters");
typedef details::TypeList<Args...> Arguments;
// typedef details::TypeList<Args...> Arguments;
// Disabled now as it
// 1/ does not compile
// 2/ might not be relevant
......
......@@ -133,10 +133,10 @@ struct Buffer {
, isOwned(false)
{ }
Buffer(const char * const data, size_t len, bool own = false)
: data(data)
, len(len)
, isOwned(own)
Buffer(const char * const _data, size_t _len, bool _own = false)
: data(_data)
, len(_len)
, isOwned(_own)
{ }
Buffer detach(size_t fromIndex = 0) const {
......@@ -226,8 +226,8 @@ private:
class StreamCursor {
public:
StreamCursor(StreamBuf<char>* buf, size_t initialPos = 0)
: buf(buf)
StreamCursor(StreamBuf<char>* _buf, size_t initialPos = 0)
: buf(_buf)
{
advance(initialPos);
}
......@@ -235,8 +235,8 @@ public:
static constexpr int Eof = -1;
struct Token {
Token(StreamCursor& cursor)
: cursor(cursor)
Token(StreamCursor& _cursor)
: cursor(_cursor)
, position(cursor.buf->position())
, eback(cursor.buf->begptr())
, gptr(cursor.buf->curptr())
......@@ -270,8 +270,8 @@ public:
};
struct Revert {
Revert(StreamCursor& cursor)
: cursor(cursor)
Revert(StreamCursor& _cursor)
: cursor(_cursor)
, eback(cursor.buf->begptr())
, gptr(cursor.buf->curptr())
, egptr(cursor.buf->endptr())
......
......@@ -88,16 +88,16 @@ private:
enum Type { Raw, File };
explicit BufferHolder(const Buffer& buffer, off_t offset = 0)
: type(Raw)
, u(buffer)
: u(buffer)
, type(Raw)
{
offset_ = offset;
size_ = buffer.len;
}
explicit BufferHolder(const FileBuffer& buffer, off_t offset = 0)
: type(File)
, u(buffer.fd())
: u(buffer.fd())
, type(File)
{
offset_ = offset;
size_ = buffer.size();
......@@ -147,7 +147,7 @@ private:
Fd fd;
U(Buffer buffer) : raw(buffer) { }
U(Fd fd) : fd(fd) { }
U(Fd fd_) : fd(fd_) { }
} u;
size_t size_= 0;
off_t offset_ = 0;
......@@ -155,11 +155,11 @@ private:
};
struct WriteEntry {
WriteEntry(Async::Deferred<ssize_t> deferred,
BufferHolder buffer, int flags = 0)
: deferred(std::move(deferred))
, buffer(std::move(buffer))
, flags(flags)
WriteEntry(Async::Deferred<ssize_t> deferred_,
BufferHolder buffer_, int flags_ = 0)
: deferred(std::move(deferred_))
, buffer(std::move(buffer_))
, flags(flags_)
, peerFd(-1)
{ }
......@@ -170,11 +170,11 @@ private:
};
struct TimerEntry {
TimerEntry(Fd fd, std::chrono::milliseconds value,
Async::Deferred<uint64_t> deferred)
: fd(fd)
, value(value)
, deferred(std::move(deferred))
TimerEntry(Fd fd_, std::chrono::milliseconds value_,
Async::Deferred<uint64_t> deferred_)
: fd(fd_)
, value(value_)
, deferred(std::move(deferred_))
{
active.store(true, std::memory_order_relaxed);
}
......@@ -201,8 +201,8 @@ private:
};
struct PeerEntry {
PeerEntry(std::shared_ptr<Peer> peer)
: peer(std::move(peer))
PeerEntry(std::shared_ptr<Peer> peer_)
: peer(std::move(peer_))
{ }
std::shared_ptr<Peer> peer;
......
/* version.h
Kip Warner, 29 May 2018
Version constants
*/
#pragma once
namespace Pistache {
namespace Version {
static constexpr int Major = @VERSION_MAJOR@;
static constexpr int Minor = @VERSION_MINOR@;
} // namespace Version
} // namespace Pistache
prefix=@prefix@
exec_prefix=@exec_prefix@
libdir=@libdir@
includedir=@includedir@
Name: libpistache
URL: http://pistache.io/
Description: An elegant C++ REST framework.
Version: @version@
Requires:
Libs: -L'${libdir}/' -lpistache -lpthread
Libs.private:
Cflags: -I'${includedir}/'
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment