Enable gcc wall and werror.

src/base/compression/CyclicRedundancyChecker.cpp

@@ -4,7 +4,7 @@ void CyclicRedundancyChecker::createTable()
 {
     mTable = std::vector<unsigned long>(TABLE_SIZE, 0);
     unsigned long c{0};
-    for (int n = 0; n < TABLE_SIZE; n++)
+    for (std::size_t n = 0; n < TABLE_SIZE; n++)
     {
         c = (unsigned long) n;
         for (int k = 0; k < 8; k++)

src/base/compression/Lz77Encoder.cpp

@@ -77,7 +77,7 @@ unsigned Lz77Encoder::lookAheadForMatchingChars(unsigned distance)
             search_char = getSearchBufferItem(static_cast<unsigned>(search_offset));
         }
         unsigned char lookahead_char = mLookaheadBuffer.getItem(idx);
-        if ((lookahead_char != search_char) || (idx == mMaxLookAheadBufferIndex))
+        if ((lookahead_char != search_char) || (static_cast<int>(idx) == mMaxLookAheadBufferIndex))
         {
             if (idx + 1>= mMinLengthMatchSize)
             {

src/base/compression/ZlibEncoder.cpp

@@ -164,6 +164,7 @@ bool ZlibEncoder::decode()
     unsigned char byte3 = *mInputStream->readNextByte();
 
     uint32_t adler32 = (byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3;
+    (void)adler32;
     //std::cout << "Got adler 32 checksum " << adler32 << std::endl;
 
     return valid;

src/base/compression/deflate/DeflateBlock.cpp

@@ -38,6 +38,7 @@ bool DeflateBlock::isFinalBlock() const
 bool DeflateBlock::read()
 {
     auto working_byte = *mInputStream->readNextByte();
+    (void)working_byte;
 
     //std::cout << mInputStream->logNextNBytes(60);
     //std::cout << "DeflateBlock::read location " << mInputStream->logLocation();
@@ -77,6 +78,7 @@ bool DeflateBlock::readUncompressedStream()
     auto byte2 = *mInputStream->readNextByte();
     auto byte3 = *mInputStream->readNextByte();
     uint16_t len_check = (byte2 << 8) | byte3;
+    (void) len_check;
 
     //std::cout << "Check block 2: " << ByteUtils::toString(byte2) << std::endl;
     //std::cout << "Check block 3: " << ByteUtils::toString(byte3) << std::endl;

src/base/compression/huffman/HuffmanCodeLengthTable.cpp

@@ -13,10 +13,10 @@ void HuffmanCodeLengthTable::buildCompressedLengthSequence()
     RunLengthEncoder rl_encoder;
     auto rle_encoded = rl_encoder.encode(mInputLengthSequence);
 
-    for (const auto& entry : rle_encoded)
-    {
+    //for (const auto& entry : rle_encoded)
+    //{
         //std::cout << "Got rle " << static_cast<int>(entry.first) << " | " << entry.second << std::endl;
-    }
+    //}
     mCompressedLengthSequence.clear();
 
     for (const auto& entry : rle_encoded)
@@ -117,7 +117,7 @@ bool HuffmanCodeLengthTable::readNextSymbol(unsigned& result, BitStream* stream)
 
     while(!found)
     {
-        auto valid = stream->readNextNBits(delta, buffer);
+        stream->readNextNBits(delta, buffer);
         //std::cout << "Got buffer " << ByteUtils::toString(buffer) << std::endl;;
 
         unsigned hold = buffer;

src/base/compression/huffman/HuffmanEncoder.cpp

@@ -17,6 +17,7 @@ void HuffmanEncoder::dumpNode(RawNode<CountPair>* node, unsigned depth) const
     }
 
     auto data = node->getData();
+    (void)data;
 
     std::string prefix(depth, '_');
 

src/base/compression/huffman/HuffmanStream.cpp

@@ -211,7 +211,7 @@ void HuffmanStream::readSymbols()
         else if (symbol <= 264)
         {
             auto length = 3 + symbol - 257;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol <= 268)
@@ -220,7 +220,7 @@ void HuffmanStream::readSymbols()
             mInputStream->readNextNBits(1, extra);
 
             auto length = 11 + 2*(symbol - 265) + extra;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol <= 272)
@@ -229,7 +229,7 @@ void HuffmanStream::readSymbols()
             mInputStream->readNextNBits(2, extra);
 
             auto length = 19 + 4*(symbol - 269) + extra;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol <= 276)
@@ -238,7 +238,7 @@ void HuffmanStream::readSymbols()
             mInputStream->readNextNBits(3, extra);
 
             auto length = 35 + 8*(symbol - 273) + extra;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol <= 280)
@@ -247,7 +247,7 @@ void HuffmanStream::readSymbols()
             mInputStream->readNextNBits(4, extra);
 
             auto length = 67 + 16*(symbol - 277) + extra;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol <= 284)
@@ -256,13 +256,13 @@ void HuffmanStream::readSymbols()
             mInputStream->readNextNBits(5, extra);
 
             auto length = 131 + 32*(symbol - 281) + extra;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
         else if (symbol == 285)
         {
             auto length = 258;
-            const auto valid_dist = readNextDistanceSymbol(distance);
+            readNextDistanceSymbol(distance);
             copyFromBuffer(length, distance);
         }
     }

