tb_http_response.hpp

#ifndef TurtleBrains_HTTPResponse_hpp
#define TurtleBrains_HTTPResponse_hpp

#include <turtle_brains/core/tb_configuration.hpp>
#if defined(tb_with_networking)

#include <turtle_brains/core/tb_types.hpp>

#include <vector>

namespace TurtleBrains
{
    namespace Network
    {
        namespace HTTP {
            class Request;

            class Response
            {
            public:
                explicit Response(const tbCore::int32 code = 0, const std::vector<char>& data = std::vector<char>(),
                    const std::vector<tbCore::tbString>& headerLines = std::vector<tbCore::tbString>());
                Response(const Response& other);
                ~Response(void);

                bool IsValid(void) const;
                operator bool() const { return IsValid(); }

                tbCore::int32 GetResponseCode(void) const;
                const tbCore::tbString& GetResponseBody(void) const;
                const std::vector<char>& GetResponseData(void) const;

                bool HasHeader(const tbCore::tbString& header) const;

                const tbCore::tbString& GetHeader(const size_t headerIndex) const;

                size_t GetNumberOfHeaders(void) const;

                const std::vector<tbCore::tbString>& GetHeaders(void) const;

                Response& operator=(const Response& other);

            private:
                friend class TurtleBrains::Network::HTTP::Request;

                std::vector<char> mRawResponseData;
                std::vector<tbCore::tbString> mHeaderLines;
                tbCore::tbString mResponseBody;
                tbCore::int32 mResponseCode;
            };

        }; /* namespace HTTP */
    }; /* namespace Network */
}; /* namespace TurtleBrains */

namespace tbNetwork = TurtleBrains::Network;

#endif /* tb_with_networking */
#endif /* TurtleBrains_HTTPResponse_hpp */