src/base/core/http/HttpHeader.cpp

@@ -3,8 +3,8 @@
 
 
 HttpHeader::HttpHeader()
-    :   mContentType("text / html"),
-        mHttpVersion("1.1")
+    :   mHttpVersion("1.1"),
+        mContentType("text / html")
 {
 
 }

src/base/core/streams/BufferBitStream.cpp

@@ -6,7 +6,7 @@
 
 bool BufferBitStream::isFinished() const
 {
-    return mByteOffset == mBuffer.size() - 1;
+    return mByteOffset == static_cast<int>(mBuffer.size()) - 1;
 }
 
 std::vector<unsigned char> BufferBitStream::peekNextNBytes(unsigned n) const
@@ -35,7 +35,7 @@ std::vector<unsigned char> BufferBitStream::peekNextNBytes(unsigned n) const
 
 std::optional<unsigned char> BufferBitStream::readNextByte()
 {
-    if (mByteOffset + 1 == mBuffer.size())
+    if (mByteOffset + 1 == static_cast<int>(mBuffer.size()))
     {
         return std::nullopt;
     }
@@ -76,3 +76,19 @@ void BufferBitStream::writeByte(unsigned char data, bool checkOverflow)
 }
 
 
+void BufferBitStream::writeBytes(const std::vector<unsigned char> data)
+{
+    std::copy(data.begin(), data.end(), std::back_inserter(mBuffer));
+}
+
+const std::vector<unsigned char>& BufferBitStream::getBuffer() const
+{
+    return mBuffer;
+}
+
+void BufferBitStream::reset()
+{
+    BitStream::reset();
+    mBuffer.clear();
+}
+

src/base/core/streams/BufferBitStream.h

@@ -8,31 +8,21 @@
 class BufferBitStream : public BitStream
 {
 public:
+    const std::vector<unsigned char>& getBuffer() const;
+
     bool isFinished() const override;
 
     std::vector<unsigned char> peekNextNBytes(unsigned n) const override;
 
     std::optional<unsigned char> readNextByte() override;
 
+    void reset() override;
+
     void setBuffer(const std::vector<unsigned char>& data);
 
     void writeByte(unsigned char data, bool checkOverflow = true) override;
 
-    void writeBytes(const std::vector<unsigned char> data) override
-    {
-        std::copy(data.begin(), data.end(), std::back_inserter(mBuffer));
-    }
-
-    const std::vector<unsigned char>& getBuffer() const
-    {
-        return mBuffer;
-    }
-
-    void reset() override
-    {
-        BitStream::reset();
-        mBuffer.clear();
-    }
+    void writeBytes(const std::vector<unsigned char> data) override;
 
 private:
     unsigned mBufferSize{0};

src/base/core/xml/XmlParser.cpp

@@ -12,9 +12,9 @@ using LS = XmlParser::LineState;
 using DS = XmlParser::DocumentState;
 
 XmlParser::XmlParser()
-    : mDocument(XmlDocument::Create()),
-      mDocumentState(XmlParser::DocumentState::Await_Prolog),
+    : mDocumentState(XmlParser::DocumentState::Await_Prolog),
       mLineState(XmlParser::LineState::Await_Tag_Open),
+      mDocument(XmlDocument::Create()),
       mWorkingElements()
 {
 

src/base/geometry/primitives/Circle.cpp

@@ -1,30 +1,31 @@
 #include "Circle.h"
 
 Circle::Circle(const Point& centre, double radius)
-	:	mCentre(centre),
-		mRadius(radius)
+    :   mRadius(radius),
+        mCentre(centre)
+
 {
-	mMinorRadius = mRadius;
+    mMinorRadius = mRadius;
 }
 
 const Point& Circle::getLocation() const
 {
-	return mCentre;
+    return mCentre;
 }
 
 double Circle::getRadius() const
 {
-	return mRadius;
+    return mRadius;
 }
 
 double Circle::getMinorRadius() const
 {
-	return mMinorRadius;
+    return mMinorRadius;
 }
 
 void Circle::setMinorRadius(double radius)
 {
-	mMinorRadius = radius;
+    mMinorRadius = radius;
 }
 
 void Circle::sample(SparseGrid<bool>* grid) const
@@ -34,19 +35,19 @@ void Circle::sample(SparseGrid<bool>* grid) const
 
 bool Circle::isEllipse() const
 {
-	return mRadius != mMinorRadius;
+    return mRadius != mMinorRadius;
 }
 
 Bounds Circle::getBounds() const
 {
-	double minX = mCentre.getX() - mRadius;
-	double maxX = mCentre.getX() + mRadius;
-	double minY = mCentre.getY() - mMinorRadius;
-	double maxY = mCentre.getY() + mMinorRadius;
-	return { minX, maxX, minY, maxY };
+    double minX = mCentre.getX() - mRadius;
+    double maxX = mCentre.getX() + mRadius;
+    double minY = mCentre.getY() - mMinorRadius;
+    double maxY = mCentre.getY() + mMinorRadius;
+    return { minX, maxX, minY, maxY };
 }
 
 Circle::Type Circle::getType() const
 {
-	return Type::CIRCLE;
-}
+    return Type::CIRCLE;
+}

src/base/geometry/primitives/Circle.h

@@ -6,26 +6,26 @@
 class Circle : public AbstractGeometricItem
 {
 public:
-	Circle(const Point& centre, double radius = 0.5);
+    Circle(const Point& centre, double radius = 0.5);
 
-	const Point& getLocation() const override;
+    const Point& getLocation() const override;
 
-	double getRadius() const;
+    double getRadius() const;
 
-	double getMinorRadius() const;
+    double getMinorRadius() const;
 
-	Bounds getBounds() const override;
+    Bounds getBounds() const override;
 
-	Type getType() const override;
+    Type getType() const override;
 
-	bool isEllipse() const;
+    bool isEllipse() const;
 
-	void setMinorRadius(double radius);
+    void setMinorRadius(double radius);
 
-	void sample(SparseGrid<bool>* grid) const override;
+    void sample(SparseGrid<bool>* grid) const override;
 
 private:
-	double mMinorRadius{ 0.5 };
-	double mRadius{ 0.5 };
-	Point mCentre;
-};
+    double mMinorRadius{ 0.5 };
+    double mRadius{ 0.5 };
+    Point mCentre;
+};

src/base/geometry/primitives/Rectangle.cpp

@@ -9,9 +9,10 @@ namespace ntk {
     }
 
     Rectangle::Rectangle(const Point& bottomLeft, double width, double height)
-        : mBottomLeft(bottomLeft),
-            mHeight(height),
-            mWidth(width)
+        :   mBottomLeft(bottomLeft),
+              mWidth(width),
+              mHeight(height)
+
     {
 
     }

src/base/network/NetworkManager.cpp

@@ -1,12 +1,11 @@
 #include "NetworkManager.h"
+
 #ifdef __linux__
 #include "UnixSocketInterface.h"
 #else
 #include "Win32WebServer.h"
 #endif
 
-#include <iostream>
-
 NetworkManager::NetworkManager()
     : mActiveSockets(),
       mSocketInterface()
@@ -44,9 +43,9 @@ void NetworkManager::runHttpServer(AbstractWebApp* webApp)
     }
 
     auto socket = Socket::Create();
-    mSocketInterface->InitializeSocket(socket);
-    mSocketInterface->Listen(socket);
-    mSocketInterface->Run(socket);
+    mSocketInterface->initializeSocket(socket);
+    mSocketInterface->socketListen(socket);
+    mSocketInterface->run(socket);
 #endif
 }
 
@@ -63,8 +62,8 @@ void NetworkManager::runHttpClient()
     }
 
     auto socket = Socket::Create();
-    mSocketInterface->InitializeSocket(socket, "127.0.0.1");
-    mSocketInterface->Write(socket, "Hello Friend");
+    mSocketInterface->initializeSocket(socket, "127.0.0.1");
+    mSocketInterface->socketWrite(socket, "Hello Friend");
 }
 
 void NetworkManager::shutDown()

src/base/network/NetworkManager.h

@@ -11,7 +11,6 @@ class AbstractWebApp;
 class NetworkManager
 {
 public:
-
     NetworkManager();
 
     ~NetworkManager();

src/base/network/sockets/Socket.cpp

@@ -1,9 +1,10 @@
 #include "Socket.h"
 
 Socket::Socket()
-    : mPort(8888),
-      mMessage(),
-      mHandle(-1)
+    : mHandle(-1),
+        mPort(8888),
+      mMessage()
+
 {
 
 }
@@ -13,12 +14,12 @@ Socket::~Socket()
 
 }
 
-void Socket::SetHandle(SocketHandle handle)
+void Socket::setHandle(SocketHandle handle)
 {
     mHandle = handle;
 }
 
-Socket::SocketHandle Socket::GetHandle() const
+Socket::SocketHandle Socket::getHandle() const
 {
     return mHandle;
 }
@@ -28,33 +29,33 @@ std::unique_ptr<Socket> Socket::Create()
     return std::make_unique<Socket>();
 }
 
-std::string Socket::GetMessage() const
+std::string Socket::getMessage() const
 {
     return mMessage;
 }
 
-void Socket::SetMessage(const std::string& message)
+void Socket::setMessage(const std::string& message)
 {
     mMessage = message;
 }
 
-void Socket::SetPort(unsigned port)
+void Socket::setPort(unsigned port)
 {
     mPort = port;
 }
 
-unsigned Socket::GetPort() const
+unsigned Socket::getPort() const
 {
     return mPort;
 }
 
 std::string Socket::getAddress() const
 {
-	return mAddress;
+    return mAddress;
 }
 
 
 void Socket::setAddress(const std::string& address)
 {
-	mAddress = address;
+    mAddress = address;
 }

src/base/network/sockets/Socket.h

@@ -14,23 +14,23 @@ public:
 
     static std::unique_ptr<Socket> Create();
 
-    void SetPort(unsigned port);
-
-    void SetHandle(SocketHandle handle);
-
-    SocketHandle GetHandle() const;
-
-    unsigned GetPort() const;
-
-    std::string GetMessage() const;
-
-    void SetMessage(const std::string& message);
-
     std::string getAddress() const;
+
+    SocketHandle getHandle() const;
+
+    unsigned getPort() const;
+
+    std::string getMessage() const;
+
+    void setPort(unsigned port);
+
+    void setHandle(SocketHandle handle);
+
+    void setMessage(const std::string& message);
+
     void setAddress(const std::string& address);
 
 private:
-
     SocketHandle mHandle;
     unsigned mPort{0};
     std::string mMessage;

src/base/network/sockets/SocketInterface.h

@@ -8,16 +8,15 @@ using SocketPtr = std::unique_ptr<Socket>;
 class ISocketInterface
 {
 public:
-
     ISocketInterface() = default;
 
     virtual ~ISocketInterface() = default;
 
-    virtual void InitializeSocket(const SocketPtr& socket, const std::string& address = {}) = 0;
-    virtual void Listen(const SocketPtr& socket) = 0;
-    virtual void Run(const SocketPtr& socket) = 0;
+    virtual void initializeSocket(const SocketPtr& socket, const std::string& address = {}) = 0;
+    virtual void socketListen(const SocketPtr& socket) = 0;
+    virtual void run(const SocketPtr& socket) = 0;
 
-    virtual void Write(const SocketPtr& socket, const std::string& message) = 0;
+    virtual void socketWrite(const SocketPtr& socket, const std::string& message) = 0;
 };
 
 using ISocketInterfaceUPtr = std::unique_ptr<ISocketInterface>;

src/base/network/sockets/UnixSocketInterface.cpp

@@ -16,7 +16,7 @@
 UnixSocketInterface::UnixSocketInterface()
     : mBufferSize(1024)
 {
-	mMessageHandler = std::make_unique<HttpMessageHandler>();
+    mMessageHandler = std::make_unique<HttpMessageHandler>();
 }
 
 std::unique_ptr<UnixSocketInterface> UnixSocketInterface::Create()
@@ -29,26 +29,26 @@ UnixSocketInterface::~UnixSocketInterface()
 
 }
 
-void UnixSocketInterface::InitializeSocket(const SocketPtr& socketPtr, const std::string& address)
+void UnixSocketInterface::initializeSocket(const SocketPtr& socketPtr, const std::string& address)
 {
     auto handle = ::socket(AF_INET, SOCK_STREAM, 0);
-    socketPtr->SetHandle(handle);
+    socketPtr->setHandle(handle);
 
     if (!address.empty())
     {
-    	socketPtr->setAddress(address);
+        socketPtr->setAddress(address);
     }
 }
 
-void UnixSocketInterface::Write(const SocketPtr& socket, const std::string& message)
+void UnixSocketInterface::socketWrite(const SocketPtr& socket, const std::string& message)
 {
-    if(socket->GetHandle() < 0)
+    if(socket->getHandle() < 0)
     {
          MLOG_ERROR("Error opening socket" );
          return;
     }
 
-    const auto port = static_cast<int>(socket->GetPort());
+    const auto port = static_cast<int>(socket->getPort());
     struct sockaddr_in serv_addr;
     memset(&serv_addr, 0, sizeof(serv_addr));
     serv_addr.sin_family = AF_INET;
@@ -56,14 +56,14 @@ void UnixSocketInterface::Write(const SocketPtr& socket, const std::string& mess
     inet_aton(socket->getAddress().c_str(), &serv_addr.sin_addr);
     serv_addr.sin_port = htons(port);
 
-    int result = connect(socket->GetHandle(), (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    int result = connect(socket->getHandle(), (struct sockaddr *)&serv_addr, sizeof(serv_addr));
     if(result< 0)
     {
         MLOG_ERROR("Error connecting to socket" );
         return;
     }
 
-    auto n = write(socket->GetHandle(), message.c_str(), message.length());
+    auto n = write(socket->getHandle(), message.c_str(), message.length());
     if (n < 0)
     {
          std::cerr << "Error on write" << std::endl;
@@ -71,44 +71,44 @@ void UnixSocketInterface::Write(const SocketPtr& socket, const std::string& mess
     }
 
     char buffer[BUFFER_SIZE] = {0};
-    int res = read(socket->GetHandle(), buffer, BUFFER_SIZE);
+    int res = read(socket->getHandle(), buffer, BUFFER_SIZE);
     if (res < 0)
     {
         std::cerr << "Error on read" << std::endl;
         return;
     }
-    socket->SetMessage(buffer);
+    socket->setMessage(buffer);
     std::cout << "Here is the message: " << buffer << std::endl;
 }
 
-void UnixSocketInterface::Listen(const SocketPtr& socket)
+void UnixSocketInterface::socketListen(const SocketPtr& socket)
 {
-    if(socket->GetHandle() < 0)
+    if(socket->getHandle() < 0)
     {
          std::cerr << "Error opening socket" << std::endl;
          return;
     }
 
-    const auto port = static_cast<int>(socket->GetPort());
+    const auto port = static_cast<int>(socket->getPort());
     struct sockaddr_in serv_addr;
     memset(&serv_addr, 0, sizeof(serv_addr));
     serv_addr.sin_family = AF_INET;
     serv_addr.sin_addr.s_addr = INADDR_ANY;
     serv_addr.sin_port = htons(port);
 
-    int result = bind(socket->GetHandle(), (struct sockaddr *)&serv_addr, sizeof(serv_addr));
+    int result = bind(socket->getHandle(), (struct sockaddr *)&serv_addr, sizeof(serv_addr));
     if(result< 0)
     {
         std::cerr << "Error binding socket" << std::endl;
         return;
     }
 
-    listen(socket->GetHandle(), 5);
+    listen(socket->getHandle(), 5);
 }
 
-void UnixSocketInterface::Run(const SocketPtr& socket)
+void UnixSocketInterface::run(const SocketPtr& socket)
 {
-    if(socket->GetHandle() < 0)
+    if(socket->getHandle() < 0)
     {
          std::cerr << "Error opening socket" << std::endl;
          return;
@@ -118,7 +118,7 @@ void UnixSocketInterface::Run(const SocketPtr& socket)
     socklen_t clilen = sizeof(cli_addr);
     while(true)
     {
-        const auto new_socket_handle = accept(socket->GetHandle(), (struct sockaddr *) &cli_addr, &clilen);
+        const auto new_socket_handle = accept(socket->getHandle(), (struct sockaddr *) &cli_addr, &clilen);
         if (new_socket_handle < 0)
         {
             std::cerr << "Error on accept" << std::endl;
@@ -132,7 +132,7 @@ void UnixSocketInterface::Run(const SocketPtr& socket)
             std::cerr << "Error on read" << std::endl;
             return;
         }
-        socket->SetMessage(buffer);
+        socket->setMessage(buffer);
         std::cout << "Here is the message: " << buffer << std::endl;
 
         const auto response = mMessageHandler->onMessage(buffer);

src/base/network/sockets/UnixSocketInterface.h

@@ -10,25 +10,22 @@ class ISocketMessageHandler;
 
 class UnixSocketInterface : public ISocketInterface
 {
-
 public:
-
     UnixSocketInterface();
 
     virtual ~UnixSocketInterface();
 
     static std::unique_ptr<UnixSocketInterface> Create();
 
-    void InitializeSocket(const SocketPtr& socket, const std::string& address = {}) override;
+    void initializeSocket(const SocketPtr& socket, const std::string& address = {}) override;
 
-    void Listen(const SocketPtr& socket) override;
+    void socketListen(const SocketPtr& socket) override;
 
-    void Write(const SocketPtr& socket, const std::string& message) override;
+    void socketWrite(const SocketPtr& socket, const std::string& message) override;
 
-    void Run(const SocketPtr& socket) override;
+    void run(const SocketPtr& socket) override;
 
 private:
-
     static constexpr unsigned BUFFER_SIZE{1024};
     std::size_t mBufferSize { 0 };
     std::unique_ptr<ISocketMessageHandler> mMessageHandler;