third-party/SimpleAmqpClient
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: implement BasicMessage and core AMQP client infrastructure

Browse Source
This commit is contained in:
bing
2026-04-03 15:35:49 +08:00
parent 2974a3dec5
commit ff8ff1189a
29 changed files with 1031 additions and 987 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
CMakeLists.txt
View File

@@ -8,7 +8,7 @@ cmake_minimum_required(VERSION 3.5)
project(SimpleAmqpClient LANGUAGES CXX)
if(NOT DEFINED CMAKE_CXX_STANDARD)
set(CMAKE_CXX_STANDARD 98)
set(CMAKE_CXX_STANDARD 17)
endif()
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)
@@ -45,30 +45,6 @@ set(SAC_APIVERSION ${_API_VERSION_MAJOR}.${_API_VERSION_MINOR}.${_API_VERSION_PA
option(BUILD_SHARED_LIBS "Build SimpleAmqpClient as a shared library" ON)
# Force the use of static boost library for static libraries
include(CMakeDependentOption)
cmake_dependent_option(
Boost_Dynamic_Linking_ENABLED
"Enable boost dynamic linking"
ON
"BUILD_SHARED_LIBS"
OFF
)
if(Boost_Dynamic_Linking_ENABLED)
set(Boost_USE_STATIC_LIBS OFF)
else()
set(Boost_USE_STATIC_LIBS ON)
endif()
set(Boost_USE_STATIC_RUNTIME OFF)
find_package(Boost 1.47.0 COMPONENTS chrono REQUIRED)
if(Boost_VERSION VERSION_LESS 1.89)
find_package(Boost 1.47.0 COMPONENTS chrono system REQUIRED)
endif()
include_directories(SYSTEM ${Boost_INCLUDE_DIRS})
link_directories(${Boost_LIBRARY_DIRS})
# Try using the CMake config modules first
find_package(rabbitmq-c CONFIG QUIET)
@@ -158,16 +134,12 @@ set(SAC_LIB_SRCS
add_library(SimpleAmqpClient ${SAC_LIB_SRCS})
target_link_libraries(SimpleAmqpClient ${Rabbitmqc_LIBRARY} ${SOCKET_LIBRARY} ${Boost_LIBRARIES} $<$<BOOL:${Boost_Dynamic_Linking_ENABLED}>:Boost::dynamic_linking>)
target_link_libraries(SimpleAmqpClient ${Rabbitmqc_LIBRARY} ${SOCKET_LIBRARY})
if (WIN32)
if (NOT BUILD_SHARED_LIBS)
target_compile_definitions(SimpleAmqpClient PUBLIC SimpleAmqpClient_STATIC)
endif ()
set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} OUTPUT_NAME SimpleAmqpClient.${SAC_SOVERSION})
else ()
set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} SOVERSION ${SAC_SOVERSION})
endif ()
# Some smoke tests:
@@ -177,24 +149,7 @@ option(ENABLE_TESTING "Enable smoke tests" OFF)
if (ENABLE_TESTING)
enable_testing()
set(BUILD_GTEST ON CACHE BOOL "" FORCE)
set(BUILD_GMOCK OFF CACHE BOOL "" FORCE)
set(INSTALL_GTEST OFF CACHE BOOL "" FORCE)
# This only affects targets declared after this.
set(BUILD_SHARED_LIBS OFF)
mark_as_advanced(BUILD_GMOCK)
mark_as_advanced(BUILD_GTEST)
mark_as_advanced(INSTALL_GTEST)
mark_as_advanced(gmock_build_tests)
mark_as_advanced(gtest_build_samples)
mark_as_advanced(gtest_build_tests)
mark_as_advanced(gtest_disable_pthreads)
mark_as_advanced(gtest_force_shared_crt)
mark_as_advanced(gtest_hide_internal_symbols)
add_subdirectory(third-party/googletest)
find_package(xgoogletest CONFIG REQUIRED)
add_subdirectory(testing)
endif (ENABLE_TESTING)
@@ -284,7 +239,7 @@ else (BUILD_SHARED_LIBS)
set(extra_win32_targets "${Rabbitmqc_LIBRARY};${SOCKET_LIBRARY}")
endif (BUILD_SHARED_LIBS)
foreach(_lib ${Boost_LIBRARIES} ${extra_win32_targets})
foreach(_lib ${extra_win32_targets})
# Check if FindBoost.cmake provided actual library paths or targets
if(TARGET ${_lib})

9
CMakeUserPresets.json Normal file
View File

@@ -0,0 +1,9 @@
{
"version": 4,
"vendor": {
"conan": {}
},
"include": [
"build/Release/generators/CMakePresets.json"
]
}

23
LICENSE-MIT
View File

@@ -1,23 +0,0 @@
The MIT License (MIT)
Copyright (c) 2010-2014 Alan Antonuk. All Rights Reserved.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this software and associated documentation
files (the "Software"), to deal in the Software without
restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

90
conanfile.py Normal file
View File

@@ -0,0 +1,90 @@
from conan import ConanFile
from conan.tools.cmake import CMake, CMakeToolchain, CMakeDeps, cmake_layout
from conan.tools.files import copy
import os
class SimpleAmqpClientConan(ConanFile):
name = "simpleamqpclient"
version = "2.5.1"
description = "Simple C++ Wrapper around rabbitmq-c"
url = "https://github.com/alanxz/SimpleAmqpClient"
license = "MIT"
author = "Alan Antonuk"
topics = ("rabbitmq", "amqp", "client", "message-queue", "cpp")
settings = "os", "compiler", "build_type", "arch"
package_type = "library"
options = {
"shared": [True, False],
"fPIC": [True, False],
"with_test": [True, False]
}
default_options = {
"shared": False,
"fPIC": True,
"with_test": True
}
exports_sources = "CMakeLists.txt", "Modules/*", "src/*", "testing/*", "third-party/*", "Doxyfile.in", "libSimpleAmqpClient.pc.in"
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def configure(self):
if self.options.shared:
self.options.rm_safe("fPIC")
def layout(self):
cmake_layout(self)
def requirements(self):
self.requires("rabbitmq-c/[>=0.11.0]", transitive_headers=True, transitive_libs=True)
def build_requirements(self):
if self.options.with_test:
self.test_requires("xgoogletest/1.17.1")
def generate(self):
tc = CMakeToolchain(self)
tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
tc.variables["ENABLE_TESTING"] = self.options.with_test
tc.variables["BUILD_API_DOCS"] = False
tc.generate()
deps = CMakeDeps(self)
deps.set_property("rabbitmq-c", "cmake_target_name", "rabbitmq::rabbitmq" if self.options.shared else "rabbitmq::rabbitmq-static")
deps.generate()
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
if self.options.with_test:
cmake.test()
def package(self):
cmake = CMake(self)
cmake.install()
copy(self, "LICENSE-MIT", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
def package_info(self):
self.cpp_info.set_property("cmake_file_name", "simpleamqpclient")
self.cpp_info.set_property("cmake_target_name", "simpleamqpclient::simpleamqpclient")
# When simpleamqpclient builds as static on windows, we need SimpleAmqpClient_STATIC
if not self.options.shared and self.settings.os == "Windows":
self.cpp_info.defines.append("SimpleAmqpClient_STATIC")
libs_name = "SimpleAmqpClient"
# In the CMakeLists.txt:
# set_target_properties(SimpleAmqpClient PROPERTIES VERSION ${SAC_VERSION} OUTPUT_NAME SimpleAmqpClient.${SAC_SOVERSION})
# Note on Windows it sets SimpleAmqpClient.7, but conan usually links `SimpleAmqpClient.7.lib` or similar. We'll simplify and use SimpleAmqpClient.7 if we really need to, but often CMake finds it via exported targets. Let's provide the base name here.
# Actually in Windows if shared, CMake generates SimpleAmqpClient.lib or SimpleAmqpClient.7.lib. Let's just use "SimpleAmqpClient".
self.cpp_info.libs = ["SimpleAmqpClient"]
if self.settings.os == "Windows":
self.cpp_info.system_libs.append("ws2_32")
self.cpp_info.requires = ["rabbitmq-c::rabbitmq-c"]

51
src/AmqpException.cpp
View File

@@ -1,3 +1,5 @@
#include <sstream>
#include <cassert>
/*
* ***** BEGIN LICENSE BLOCK *****
* Version: MIT
@@ -32,35 +34,36 @@
#include <amqp_framing.h>
#include <assert.h>
#include <boost/lexical_cast.hpp>
#include <string>
#include <stdexcept>
namespace AmqpClient {
const boost::uint16_t ContentTooLargeException::REPLY_CODE =
const uint16_t ContentTooLargeException::REPLY_CODE =
AMQP_CONTENT_TOO_LARGE;
const boost::uint16_t NoRouteException::REPLY_CODE = AMQP_NO_ROUTE;
const boost::uint16_t NoConsumersException::REPLY_CODE = AMQP_NO_CONSUMERS;
const boost::uint16_t AccessRefusedException::REPLY_CODE = AMQP_ACCESS_REFUSED;
const boost::uint16_t NotFoundException::REPLY_CODE = AMQP_NOT_FOUND;
const boost::uint16_t ResourceLockedException::REPLY_CODE =
const uint16_t NoRouteException::REPLY_CODE = AMQP_NO_ROUTE;
const uint16_t NoConsumersException::REPLY_CODE = AMQP_NO_CONSUMERS;
const uint16_t AccessRefusedException::REPLY_CODE = AMQP_ACCESS_REFUSED;
const uint16_t NotFoundException::REPLY_CODE = AMQP_NOT_FOUND;
const uint16_t ResourceLockedException::REPLY_CODE =
AMQP_RESOURCE_LOCKED;
const boost::uint16_t PreconditionFailedException::REPLY_CODE =
const uint16_t PreconditionFailedException::REPLY_CODE =
AMQP_PRECONDITION_FAILED;
const boost::uint16_t ConnectionForcedException::REPLY_CODE =
const uint16_t ConnectionForcedException::REPLY_CODE =
AMQP_CONNECTION_FORCED;
const boost::uint16_t InvalidPathException::REPLY_CODE = AMQP_INVALID_PATH;
const boost::uint16_t FrameErrorException::REPLY_CODE = AMQP_FRAME_ERROR;
const boost::uint16_t SyntaxErrorException::REPLY_CODE = AMQP_SYNTAX_ERROR;
const boost::uint16_t CommandInvalidException::REPLY_CODE =
const uint16_t InvalidPathException::REPLY_CODE = AMQP_INVALID_PATH;
const uint16_t FrameErrorException::REPLY_CODE = AMQP_FRAME_ERROR;
const uint16_t SyntaxErrorException::REPLY_CODE = AMQP_SYNTAX_ERROR;
const uint16_t CommandInvalidException::REPLY_CODE =
AMQP_COMMAND_INVALID;
const boost::uint16_t ChannelErrorException::REPLY_CODE = AMQP_CHANNEL_ERROR;
const boost::uint16_t UnexpectedFrameException::REPLY_CODE =
const uint16_t ChannelErrorException::REPLY_CODE = AMQP_CHANNEL_ERROR;
const uint16_t UnexpectedFrameException::REPLY_CODE =
AMQP_UNEXPECTED_FRAME;
const boost::uint16_t ResourceErrorException::REPLY_CODE = AMQP_RESOURCE_ERROR;
const boost::uint16_t NotAllowedException::REPLY_CODE = AMQP_NOT_ALLOWED;
const boost::uint16_t NotImplementedException::REPLY_CODE =
const uint16_t ResourceErrorException::REPLY_CODE = AMQP_RESOURCE_ERROR;
const uint16_t NotAllowedException::REPLY_CODE = AMQP_NOT_ALLOWED;
const uint16_t NotImplementedException::REPLY_CODE =
AMQP_NOT_IMPLEMENTED;
const boost::uint16_t InternalErrorException::REPLY_CODE = AMQP_INTERNAL_ERROR;
const uint16_t InternalErrorException::REPLY_CODE = AMQP_INTERNAL_ERROR;
void AmqpException::Throw(const amqp_rpc_reply_t &reply) {
assert(reply.reply_type == AMQP_RESPONSE_SERVER_EXCEPTION);
@@ -77,7 +80,7 @@ void AmqpException::Throw(const amqp_rpc_reply_t &reply) {
throw std::logic_error(
std::string(
"Programming error: unknown server exception class/method")
.append(boost::lexical_cast<std::string>(reply.reply.id)));
.append(std::to_string(reply.reply.id)));
}
}
@@ -124,7 +127,7 @@ void AmqpException::Throw(const amqp_channel_close_t &reply) {
default:
throw std::logic_error(
std::string("Programming error: unknown channel reply code: ")
.append(boost::lexical_cast<std::string>(reply.reply_code)));
.append(std::to_string(reply.reply_code)));
}
}
@@ -186,14 +189,14 @@ void AmqpException::Throw(const amqp_connection_close_t &reply) {
default:
throw std::logic_error(
std::string("Programming error: unknown connection reply code: ")
.append(boost::lexical_cast<std::string>(reply.reply_code)));
.append(std::to_string(reply.reply_code)));
}
}
AmqpException::AmqpException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: std::runtime_error(what),
m_reply_text(reply_text),
m_class_id(class_id),

90
src/BasicMessage.cpp
View File

@@ -32,7 +32,7 @@
#include <amqp.h>
#include <amqp_framing.h>
#include <boost/optional/optional.hpp>
#include <optional>
#include <cstring>
#include <string>
@@ -42,20 +42,20 @@ namespace AmqpClient {
struct BasicMessage::Impl {
std::string body;
boost::optional<std::string> content_type;
boost::optional<std::string> content_encoding;
boost::optional<delivery_mode_t> delivery_mode;
boost::optional<boost::uint8_t> priority;
boost::optional<std::string> correlation_id;
boost::optional<std::string> reply_to;
boost::optional<std::string> expiration;
boost::optional<std::string> message_id;
boost::optional<boost::uint64_t> timestamp;
boost::optional<std::string> type;
boost::optional<std::string> user_id;
boost::optional<std::string> app_id;
boost::optional<std::string> cluster_id;
boost::optional<Table> header_table;
std::optional<std::string> content_type;
std::optional<std::string> content_encoding;
std::optional<delivery_mode_t> delivery_mode;
std::optional<uint8_t> priority;
std::optional<std::string> correlation_id;
std::optional<std::string> reply_to;
std::optional<std::string> expiration;
std::optional<std::string> message_id;
std::optional<uint64_t> timestamp;
std::optional<std::string> type;
std::optional<std::string> user_id;
std::optional<std::string> app_id;
std::optional<std::string> cluster_id;
std::optional<Table> header_table;
};
BasicMessage::BasicMessage() : m_impl(new Impl) {}
@@ -74,7 +74,7 @@ void BasicMessage::Body(const std::string& body) { m_impl->body = body; }
const std::string& BasicMessage::ContentType() const {
if (ContentTypeIsSet()) {
return m_impl->content_type.get();
return m_impl->content_type.value();
}
static const std::string empty;
return empty;
@@ -85,14 +85,14 @@ void BasicMessage::ContentType(const std::string& content_type) {
}
bool BasicMessage::ContentTypeIsSet() const {
return m_impl->content_type.is_initialized();
return m_impl->content_type.has_value();
}
void BasicMessage::ContentTypeClear() { m_impl->content_type.reset(); }
const std::string& BasicMessage::ContentEncoding() const {
if (ContentEncodingIsSet()) {
return m_impl->content_encoding.get();
return m_impl->content_encoding.value();
}
static const std::string empty;
return empty;
@@ -103,7 +103,7 @@ void BasicMessage::ContentEncoding(const std::string& content_encoding) {
}
bool BasicMessage::ContentEncodingIsSet() const {
return m_impl->content_encoding.is_initialized();
return m_impl->content_encoding.has_value();
}
void BasicMessage::ContentEncodingClear() { m_impl->content_encoding.reset(); }
@@ -117,28 +117,28 @@ void BasicMessage::DeliveryMode(delivery_mode_t delivery_mode) {
}
bool BasicMessage::DeliveryModeIsSet() const {
return m_impl->delivery_mode.is_initialized();
return m_impl->delivery_mode.has_value();
}
void BasicMessage::DeliveryModeClear() { m_impl->delivery_mode.reset(); }
boost::uint8_t BasicMessage::Priority() const {
uint8_t BasicMessage::Priority() const {
return m_impl->priority.value_or(0);
}
void BasicMessage::Priority(boost::uint8_t priority) {
void BasicMessage::Priority(uint8_t priority) {
m_impl->priority = priority;
}
bool BasicMessage::PriorityIsSet() const {
return m_impl->priority.is_initialized();
return m_impl->priority.has_value();
}
void BasicMessage::PriorityClear() { m_impl->priority.reset(); }
const std::string& BasicMessage::CorrelationId() const {
if (CorrelationIdIsSet()) {
return m_impl->correlation_id.get();
return m_impl->correlation_id.value();
}
static const std::string empty;
return empty;
@@ -149,14 +149,14 @@ void BasicMessage::CorrelationId(const std::string& correlation_id) {
}
bool BasicMessage::CorrelationIdIsSet() const {
return m_impl->correlation_id.is_initialized();
return m_impl->correlation_id.has_value();
}
void BasicMessage::CorrelationIdClear() { m_impl->correlation_id.reset(); }
const std::string& BasicMessage::ReplyTo() const {
if (ReplyToIsSet()) {
return m_impl->reply_to.get();
return m_impl->reply_to.value();
}
static const std::string empty;
return empty;
@@ -167,14 +167,14 @@ void BasicMessage::ReplyTo(const std::string& reply_to) {
}
bool BasicMessage::ReplyToIsSet() const {
return m_impl->reply_to.is_initialized();
return m_impl->reply_to.has_value();
}
void BasicMessage::ReplyToClear() { m_impl->reply_to.reset(); }
const std::string& BasicMessage::Expiration() const {
if (ExpirationIsSet()) {
return m_impl->expiration.get();
return m_impl->expiration.value();
}
static const std::string empty;
return empty;
@@ -185,14 +185,14 @@ void BasicMessage::Expiration(const std::string& expiration) {
}
bool BasicMessage::ExpirationIsSet() const {
return m_impl->expiration.is_initialized();
return m_impl->expiration.has_value();
}
void BasicMessage::ExpirationClear() { m_impl->expiration.reset(); }
const std::string& BasicMessage::MessageId() const {
if (MessageIdIsSet()) {
return m_impl->message_id.get();
return m_impl->message_id.value();
}
static const std::string empty;
return empty;
@@ -203,27 +203,27 @@ void BasicMessage::MessageId(const std::string& message_id) {
}
bool BasicMessage::MessageIdIsSet() const {
return m_impl->message_id.is_initialized();
return m_impl->message_id.has_value();
}
void BasicMessage::MessageIdClear() { m_impl->message_id.reset(); }
boost::uint64_t BasicMessage::Timestamp() const {
uint64_t BasicMessage::Timestamp() const {
return m_impl->timestamp.value_or(0);
}
void BasicMessage::Timestamp(boost::uint64_t timestamp) {
void BasicMessage::Timestamp(uint64_t timestamp) {
m_impl->timestamp = timestamp;
}
bool BasicMessage::TimestampIsSet() const {
return m_impl->timestamp.is_initialized();
return m_impl->timestamp.has_value();
}
void BasicMessage::TimestampClear() { m_impl->timestamp.reset(); }
const std::string& BasicMessage::Type() const {
if (TypeIsSet()) {
return m_impl->type.get();
return m_impl->type.value();
}
static const std::string empty;
return empty;
@@ -231,13 +231,13 @@ const std::string& BasicMessage::Type() const {
void BasicMessage::Type(const std::string& type) { m_impl->type = type; }
bool BasicMessage::TypeIsSet() const { return m_impl->type.is_initialized(); }
bool BasicMessage::TypeIsSet() const { return m_impl->type.has_value(); }
void BasicMessage::TypeClear() { m_impl->type.reset(); }
const std::string& BasicMessage::UserId() const {
if (UserIdIsSet()) {
return m_impl->user_id.get();
return m_impl->user_id.value();
}
static const std::string empty;
return empty;
@@ -248,14 +248,14 @@ void BasicMessage::UserId(const std::string& user_id) {
}
bool BasicMessage::UserIdIsSet() const {
return m_impl->user_id.is_initialized();
return m_impl->user_id.has_value();
}
void BasicMessage::UserIdClear() { m_impl->user_id.reset(); }
const std::string& BasicMessage::AppId() const {
if (AppIdIsSet()) {
return m_impl->app_id.get();
return m_impl->app_id.value();
}
static const std::string empty;
return empty;
@@ -264,14 +264,14 @@ const std::string& BasicMessage::AppId() const {
void BasicMessage::AppId(const std::string& app_id) { m_impl->app_id = app_id; }
bool BasicMessage::AppIdIsSet() const {
return m_impl->app_id.is_initialized();
return m_impl->app_id.has_value();
}
void BasicMessage::AppIdClear() { m_impl->app_id.reset(); }
const std::string& BasicMessage::ClusterId() const {
if (ClusterIdIsSet()) {
return m_impl->cluster_id.get();
return m_impl->cluster_id.value();
}
static const std::string empty;
return empty;
@@ -282,7 +282,7 @@ void BasicMessage::ClusterId(const std::string& cluster_id) {
}
bool BasicMessage::ClusterIdIsSet() const {
return m_impl->cluster_id.is_initialized();
return m_impl->cluster_id.has_value();
}
void BasicMessage::ClusterIdClear() { m_impl->cluster_id.reset(); }
@@ -291,12 +291,12 @@ Table& BasicMessage::HeaderTable() {
if (!HeaderTableIsSet()) {
m_impl->header_table = Table();
}
return m_impl->header_table.get();
return m_impl->header_table.value();
}
const Table& BasicMessage::HeaderTable() const {
if (HeaderTableIsSet()) {
return m_impl->header_table.get();
return m_impl->header_table.value();
}
static const Table empty;
return empty;
@@ -307,7 +307,7 @@ void BasicMessage::HeaderTable(const Table& header_table) {
}
bool BasicMessage::HeaderTableIsSet() const {
return m_impl->header_table.is_initialized();
return m_impl->header_table.has_value();
}
void BasicMessage::HeaderTableClear() { m_impl->header_table.reset(); }

111
src/Channel.cpp
View File

@@ -1,3 +1,4 @@
#include <string_view>
/*
* ***** BEGIN LICENSE BLOCK *****
* Version: MIT
@@ -36,10 +37,10 @@
#include <string.h>
#include <boost/array.hpp>
#include <boost/chrono.hpp>
#include <boost/cstdint.hpp>
#include <boost/limits.hpp>
#include <array>
#include <chrono>
#include <cstdint>
#include <limits>
#include <map>
#include <new>
#include <queue>
@@ -142,8 +143,8 @@ Channel::OpenOpts Channel::OpenOpts::FromUri(const std::string &uri) {
amqp_connection_info info;
amqp_default_connection_info(&info);
boost::shared_ptr<char> uri_dup =
boost::shared_ptr<char>(strdup(uri.c_str()), free);
std::shared_ptr<char> uri_dup =
std::shared_ptr<char>(strdup(uri.c_str()), free);
if (0 != amqp_parse_url(uri_dup.get(), &info)) {
throw BadUriException();
@@ -193,22 +194,22 @@ Channel::ptr_t Channel::Open(const OpenOpts &opts) {
throw std::runtime_error(
"opts.port is not valid, it must be a positive number");
}
if (opts.auth.empty()) {
if (false) {
throw std::runtime_error("opts.auth is not specified, it is required");
}
if (!opts.tls_params.is_initialized()) {
switch (opts.auth.which()) {
if (!opts.tls_params.has_value()) {
switch (opts.auth.index()) {
case 0: {
const OpenOpts::BasicAuth &auth =
boost::get<OpenOpts::BasicAuth>(opts.auth);
return boost::make_shared<Channel>(
std::get<OpenOpts::BasicAuth>(opts.auth);
return std::make_shared<Channel>(
OpenChannel(opts.host, opts.port, auth.username, auth.password,
opts.vhost, opts.frame_max, false));
}
case 1: {
const OpenOpts::ExternalSaslAuth &auth =
boost::get<OpenOpts::ExternalSaslAuth>(opts.auth);
return boost::make_shared<Channel>(
std::get<OpenOpts::ExternalSaslAuth>(opts.auth);
return std::make_shared<Channel>(
OpenChannel(opts.host, opts.port, auth.identity, "", opts.vhost,
opts.frame_max, true));
}
@@ -216,20 +217,20 @@ Channel::ptr_t Channel::Open(const OpenOpts &opts) {
throw std::logic_error("Unhandled auth type");
}
}
switch (opts.auth.which()) {
switch (opts.auth.index()) {
case 0: {
const OpenOpts::BasicAuth &auth =
boost::get<OpenOpts::BasicAuth>(opts.auth);
return boost::make_shared<Channel>(OpenSecureChannel(
std::get<OpenOpts::BasicAuth>(opts.auth);
return std::make_shared<Channel>(OpenSecureChannel(
opts.host, opts.port, auth.username, auth.password, opts.vhost,
opts.frame_max, opts.tls_params.get(), false));
opts.frame_max, opts.tls_params.value(), false));
}
case 1: {
const OpenOpts::ExternalSaslAuth &auth =
boost::get<OpenOpts::ExternalSaslAuth>(opts.auth);
return boost::make_shared<Channel>(
std::get<OpenOpts::ExternalSaslAuth>(opts.auth);
return std::make_shared<Channel>(
OpenSecureChannel(opts.host, opts.port, auth.identity, "", opts.vhost,
opts.frame_max, opts.tls_params.get(), true));
opts.frame_max, opts.tls_params.value(), true));
}
default:
throw std::logic_error("Unhandled auth type");
@@ -340,7 +341,7 @@ Channel::ptr_t Channel::CreateSecureSaslExternal(
Channel::ptr_t Channel::CreateFromUri(const std::string &uri, int frame_max) {
OpenOpts opts = OpenOpts::FromUri(uri);
if (opts.tls_params.is_initialized()) {
if (opts.tls_params.has_value()) {
throw std::runtime_error(
"CreateFromUri only supports non-SSL-enabled URIs");
}
@@ -354,7 +355,7 @@ Channel::ptr_t Channel::CreateSecureFromUri(
const std::string &path_to_client_cert, bool verify_hostname_and_peer,
int frame_max) {
OpenOpts opts = OpenOpts::FromUri(uri);
if (!opts.tls_params.is_initialized()) {
if (!opts.tls_params.has_value()) {
throw std::runtime_error(
"CreateSecureFromUri only supports SSL-enabled URIs");
}
@@ -477,8 +478,8 @@ int Channel::GetSocketFD() const {
return amqp_get_sockfd(m_impl->m_connection);
}
bool Channel::CheckExchangeExists(boost::string_ref exchange_name) {
const boost::array<boost::uint32_t, 1> DECLARE_OK = {
bool Channel::CheckExchangeExists(std::string_view exchange_name) {
const std::array<uint32_t, 1> DECLARE_OK = {
{AMQP_EXCHANGE_DECLARE_OK_METHOD}};
amqp_exchange_declare_t declare = {};
@@ -507,7 +508,7 @@ void Channel::DeclareExchange(const std::string &exchange_name,
const std::string &exchange_type, bool passive,
bool durable, bool auto_delete,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> DECLARE_OK = {
const std::array<uint32_t, 1> DECLARE_OK = {
{AMQP_EXCHANGE_DECLARE_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -530,7 +531,7 @@ void Channel::DeclareExchange(const std::string &exchange_name,
}
void Channel::DeleteExchange(const std::string &exchange_name, bool if_unused) {
const boost::array<boost::uint32_t, 1> DELETE_OK = {
const std::array<uint32_t, 1> DELETE_OK = {
{AMQP_EXCHANGE_DELETE_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -554,7 +555,7 @@ void Channel::BindExchange(const std::string &destination,
const std::string &source,
const std::string &routing_key,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> BIND_OK = {
const std::array<uint32_t, 1> BIND_OK = {
{AMQP_EXCHANGE_BIND_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -582,7 +583,7 @@ void Channel::UnbindExchange(const std::string &destination,
const std::string &source,
const std::string &routing_key,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> UNBIND_OK = {
const std::array<uint32_t, 1> UNBIND_OK = {
{AMQP_EXCHANGE_UNBIND_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -601,8 +602,8 @@ void Channel::UnbindExchange(const std::string &destination,
m_impl->MaybeReleaseBuffersOnChannel(frame.channel);
}
bool Channel::CheckQueueExists(boost::string_ref queue_name) {
const boost::array<boost::uint32_t, 1> DECLARE_OK = {
bool Channel::CheckQueueExists(std::string_view queue_name) {
const std::array<uint32_t, 1> DECLARE_OK = {
{AMQP_QUEUE_DECLARE_OK_METHOD}};
amqp_queue_declare_t declare = {};
@@ -630,16 +631,16 @@ std::string Channel::DeclareQueue(const std::string &queue_name, bool passive,
std::string Channel::DeclareQueue(const std::string &queue_name, bool passive,
bool durable, bool exclusive,
bool auto_delete, const Table &arguments) {
boost::uint32_t message_count;
boost::uint32_t consumer_count;
uint32_t message_count;
uint32_t consumer_count;
return DeclareQueueWithCounts(queue_name, message_count, consumer_count,
passive, durable, exclusive, auto_delete,
arguments);
}
std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
boost::uint32_t &message_count,
boost::uint32_t &consumer_count,
uint32_t &message_count,
uint32_t &consumer_count,
bool passive, bool durable,
bool exclusive, bool auto_delete) {
return DeclareQueueWithCounts(queue_name, message_count, consumer_count,
@@ -648,12 +649,12 @@ std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
}
std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
boost::uint32_t &message_count,
boost::uint32_t &consumer_count,
uint32_t &message_count,
uint32_t &consumer_count,
bool passive, bool durable,
bool exclusive, bool auto_delete,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> DECLARE_OK = {
const std::array<uint32_t, 1> DECLARE_OK = {
{AMQP_QUEUE_DECLARE_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -686,7 +687,7 @@ std::string Channel::DeclareQueueWithCounts(const std::string &queue_name,
void Channel::DeleteQueue(const std::string &queue_name, bool if_unused,
bool if_empty) {
const boost::array<boost::uint32_t, 1> DELETE_OK = {
const std::array<uint32_t, 1> DELETE_OK = {
{AMQP_QUEUE_DELETE_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -710,7 +711,7 @@ void Channel::BindQueue(const std::string &queue_name,
const std::string &exchange_name,
const std::string &routing_key,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> BIND_OK = {
const std::array<uint32_t, 1> BIND_OK = {
{AMQP_QUEUE_BIND_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -738,7 +739,7 @@ void Channel::UnbindQueue(const std::string &queue_name,
const std::string &exchange_name,
const std::string &routing_key,
const Table &arguments) {
const boost::array<boost::uint32_t, 1> UNBIND_OK = {
const std::array<uint32_t, 1> UNBIND_OK = {
{AMQP_QUEUE_UNBIND_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -757,7 +758,7 @@ void Channel::UnbindQueue(const std::string &queue_name,
}
void Channel::PurgeQueue(const std::string &queue_name) {
const boost::array<boost::uint32_t, 1> PURGE_OK = {
const std::array<uint32_t, 1> PURGE_OK = {
{AMQP_QUEUE_PURGE_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -845,11 +846,11 @@ void Channel::BasicPublish(const std::string &exchange_name,
// - channel.close - probably tried to publish to a non-existant exchange, in
// any case error!
// - connection.clsoe - something really bad happened
const boost::array<boost::uint32_t, 3> PUBLISH_ACK = {
const std::array<uint32_t, 3> PUBLISH_ACK = {
{AMQP_BASIC_ACK_METHOD, AMQP_BASIC_RETURN_METHOD,
AMQP_BASIC_NACK_METHOD}};
amqp_frame_t response;
boost::array<amqp_channel_t, 1> channels = {{channel}};
std::array<amqp_channel_t, 1> channels = {{channel}};
m_impl->GetMethodOnChannel(channels, response, PUBLISH_ACK);
if (AMQP_BASIC_NACK_METHOD == response.payload.method.id) {
@@ -868,7 +869,7 @@ void Channel::BasicPublish(const std::string &exchange_name,
response.payload.method.decoded)),
channel);
const boost::array<boost::uint32_t, 1> BASIC_ACK = {
const std::array<uint32_t, 1> BASIC_ACK = {
{AMQP_BASIC_ACK_METHOD}};
m_impl->GetMethodOnChannel(channels, response, BASIC_ACK);
m_impl->ReturnChannel(channel);
@@ -882,7 +883,7 @@ void Channel::BasicPublish(const std::string &exchange_name,
bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
bool no_ack) {
const boost::array<boost::uint32_t, 2> GET_RESPONSES = {
const std::array<uint32_t, 2> GET_RESPONSES = {
{AMQP_BASIC_GET_OK_METHOD, AMQP_BASIC_GET_EMPTY_METHOD}};
m_impl->CheckIsConnected();
@@ -902,7 +903,7 @@ bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
amqp_basic_get_ok_t *get_ok =
(amqp_basic_get_ok_t *)response.payload.method.decoded;
boost::uint64_t delivery_tag = get_ok->delivery_tag;
uint64_t delivery_tag = get_ok->delivery_tag;
bool redelivered = (get_ok->redelivered == 0 ? false : true);
std::string exchange((char *)get_ok->exchange.bytes, get_ok->exchange.len);
std::string routing_key((char *)get_ok->routing_key.bytes,
@@ -918,7 +919,7 @@ bool Channel::BasicGet(Envelope::ptr_t &envelope, const std::string &queue,
}
void Channel::BasicRecover(const std::string &consumer) {
const boost::array<boost::uint32_t, 1> RECOVER_OK = {
const std::array<uint32_t, 1> RECOVER_OK = {
{AMQP_BASIC_RECOVER_OK_METHOD}};
m_impl->CheckIsConnected();
@@ -935,21 +936,21 @@ void Channel::BasicRecover(const std::string &consumer) {
std::string Channel::BasicConsume(const std::string &queue,
const std::string &consumer_tag,
bool no_local, bool no_ack, bool exclusive,
boost::uint16_t message_prefetch_count) {
uint16_t message_prefetch_count) {
return BasicConsume(queue, consumer_tag, no_local, no_ack, exclusive,
message_prefetch_count, Table());
}
std::string Channel::BasicConsume(const std::string &queue,
const std::string &consumer_tag,
bool no_local, bool no_ack, bool exclusive,
boost::uint16_t message_prefetch_count,
uint16_t message_prefetch_count,
const Table &arguments) {
m_impl->CheckIsConnected();
amqp_channel_t channel = m_impl->GetChannel();
// Set this before starting the consume as it may have been set by a previous
// consumer
const boost::array<boost::uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
const std::array<uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
amqp_basic_qos_t qos = {};
qos.prefetch_size = 0;
@@ -959,7 +960,7 @@ std::string Channel::BasicConsume(const std::string &queue,
m_impl->DoRpcOnChannel(channel, AMQP_BASIC_QOS_METHOD, &qos, QOS_OK);
m_impl->MaybeReleaseBuffersOnChannel(channel);
const boost::array<boost::uint32_t, 1> CONSUME_OK = {
const std::array<uint32_t, 1> CONSUME_OK = {
{AMQP_BASIC_CONSUME_OK_METHOD}};
amqp_basic_consume_t consume = {};
@@ -989,11 +990,11 @@ std::string Channel::BasicConsume(const std::string &queue,
}
void Channel::BasicQos(const std::string &consumer_tag,
boost::uint16_t message_prefetch_count) {
uint16_t message_prefetch_count) {
m_impl->CheckIsConnected();
amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
const boost::array<boost::uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
const std::array<uint32_t, 1> QOS_OK = {{AMQP_BASIC_QOS_OK_METHOD}};
amqp_basic_qos_t qos = {};
qos.prefetch_size = 0;
@@ -1008,7 +1009,7 @@ void Channel::BasicCancel(const std::string &consumer_tag) {
m_impl->CheckIsConnected();
amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
const boost::array<boost::uint32_t, 1> CANCEL_OK = {
const std::array<uint32_t, 1> CANCEL_OK = {
{AMQP_BASIC_CANCEL_OK_METHOD}};
amqp_basic_cancel_t cancel = {};
@@ -1051,7 +1052,7 @@ bool Channel::BasicConsumeMessage(const std::string &consumer_tag,
m_impl->CheckIsConnected();
amqp_channel_t channel = m_impl->GetConsumerChannel(consumer_tag);
boost::array<amqp_channel_t, 1> channels = {{channel}};
std::array<amqp_channel_t, 1> channels = {{channel}};
return m_impl->ConsumeMessageOnChannel(channels, message, timeout);
}

72
src/ChannelImpl.cpp
View File

@@ -1,3 +1,6 @@
#include <sstream>
#include <algorithm>
#include <cassert>
/*
* ***** BEGIN LICENSE BLOCK *****
* Version: MIT
@@ -37,9 +40,9 @@
#include <sys/types.h>
#endif
#include <boost/algorithm/string/classification.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/array.hpp>
#include <array>
#include "SimpleAmqpClient/AmqpException.h"
#include "SimpleAmqpClient/AmqpLibraryException.h"
@@ -51,8 +54,9 @@
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <string.h>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <functional>
#include <string>
#include <stdexcept>
#define BROKER_HEARTBEAT 0
@@ -179,16 +183,16 @@ amqp_channel_t Channel::ChannelImpl::GetNextChannelId() {
amqp_channel_t Channel::ChannelImpl::CreateNewChannel() {
amqp_channel_t new_channel = GetNextChannelId();
static const boost::array<boost::uint32_t, 1> OPEN_OK = {
static const std::array<uint32_t, 1> OPEN_OK = {
{AMQP_CHANNEL_OPEN_OK_METHOD}};
amqp_channel_open_t channel_open = {};
DoRpcOnChannel<boost::array<boost::uint32_t, 1> >(
DoRpcOnChannel<std::array<uint32_t, 1> >(
new_channel, AMQP_CHANNEL_OPEN_METHOD, &channel_open, OPEN_OK);
static const boost::array<boost::uint32_t, 1> CONFIRM_OK = {
static const std::array<uint32_t, 1> CONFIRM_OK = {
{AMQP_CONFIRM_SELECT_OK_METHOD}};
amqp_confirm_select_t confirm_select = {};
DoRpcOnChannel<boost::array<boost::uint32_t, 1> >(
DoRpcOnChannel<std::array<uint32_t, 1> >(
new_channel, AMQP_CONFIRM_SELECT_METHOD, &confirm_select, CONFIRM_OK);
m_channels.at(new_channel) = CS_Open;
@@ -397,7 +401,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
amqp_channel_t channel) const {
frame_queue_t::const_iterator it =
std::find_if(m_frame_queue.begin(), m_frame_queue.end(),
boost::bind(&Channel::ChannelImpl::is_method_on_channel, _1,
std::bind(&Channel::ChannelImpl::is_method_on_channel, std::placeholders::_1,
AMQP_BASIC_DELIVER_METHOD, channel));
if (it == m_frame_queue.end()) {
@@ -406,7 +410,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
it = std::find_if(
it + 1, m_frame_queue.end(),
boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
if (it == m_frame_queue.end()) {
return false;
@@ -421,7 +425,7 @@ bool Channel::ChannelImpl::CheckForQueuedMessageOnChannel(
while (body_received < body_length) {
it = std::find_if(
it + 1, m_frame_queue.end(),
boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
if (it == m_frame_queue.end()) {
return false;
@@ -439,7 +443,7 @@ void Channel::ChannelImpl::AddToFrameQueue(const amqp_frame_t &frame) {
m_frame_queue.push_back(frame);
if (CheckForQueuedMessageOnChannel(frame.channel)) {
boost::array<amqp_channel_t, 1> channel = {{frame.channel}};
std::array<amqp_channel_t, 1> channel = {{frame.channel}};
Envelope::ptr_t envelope;
if (!ConsumeMessageOnChannelInner(channel, envelope, -1)) {
throw std::logic_error(
@@ -451,25 +455,25 @@ void Channel::ChannelImpl::AddToFrameQueue(const amqp_frame_t &frame) {
}
bool Channel::ChannelImpl::GetNextFrameFromBroker(
amqp_frame_t &frame, boost::chrono::microseconds timeout) {
amqp_frame_t &frame, std::chrono::microseconds timeout) {
struct timeval *tvp = NULL;
struct timeval tv_timeout;
memset(&tv_timeout, 0, sizeof(tv_timeout));
if (timeout != boost::chrono::microseconds::max()) {
// boost::chrono::seconds.count() returns boost::int_atleast64_t,
if (timeout != std::chrono::microseconds::max()) {
// std::chrono::seconds.count() returns std::int_atleast64_t,
// long can be 32 or 64 bit depending on the platform/arch
// unless the timeout is something absurd cast to long will be ok, but
// lets guard against the case where someone does something silly
assert(
boost::chrono::duration_cast<boost::chrono::seconds>(timeout).count() <
static_cast<boost::chrono::seconds::rep>(
std::chrono::duration_cast<std::chrono::seconds>(timeout).count() <
static_cast<std::chrono::seconds::rep>(
std::numeric_limits<long>::max()));
tv_timeout.tv_sec = static_cast<long>(
boost::chrono::duration_cast<boost::chrono::seconds>(timeout).count());
std::chrono::duration_cast<std::chrono::seconds>(timeout).count());
tv_timeout.tv_usec = static_cast<long>(
(timeout - boost::chrono::seconds(tv_timeout.tv_sec)).count());
(timeout - std::chrono::seconds(tv_timeout.tv_sec)).count());
tvp = &tv_timeout;
}
@@ -485,10 +489,10 @@ bool Channel::ChannelImpl::GetNextFrameFromBroker(
bool Channel::ChannelImpl::GetNextFrameOnChannel(
amqp_channel_t channel, amqp_frame_t &frame,
boost::chrono::microseconds timeout) {
std::chrono::microseconds timeout) {
frame_queue_t::iterator it = std::find_if(
m_frame_queue.begin(), m_frame_queue.end(),
boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel));
std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel));
if (m_frame_queue.end() != it) {
frame = *it;
@@ -503,7 +507,7 @@ bool Channel::ChannelImpl::GetNextFrameOnChannel(
return true;
}
boost::array<amqp_channel_t, 1> channels = {{channel}};
std::array<amqp_channel_t, 1> channels = {{channel}};
return GetNextFrameFromBrokerOnChannel(channels, frame, timeout);
}
@@ -512,7 +516,7 @@ void Channel::ChannelImpl::MaybeReleaseBuffersOnChannel(
if (m_frame_queue.end() ==
std::find_if(
m_frame_queue.begin(), m_frame_queue.end(),
boost::bind(&Channel::ChannelImpl::is_on_channel, _1, channel))) {
std::bind(&Channel::ChannelImpl::is_on_channel, std::placeholders::_1, channel))) {
amqp_maybe_release_buffers_on_channel(m_connection, channel);
}
}
@@ -534,7 +538,7 @@ bool bytesEqual(amqp_bytes_t r, amqp_bytes_t l) {
}
} // namespace
boost::uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
amqp_connection_state_t state) {
const amqp_table_t *properties = amqp_get_server_properties(state);
const amqp_bytes_t version = amqp_cstring_bytes("version");
@@ -554,16 +558,20 @@ boost::uint32_t Channel::ChannelImpl::ComputeBrokerVersion(
static_cast<char *>(version_entry->value.value.bytes.bytes),
version_entry->value.value.bytes.len);
std::vector<std::string> version_components;
boost::split(version_components, version_string, boost::is_any_of("."));
std::istringstream iss(version_string);
std::string token;
while (std::getline(iss, token, '.')) {
version_components.push_back(token);
}
if (version_components.size() != 3) {
return 0;
}
boost::uint32_t version_major =
boost::lexical_cast<boost::uint32_t>(version_components[0]);
boost::uint32_t version_minor =
boost::lexical_cast<boost::uint32_t>(version_components[1]);
boost::uint32_t version_patch =
boost::lexical_cast<boost::uint32_t>(version_components[2]);
uint32_t version_major =
std::stoull(version_components[0]);
uint32_t version_minor =
std::stoull(version_components[1]);
uint32_t version_patch =
std::stoull(version_components[2]);
return (version_major & 0xFF) << 16 | (version_minor & 0xFF) << 8 |
(version_patch & 0xFF);
}

4
src/Envelope.cpp
View File

@@ -32,10 +32,10 @@ namespace AmqpClient {
Envelope::Envelope(const BasicMessage::ptr_t message,
const std::string &consumer_tag,
const boost::uint64_t delivery_tag,
const uint64_t delivery_tag,
const std::string &exchange, bool redelivered,
const std::string &routing_key,
const boost::uint16_t delivery_channel)
const uint16_t delivery_channel)
: m_message(message),
m_consumerTag(consumer_tag),
m_deliveryTag(delivery_tag),

7
src/MessageReturnedException.cpp
View File

@@ -28,16 +28,17 @@
#include "SimpleAmqpClient/MessageReturnedException.h"
#include <boost/lexical_cast.hpp>
#include <string>
#include <stdexcept>
namespace AmqpClient {
MessageReturnedException::MessageReturnedException(
BasicMessage::ptr_t message, boost::uint32_t reply_code,
BasicMessage::ptr_t message, uint32_t reply_code,
const std::string &reply_text, const std::string &exchange,
const std::string &routing_key) throw()
: std::runtime_error(
std::string("Message returned. Reply code: ")
.append(boost::lexical_cast<std::string>(reply_code))
.append(std::to_string(reply_code))
.append(" ")
.append(reply_text)),
m_message(message),

168
src/SimpleAmqpClient/AmqpException.h
View File

@@ -28,7 +28,7 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <cstdint>
#include <stdexcept>
#include <string>
@@ -84,8 +84,8 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
* @param [in] method_id the method id of the method that caused the error
*/
explicit AmqpException(const std::string &what, const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw();
uint16_t class_id,
uint16_t method_id) throw();
/**
* Destructor
@@ -109,21 +109,21 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
*
* @returns the error code
*/
virtual boost::uint16_t reply_code() const throw() = 0;
virtual uint16_t reply_code() const throw() = 0;
/**
* Get the class id of the method that caused the error
*
* @returns the class id
*/
virtual boost::uint16_t class_id() const throw() { return m_class_id; }
virtual uint16_t class_id() const throw() { return m_class_id; }
/**
* Get the method id of the method that caused the error
*
* @returns the method id
*/
virtual boost::uint16_t method_id() const throw() { return m_method_id; }
virtual uint16_t method_id() const throw() { return m_method_id; }
/**
* Get the error string returned from the broker
@@ -135,8 +135,8 @@ class SIMPLEAMQPCLIENT_EXPORT AmqpException : public std::runtime_error {
protected:
/** @cond INTERNAL */
std::string m_reply_text;
boost::uint16_t m_class_id;
boost::uint16_t m_method_id;
uint16_t m_class_id;
uint16_t m_method_id;
/** @endcond */
};
@@ -159,8 +159,8 @@ class SIMPLEAMQPCLIENT_EXPORT ConnectionException : public AmqpException {
*/
explicit ConnectionException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: AmqpException(what, reply_text, class_id, method_id) {}
virtual bool is_soft_error() const throw() { return false; }
@@ -184,8 +184,8 @@ class SIMPLEAMQPCLIENT_EXPORT ChannelException : public AmqpException {
*/
explicit ChannelException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: AmqpException(what, reply_text, class_id, method_id) {}
virtual bool is_soft_error() const throw() { return true; }
@@ -198,18 +198,18 @@ class SIMPLEAMQPCLIENT_EXPORT ConnectionForcedException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit ConnectionForcedException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -219,18 +219,18 @@ class SIMPLEAMQPCLIENT_EXPORT InvalidPathException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit InvalidPathException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -241,18 +241,18 @@ class SIMPLEAMQPCLIENT_EXPORT InvalidPathException
class SIMPLEAMQPCLIENT_EXPORT FrameErrorException : public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit FrameErrorException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -264,17 +264,17 @@ class SIMPLEAMQPCLIENT_EXPORT SyntaxErrorException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit SyntaxErrorException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -286,18 +286,18 @@ class SIMPLEAMQPCLIENT_EXPORT CommandInvalidException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit CommandInvalidException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -309,17 +309,17 @@ class SIMPLEAMQPCLIENT_EXPORT ChannelErrorException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit ChannelErrorException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -331,18 +331,18 @@ class SIMPLEAMQPCLIENT_EXPORT UnexpectedFrameException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit UnexpectedFrameException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -354,18 +354,18 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceErrorException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit ResourceErrorException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -377,18 +377,18 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceErrorException
class SIMPLEAMQPCLIENT_EXPORT NotAllowedException : public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit NotAllowedException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -398,18 +398,18 @@ class SIMPLEAMQPCLIENT_EXPORT NotImplementedException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/**
* Constructor
*/
explicit NotImplementedException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -419,16 +419,16 @@ class SIMPLEAMQPCLIENT_EXPORT InternalErrorException
: public ConnectionException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit InternalErrorException(const std::string &what,
const std::string &reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ConnectionException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -440,16 +440,16 @@ class SIMPLEAMQPCLIENT_EXPORT ContentTooLargeException
: public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit ContentTooLargeException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -459,15 +459,15 @@ class SIMPLEAMQPCLIENT_EXPORT ContentTooLargeException
class SIMPLEAMQPCLIENT_EXPORT NoRouteException : public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit NoRouteException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -478,15 +478,15 @@ class SIMPLEAMQPCLIENT_EXPORT NoRouteException : public ChannelException {
class SIMPLEAMQPCLIENT_EXPORT NoConsumersException : public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit NoConsumersException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -496,15 +496,15 @@ class SIMPLEAMQPCLIENT_EXPORT NoConsumersException : public ChannelException {
class SIMPLEAMQPCLIENT_EXPORT AccessRefusedException : public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit AccessRefusedException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -514,15 +514,15 @@ class SIMPLEAMQPCLIENT_EXPORT AccessRefusedException : public ChannelException {
class SIMPLEAMQPCLIENT_EXPORT NotFoundException : public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit NotFoundException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -533,15 +533,15 @@ class SIMPLEAMQPCLIENT_EXPORT ResourceLockedException
: public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit ResourceLockedException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
/**
@@ -552,15 +552,15 @@ class SIMPLEAMQPCLIENT_EXPORT PreconditionFailedException
: public ChannelException {
public:
/** reply code */
static const boost::uint16_t REPLY_CODE;
static const uint16_t REPLY_CODE;
/** Constructor */
explicit PreconditionFailedException(const std::string &what,
const std::string reply_text,
boost::uint16_t class_id,
boost::uint16_t method_id) throw()
uint16_t class_id,
uint16_t method_id) throw()
: ChannelException(what, reply_text, class_id, method_id) {}
virtual boost::uint16_t reply_code() const throw() { return REPLY_CODE; }
virtual uint16_t reply_code() const throw() { return REPLY_CODE; }
};
} // namespace AmqpClient

2
src/SimpleAmqpClient/AmqpResponseLibraryException.h
View File

@@ -28,7 +28,7 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <cstdint>
#include <stdexcept>
#include <string>

26
src/SimpleAmqpClient/BasicMessage.h
View File

@@ -28,11 +28,9 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <boost/make_shared.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <cstdint>
#include <memory>
#include <string>
#include "SimpleAmqpClient/Table.h"
@@ -51,10 +49,10 @@ namespace AmqpClient {
/**
* An AMQP BasicMessage
*/
class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
class SIMPLEAMQPCLIENT_EXPORT BasicMessage {
public:
/// A shared pointer to BasicMessage
typedef boost::shared_ptr<BasicMessage> ptr_t;
typedef std::shared_ptr<BasicMessage> ptr_t;
/// With durable queues, messages can be requested to persist or not
enum delivery_mode_t {
@@ -66,7 +64,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
/**
* Create a new empty BasicMessage object
*/
static ptr_t Create() { return boost::make_shared<BasicMessage>(); }
static ptr_t Create() { return std::make_shared<BasicMessage>(); }
/**
* Create a new BasicMessage object with given body
@@ -75,7 +73,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
* @returns a new BasicMessage object
*/
static ptr_t Create(const std::string& body) {
return boost::make_shared<BasicMessage>(body);
return std::make_shared<BasicMessage>(body);
}
/// Construct empty BasicMessage
@@ -154,11 +152,11 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
/**
* Gets the priority property
*/
boost::uint8_t Priority() const;
uint8_t Priority() const;
/**
* Sets the priority property
*/
void Priority(boost::uint8_t priority);
void Priority(uint8_t priority);
/**
* Determines whether the priority property is set
*/
@@ -239,11 +237,11 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
/**
* Gets the timestamp property
*/
boost::uint64_t Timestamp() const;
uint64_t Timestamp() const;
/**
* Sets the timestamp property
*/
void Timestamp(boost::uint64_t timestamp);
void Timestamp(uint64_t timestamp);
/**
* Determines whether the timestamp property is set
*/
@@ -342,7 +340,7 @@ class SIMPLEAMQPCLIENT_EXPORT BasicMessage : boost::noncopyable {
protected:
struct Impl;
/// PIMPL idiom
boost::scoped_ptr<Impl> m_impl;
std::unique_ptr<Impl> m_impl;
};
} // namespace AmqpClient

4
src/SimpleAmqpClient/Bytes.h
View File

@@ -2,7 +2,7 @@
#define SIMPLEAMQPCLIENT_BYTES_H
#include <amqp.h>
#include <boost/utility/string_ref.hpp>
#include <string_view>
#include <string>
@@ -15,7 +15,7 @@ amqp_bytes_t StringToBytes(const std::string& str) {
return ret;
}
amqp_bytes_t StringRefToBytes(boost::string_ref str) {
amqp_bytes_t StringRefToBytes(std::string_view str) {
amqp_bytes_t ret;
ret.bytes = reinterpret_cast<void*>(const_cast<char*>(str.data()));
ret.len = str.length();

42
src/SimpleAmqpClient/Channel.h
View File

@@ -28,14 +28,12 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <boost/make_shared.hpp>
#include <boost/optional.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
#include <boost/utility/string_ref.hpp>
#include <boost/variant.hpp>
#include <cstdint>
#include <memory>
#include <optional>
#include <string_view>
#include <variant>
#include <string>
#include <vector>
@@ -59,10 +57,10 @@ namespace AmqpClient {
*
* Represents a logical AMQP channel multiplexed over a connection
*/
class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
class SIMPLEAMQPCLIENT_EXPORT Channel {
public:
/// a `shared_ptr` to Channel
typedef boost::shared_ptr<Channel> ptr_t;
typedef std::shared_ptr<Channel> ptr_t;
static const std::string
EXCHANGE_TYPE_DIRECT; ///< `"direct"` string constant
@@ -109,9 +107,9 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
int port; ///< Port to connect to, default is 5672.
int frame_max; ///< Max frame size in bytes. Default 128KB.
/// One of BasicAuth or ExternalSaslAuth is required.
boost::variant<BasicAuth, ExternalSaslAuth> auth;
std::variant<BasicAuth, ExternalSaslAuth> auth;
/// Connect using TLS/SSL when set, otherwise use an unencrypted channel.
boost::optional<TLSParams> tls_params;
std::optional<TLSParams> tls_params;
/**
* Create an OpenOpts struct from a URI.
@@ -351,7 +349,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
* @param exchange_name the name of the exchange to check for.
* @returns true if the exchange exists on the broker, false otherwise.
*/
bool CheckExchangeExists(boost::string_ref exchange_name);
bool CheckExchangeExists(std::string_view exchange_name);
/**
* Declares an exchange
@@ -454,7 +452,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
* @param queue_name the name of the exchange to check for.
* @returns true if the exchange exists on the broker, false otherwise.
*/
bool CheckQueueExists(boost::string_ref queue_name);
bool CheckQueueExists(std::string_view queue_name);
/**
* Declare a queue
@@ -527,8 +525,8 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
* broker is asked to create a unique queue by not providing a queue name.
*/
std::string DeclareQueueWithCounts(const std::string &queue_name,
boost::uint32_t &message_count,
boost::uint32_t &consumer_count,
uint32_t &message_count,
uint32_t &consumer_count,
bool passive = false, bool durable = false,
bool exclusive = true,
bool auto_delete = true);
@@ -558,8 +556,8 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
* broker is asked to create a unique queue by not providing a queue name.
*/
std::string DeclareQueueWithCounts(const std::string &queue_name,
boost::uint32_t &message_count,
boost::uint32_t &consumer_count,
uint32_t &message_count,
uint32_t &consumer_count,
bool passive, bool durable, bool exclusive,
bool auto_delete, const Table &arguments);
@@ -772,7 +770,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
const std::string &consumer_tag = "",
bool no_local = true, bool no_ack = true,
bool exclusive = true,
boost::uint16_t message_prefetch_count = 1);
uint16_t message_prefetch_count = 1);
/**
* Starts consuming Basic messages on a queue
@@ -800,7 +798,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
std::string BasicConsume(const std::string &queue,
const std::string &consumer_tag, bool no_local,
bool no_ack, bool exclusive,
boost::uint16_t message_prefetch_count,
uint16_t message_prefetch_count,
const Table &arguments);
/**
@@ -816,7 +814,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
* broker will deliver. A value of 0 means no limit.
*/
void BasicQos(const std::string &consumer_tag,
boost::uint16_t message_prefetch_count);
uint16_t message_prefetch_count);
/**
* Cancels a previously created Consumer
@@ -934,7 +932,7 @@ class SIMPLEAMQPCLIENT_EXPORT Channel : boost::noncopyable {
bool sasl_external);
/// PIMPL idiom
boost::scoped_ptr<ChannelImpl> m_impl;
std::unique_ptr<ChannelImpl> m_impl;
};
} // namespace AmqpClient

81
src/SimpleAmqpClient/ChannelImpl.h
View File

@@ -1,3 +1,4 @@
#include <algorithm>
#ifndef SIMPLEAMQPCLIENT_CHANNELIMPL_H
#define SIMPLEAMQPCLIENT_CHANNELIMPL_H
/*
@@ -32,7 +33,7 @@
#include <amqp.h>
#include <amqp_framing.h>
#include <boost/array.hpp>
#include <array>
#include "SimpleAmqpClient/AmqpException.h"
#include "SimpleAmqpClient/BasicMessage.h"
@@ -41,15 +42,15 @@
#include "SimpleAmqpClient/Envelope.h"
#include "SimpleAmqpClient/MessageReturnedException.h"
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <boost/bind.hpp>
#include <boost/chrono.hpp>
#include <boost/noncopyable.hpp>
#include <functional>
#include <chrono>
#include <map>
#include <vector>
namespace AmqpClient {
class Channel::ChannelImpl : boost::noncopyable {
class Channel::ChannelImpl {
public:
ChannelImpl();
virtual ~ChannelImpl();
@@ -67,7 +68,7 @@ class Channel::ChannelImpl : boost::noncopyable {
bool IsChannelOpen(amqp_channel_t channel);
bool GetNextFrameFromBroker(amqp_frame_t &frame,
boost::chrono::microseconds timeout);
std::chrono::microseconds timeout);
bool CheckForQueuedMessageOnChannel(amqp_channel_t message_on_channel) const;
void AddToFrameQueue(const amqp_frame_t &frame);
@@ -75,12 +76,12 @@ class Channel::ChannelImpl : boost::noncopyable {
template <class ChannelListType>
bool GetNextFrameFromBrokerOnChannel(const ChannelListType channels,
amqp_frame_t &frame_out,
boost::chrono::microseconds timeout =
boost::chrono::microseconds::max()) {
boost::chrono::steady_clock::time_point end_point;
boost::chrono::microseconds timeout_left = timeout;
if (timeout != boost::chrono::microseconds::max()) {
end_point = boost::chrono::steady_clock::now() + timeout;
std::chrono::microseconds timeout =
std::chrono::microseconds::max()) {
std::chrono::steady_clock::time_point end_point;
std::chrono::microseconds timeout_left = timeout;
if (timeout != std::chrono::microseconds::max()) {
end_point = std::chrono::steady_clock::now() + timeout;
}
amqp_frame_t frame;
@@ -104,14 +105,14 @@ class Channel::ChannelImpl : boost::noncopyable {
AddToFrameQueue(frame);
}
if (timeout != boost::chrono::microseconds::max()) {
boost::chrono::steady_clock::time_point now =
boost::chrono::steady_clock::now();
if (timeout != std::chrono::microseconds::max()) {
std::chrono::steady_clock::time_point now =
std::chrono::steady_clock::now();
if (now >= end_point) {
return false;
}
timeout_left =
boost::chrono::duration_cast<boost::chrono::microseconds>(
std::chrono::duration_cast<std::chrono::microseconds>(
end_point - now);
}
}
@@ -120,7 +121,7 @@ class Channel::ChannelImpl : boost::noncopyable {
bool GetNextFrameOnChannel(
amqp_channel_t channel, amqp_frame_t &frame,
boost::chrono::microseconds timeout = boost::chrono::microseconds::max());
std::chrono::microseconds timeout = std::chrono::microseconds::max());
static bool is_on_channel(const amqp_frame_t frame, amqp_channel_t channel) {
return channel == frame.channel;
@@ -154,14 +155,14 @@ class Channel::ChannelImpl : boost::noncopyable {
template <class ChannelListType, class ResponseListType>
bool GetMethodOnChannel(const ChannelListType channels, amqp_frame_t &frame,
const ResponseListType &expected_responses,
boost::chrono::microseconds timeout =
boost::chrono::microseconds::max()) {
std::chrono::microseconds timeout =
std::chrono::microseconds::max()) {
frame_queue_t::iterator desired_frame = std::find_if(
m_frame_queue.begin(), m_frame_queue.end(),
boost::bind(
std::bind(
&ChannelImpl::is_expected_method_on_channel<ChannelListType,
ResponseListType>,
_1, channels, expected_responses));
std::placeholders::_1, channels, expected_responses));
if (m_frame_queue.end() != desired_frame) {
frame = *desired_frame;
@@ -169,10 +170,10 @@ class Channel::ChannelImpl : boost::noncopyable {
return true;
}
boost::chrono::steady_clock::time_point end_point;
boost::chrono::microseconds timeout_left = timeout;
if (timeout != boost::chrono::microseconds::max()) {
end_point = boost::chrono::steady_clock::now() + timeout;
std::chrono::steady_clock::time_point end_point;
std::chrono::microseconds timeout_left = timeout;
if (timeout != std::chrono::microseconds::max()) {
end_point = std::chrono::steady_clock::now() + timeout;
}
amqp_frame_t incoming_frame;
@@ -196,14 +197,14 @@ class Channel::ChannelImpl : boost::noncopyable {
}
m_frame_queue.push_back(incoming_frame);
if (timeout != boost::chrono::microseconds::max()) {
boost::chrono::steady_clock::time_point now =
boost::chrono::steady_clock::now();
if (timeout != std::chrono::microseconds::max()) {
std::chrono::steady_clock::time_point now =
std::chrono::steady_clock::now();
if (now >= end_point) {
return false;
}
timeout_left =
boost::chrono::duration_cast<boost::chrono::microseconds>(
std::chrono::duration_cast<std::chrono::microseconds>(
end_point - now);
}
}
@@ -211,20 +212,20 @@ class Channel::ChannelImpl : boost::noncopyable {
}
template <class ResponseListType>
amqp_frame_t DoRpcOnChannel(amqp_channel_t channel, boost::uint32_t method_id,
amqp_frame_t DoRpcOnChannel(amqp_channel_t channel, uint32_t method_id,
void *decoded,
const ResponseListType &expected_responses) {
CheckForError(amqp_send_method(m_connection, channel, method_id, decoded));
amqp_frame_t response;
boost::array<amqp_channel_t, 1> channels = {{channel}};
std::array<amqp_channel_t, 1> channels = {{channel}};
GetMethodOnChannel(channels, response, expected_responses);
return response;
}
template <class ResponseListType>
amqp_frame_t DoRpc(boost::uint32_t method_id, void *decoded,
amqp_frame_t DoRpc(uint32_t method_id, void *decoded,
const ResponseListType &expected_responses) {
amqp_channel_t channel = GetChannel();
amqp_frame_t ret =
@@ -245,7 +246,7 @@ class Channel::ChannelImpl : boost::noncopyable {
Envelope::ptr_t &message, int timeout) {
envelope_list_t::iterator it = std::find_if(
m_delivered_messages.begin(), m_delivered_messages.end(),
boost::bind(ChannelImpl::envelope_on_channel<ChannelListType>, _1,
std::bind(ChannelImpl::envelope_on_channel<ChannelListType>, std::placeholders::_1,
channels));
if (it != m_delivered_messages.end()) {
@@ -260,12 +261,12 @@ class Channel::ChannelImpl : boost::noncopyable {
template <class ChannelListType>
bool ConsumeMessageOnChannelInner(const ChannelListType channels,
Envelope::ptr_t &message, int timeout) {
const boost::array<boost::uint32_t, 2> DELIVER_OR_CANCEL = {
const std::array<uint32_t, 2> DELIVER_OR_CANCEL = {
{AMQP_BASIC_DELIVER_METHOD, AMQP_BASIC_CANCEL_METHOD}};
boost::chrono::microseconds real_timeout =
(timeout >= 0 ? boost::chrono::milliseconds(timeout)
: boost::chrono::microseconds::max());
std::chrono::microseconds real_timeout =
(timeout >= 0 ? std::chrono::milliseconds(timeout)
: std::chrono::microseconds::max());
amqp_frame_t deliver;
if (!GetMethodOnChannel(channels, deliver, DELIVER_OR_CANCEL,
@@ -298,7 +299,7 @@ class Channel::ChannelImpl : boost::noncopyable {
const std::string in_consumer_tag(
(char *)deliver_method->consumer_tag.bytes,
deliver_method->consumer_tag.len);
const boost::uint64_t delivery_tag = deliver_method->delivery_tag;
const uint64_t delivery_tag = deliver_method->delivery_tag;
const bool redelivered = (deliver_method->redelivered == 0 ? false : true);
MaybeReleaseBuffersOnChannel(deliver.channel);
@@ -343,7 +344,7 @@ class Channel::ChannelImpl : boost::noncopyable {
amqp_connection_state_t m_connection;
private:
static boost::uint32_t ComputeBrokerVersion(
static uint32_t ComputeBrokerVersion(
const amqp_connection_state_t state);
frame_queue_t m_frame_queue;
@@ -358,7 +359,7 @@ class Channel::ChannelImpl : boost::noncopyable {
typedef std::vector<channel_state_t> channel_state_list_t;
channel_state_list_t m_channels;
boost::uint32_t m_brokerVersion;
uint32_t m_brokerVersion;
// A channel that is likely to be an CS_Open state
amqp_channel_t m_last_used_channel;

35
src/SimpleAmqpClient/Envelope.h
View File

@@ -28,10 +28,9 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <boost/make_shared.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <cstdint>
#include <memory>
#include <string>
#include "SimpleAmqpClient/BasicMessage.h"
@@ -50,10 +49,10 @@ namespace AmqpClient {
/**
* A "message envelope" object containing the message body and delivery metadata
*/
class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
class SIMPLEAMQPCLIENT_EXPORT Envelope {
public:
/// a `shared_ptr` pointer to Envelope
typedef boost::shared_ptr<Envelope> ptr_t;
typedef std::shared_ptr<Envelope> ptr_t;
/**
* Creates an new envelope object
@@ -66,15 +65,15 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
* result of a redelivery
* @param routing_key the routing key that the message was published with
* @param delivery_channel channel ID of the delivery (see DeliveryInfo)
* @returns a boost::shared_ptr to an envelope object
* @returns a std::shared_ptr to an envelope object
*/
static ptr_t Create(const BasicMessage::ptr_t message,
const std::string &consumer_tag,
const boost::uint64_t delivery_tag,
const uint64_t delivery_tag,
const std::string &exchange, bool redelivered,
const std::string &routing_key,
const boost::uint16_t delivery_channel) {
return boost::make_shared<Envelope>(message, consumer_tag, delivery_tag,
const uint16_t delivery_channel) {
return std::make_shared<Envelope>(message, consumer_tag, delivery_tag,
exchange, redelivered, routing_key,
delivery_channel);
}
@@ -93,10 +92,10 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
*/
explicit Envelope(const BasicMessage::ptr_t message,
const std::string &consumer_tag,
const boost::uint64_t delivery_tag,
const uint64_t delivery_tag,
const std::string &exchange, bool redelivered,
const std::string &routing_key,
const boost::uint16_t delivery_channel);
const uint16_t delivery_channel);
public:
/**
@@ -127,7 +126,7 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
*
* @returns the delivery tag for a message
*/
inline boost::uint64_t DeliveryTag() const { return m_deliveryTag; }
inline uint64_t DeliveryTag() const { return m_deliveryTag; }
/**
* Get the name of the exchange that the message was published to
@@ -159,7 +158,7 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
/**
* Get the delivery channel
*/
inline boost::uint16_t DeliveryChannel() const { return m_deliveryChannel; }
inline uint16_t DeliveryChannel() const { return m_deliveryChannel; }
/**
* A POD carrier of delivery-tag
@@ -176,9 +175,9 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
struct DeliveryInfo {
/// A delivery tag, assigned by the broker to identify this delivery within
/// a channel
boost::uint64_t delivery_tag;
uint64_t delivery_tag;
/// An ID of the delivery channel
boost::uint16_t delivery_channel;
uint16_t delivery_channel;
};
/**
@@ -195,11 +194,11 @@ class SIMPLEAMQPCLIENT_EXPORT Envelope : boost::noncopyable {
private:
const BasicMessage::ptr_t m_message;
const std::string m_consumerTag;
const boost::uint64_t m_deliveryTag;
const uint64_t m_deliveryTag;
const std::string m_exchange;
const bool m_redelivered;
const std::string m_routingKey;
const boost::uint16_t m_deliveryChannel;
const uint16_t m_deliveryChannel;
};
} // namespace AmqpClient

7
src/SimpleAmqpClient/MessageRejectedException.h
View File

@@ -28,8 +28,9 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <boost/lexical_cast.hpp>
#include <cstdint>
#include <string>
#include <stdexcept>
#include <stdexcept>
#include "SimpleAmqpClient/BasicMessage.h"
@@ -51,7 +52,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageRejectedException
MessageRejectedException(uint64_t delivery_tag)
: std::runtime_error(
std::string("Message rejected: ")
.append(boost::lexical_cast<std::string>(delivery_tag))),
.append(std::to_string(delivery_tag))),
m_delivery_tag(delivery_tag) {}
/// `delivery_tag` getter

8
src/SimpleAmqpClient/MessageReturnedException.h
View File

@@ -28,7 +28,7 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <cstdint>
#include <stdexcept>
#include "SimpleAmqpClient/BasicMessage.h"
@@ -49,7 +49,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
public:
/// Constructor.
explicit MessageReturnedException(BasicMessage::ptr_t message,
boost::uint32_t reply_code,
uint32_t reply_code,
const std::string &reply_text,
const std::string &exchange,
const std::string &routing_key) throw();
@@ -59,7 +59,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
/// `message` getter
BasicMessage::ptr_t message() const throw() { return m_message; }
/// `reply_code` getter
boost::uint32_t reply_code() const throw() { return m_reply_code; }
uint32_t reply_code() const throw() { return m_reply_code; }
/// `reply_text` getter
std::string reply_text() const throw() { return m_reply_text; }
/// Exchange name getter
@@ -69,7 +69,7 @@ class SIMPLEAMQPCLIENT_EXPORT MessageReturnedException
private:
BasicMessage::ptr_t m_message;
boost::uint32_t m_reply_code;
uint32_t m_reply_code;
std::string m_reply_text;
std::string m_exchange;
std::string m_routing_key;

55
src/SimpleAmqpClient/Table.h
View File

@@ -1,3 +1,4 @@
#include <variant>
#ifndef SIMPLEAMQPCLIENT_TABLE_H
#define SIMPLEAMQPCLIENT_TABLE_H
/*
@@ -28,8 +29,8 @@
* ***** END LICENSE BLOCK *****
*/
#include <boost/cstdint.hpp>
#include <boost/scoped_ptr.hpp>
#include <cstdint>
#include <memory>
#include <ctime>
#include <map>
#include <string>
@@ -119,42 +120,42 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @param [in] value the value
*/
TableValue(boost::uint8_t value);
TableValue(uint8_t value);
/**
* Construct a 1-byte signed integer value
*
* @param [in] value the value
*/
TableValue(boost::int8_t value);
TableValue(int8_t value);
/**
* Construct a 2-byte unsigned integer value
*
* @param [in] value the value
*/
TableValue(boost::uint16_t value);
TableValue(uint16_t value);
/**
* Construct a 2-byte signed integer value
*
* @param [in] value the value
*/
TableValue(boost::int16_t value);
TableValue(int16_t value);
/**
* Construct a 4-byte unsigned integer value
*
* @param [in] value the value
*/
TableValue(boost::uint32_t value);
TableValue(uint32_t value);
/**
* Construct a 4-byte signed integer value
*
* @param [in] value the value
*/
TableValue(boost::int32_t value);
TableValue(int32_t value);
private:
/**
@@ -163,7 +164,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
* RabbitMQ does not support unsigned 64-bit values in tables,
* however, timestamps are used for this.
*/
TableValue(boost::uint64_t value);
TableValue(uint64_t value);
public:
/**
@@ -180,7 +181,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @param [in] value the value
*/
TableValue(boost::int64_t value);
TableValue(int64_t value);
/**
* Construct a single-precision floating point value
@@ -266,49 +267,49 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @returns the value if its a VT_uint8 type, 0 otherwise
*/
boost::uint8_t GetUint8() const;
uint8_t GetUint8() const;
/**
* Get the int8 value
*
* @returns the value if its a VT_int8 type, 0 otherwise
*/
boost::int8_t GetInt8() const;
int8_t GetInt8() const;
/**
* Get the uint16 value
*
* @returns the value if its a VT_uint16 type, 0 otherwise
*/
boost::uint16_t GetUint16() const;
uint16_t GetUint16() const;
/**
* Get the int16 value
*
* @returns the value if its a VT_int16 type, 0 otherwise
*/
boost::int16_t GetInt16() const;
int16_t GetInt16() const;
/**
* Get the uint32 value
*
* @returns the value if its a VT_uint32 type, 0 otherwise
*/
boost::uint32_t GetUint32() const;
uint32_t GetUint32() const;
/**
* Get the int32 value
*
* @returns the value if its a VT_int32 type, 0 otherwise
*/
boost::int32_t GetInt32() const;
int32_t GetInt32() const;
/**
* Get the uint64 value
*
* @returns the value if its a VT_uint64 type, 0 otherwise
*/
boost::uint64_t GetUint64() const;
uint64_t GetUint64() const;
/**
* Get the timestamp value
@@ -322,7 +323,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @returns the value if its a VT_int64 type, 0 otherwise
*/
boost::int64_t GetInt64() const;
int64_t GetInt64() const;
/**
* Get an integral number
@@ -334,7 +335,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
* @returns an integer number if the ValueType is VT_uint8, VT_int8,
* VT_uint16, VT_int16, VT_uint32, VT_int32,or VT_int64 type, 0 otherwise.
*/
boost::int64_t GetInteger() const;
int64_t GetInteger() const;
/**
* Get a float value
@@ -395,42 +396,42 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @param [in] value the value
*/
void Set(boost::uint8_t value);
void Set(uint8_t value);
/**
* Set the value as a int8_t
*
* @param [in] value the value
*/
void Set(boost::int8_t value);
void Set(int8_t value);
/**
* Set the value as a uint16_t
*
* @param [in] value the value
*/
void Set(boost::uint16_t value);
void Set(uint16_t value);
/**
* Set the value as a int16_t
*
* @param [in] value the value
*/
void Set(boost::int16_t value);
void Set(int16_t value);
/**
* Set the value as a uint32_t
*
* @param [in] value the value
*/
void Set(boost::uint32_t value);
void Set(uint32_t value);
/**
* Set the value as a int32_t
*
* @param [in] value the value
*/
void Set(boost::int32_t value);
void Set(int32_t value);
/**
* Set the value as a timestamp.
@@ -444,7 +445,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
*
* @param [in] value the value
*/
void Set(boost::int64_t value);
void Set(int64_t value);
/**
* Set the value as a float
@@ -489,7 +490,7 @@ class SIMPLEAMQPCLIENT_EXPORT TableValue {
void Set(const Table &value);
private:
boost::scoped_ptr<Detail::TableValueImpl> m_impl;
std::unique_ptr<Detail::TableValueImpl> m_impl;
};
} // namespace AmqpClient

35
src/SimpleAmqpClient/TableImpl.h
View File

@@ -30,9 +30,9 @@
#include <amqp.h>
#include <boost/cstdint.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/variant/variant.hpp>
#include <cstdint>
#include <memory>
#include <variant>
#include <ctime>
#include <string>
#include <vector>
@@ -42,7 +42,7 @@
namespace AmqpClient {
namespace Detail {
typedef boost::shared_ptr<amqp_pool_t> amqp_pool_ptr_t;
typedef std::shared_ptr<amqp_pool_t> amqp_pool_ptr_t;
struct void_t {};
@@ -50,10 +50,10 @@ inline bool operator==(const void_t &, const void_t &) { return true; }
typedef std::vector<TableValue> array_t;
typedef boost::variant<void_t, bool, boost::int8_t, boost::int16_t,
boost::int32_t, boost::int64_t, float, double,
std::string, array_t, Table, boost::uint8_t,
boost::uint16_t, boost::uint32_t, boost::uint64_t>
typedef std::variant<void_t, bool, int8_t, int16_t,
int32_t, int64_t, float, double,
std::string, array_t, Table, uint8_t,
uint16_t, uint32_t, uint64_t>
value_t;
class TableValueImpl {
@@ -81,22 +81,21 @@ class TableValueImpl {
amqp_pool_t &pool);
public:
class generate_field_value
: public boost::static_visitor<amqp_field_value_t> {
class generate_field_value {
public:
explicit generate_field_value(amqp_pool_t &p) : pool(p) {}
virtual ~generate_field_value() {}
amqp_field_value_t operator()(const void_t) const;
amqp_field_value_t operator()(const bool value) const;
amqp_field_value_t operator()(const boost::uint8_t value) const;
amqp_field_value_t operator()(const boost::int8_t value) const;
amqp_field_value_t operator()(const boost::uint16_t value) const;
amqp_field_value_t operator()(const boost::int16_t value) const;
amqp_field_value_t operator()(const boost::uint32_t value) const;
amqp_field_value_t operator()(const boost::int32_t value) const;
amqp_field_value_t operator()(const boost::uint64_t value) const;
amqp_field_value_t operator()(const boost::int64_t value) const;
amqp_field_value_t operator()(const uint8_t value) const;
amqp_field_value_t operator()(const int8_t value) const;
amqp_field_value_t operator()(const uint16_t value) const;
amqp_field_value_t operator()(const int16_t value) const;
amqp_field_value_t operator()(const uint32_t value) const;
amqp_field_value_t operator()(const int32_t value) const;
amqp_field_value_t operator()(const uint64_t value) const;
amqp_field_value_t operator()(const int64_t value) const;
amqp_field_value_t operator()(const float value) const;
amqp_field_value_t operator()(const double value) const;
amqp_field_value_t operator()(const std::string &value) const;

92
src/Table.cpp
View File

@@ -29,8 +29,8 @@
#include "SimpleAmqpClient/Table.h"
#include <algorithm>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/variant/get.hpp>
#include <type_traits>
#include <variant>
#include <ctime>
#include <iterator>
#include <limits>
@@ -45,32 +45,32 @@ TableValue::TableValue()
TableValue::TableValue(bool value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::uint8_t value)
TableValue::TableValue(uint8_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::int8_t value)
TableValue::TableValue(int8_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::uint16_t value)
TableValue::TableValue(uint16_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::int16_t value)
TableValue::TableValue(int16_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::uint32_t value)
TableValue::TableValue(uint32_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::int32_t value)
TableValue::TableValue(int32_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(boost::uint64_t value)
TableValue::TableValue(uint64_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue TableValue::Timestamp(std::time_t ts) {
return TableValue(static_cast<boost::uint64_t>(ts));
return TableValue(static_cast<uint64_t>(ts));
}
TableValue::TableValue(boost::int64_t value)
TableValue::TableValue(int64_t value)
: m_impl(new Detail::TableValueImpl(value)) {}
TableValue::TableValue(float value)
@@ -134,45 +134,45 @@ bool TableValue::operator!=(const TableValue &l) const {
TableValue::~TableValue() {}
TableValue::ValueType TableValue::GetType() const {
return static_cast<ValueType>(m_impl->m_value.which());
return static_cast<ValueType>(m_impl->m_value.index());
}
bool TableValue::GetBool() const { return boost::get<bool>(m_impl->m_value); }
bool TableValue::GetBool() const { return std::get<bool>(m_impl->m_value); }
boost::uint8_t TableValue::GetUint8() const {
return boost::get<boost::uint8_t>(m_impl->m_value);
uint8_t TableValue::GetUint8() const {
return std::get<uint8_t>(m_impl->m_value);
}
boost::int8_t TableValue::GetInt8() const {
return boost::get<boost::int8_t>(m_impl->m_value);
int8_t TableValue::GetInt8() const {
return std::get<int8_t>(m_impl->m_value);
}
boost::uint16_t TableValue::GetUint16() const {
return boost::get<boost::uint16_t>(m_impl->m_value);
uint16_t TableValue::GetUint16() const {
return std::get<uint16_t>(m_impl->m_value);
}
boost::int16_t TableValue::GetInt16() const {
return boost::get<boost::int16_t>(m_impl->m_value);
int16_t TableValue::GetInt16() const {
return std::get<int16_t>(m_impl->m_value);
}
boost::uint32_t TableValue::GetUint32() const {
return boost::get<boost::uint32_t>(m_impl->m_value);
uint32_t TableValue::GetUint32() const {
return std::get<uint32_t>(m_impl->m_value);
}
boost::int32_t TableValue::GetInt32() const {
return boost::get<boost::int32_t>(m_impl->m_value);
int32_t TableValue::GetInt32() const {
return std::get<int32_t>(m_impl->m_value);
}
std::time_t TableValue::GetTimestamp() const {
return static_cast<std::time_t>(boost::get<boost::uint64_t>(m_impl->m_value));
return static_cast<std::time_t>(std::get<uint64_t>(m_impl->m_value));
}
boost::int64_t TableValue::GetInt64() const {
return boost::get<boost::int64_t>(m_impl->m_value);
int64_t TableValue::GetInt64() const {
return std::get<int64_t>(m_impl->m_value);
}
boost::int64_t TableValue::GetInteger() const {
switch (m_impl->m_value.which()) {
int64_t TableValue::GetInteger() const {
switch (m_impl->m_value.index()) {
case VT_uint8:
return GetUint8();
case VT_int8:
@@ -188,62 +188,62 @@ boost::int64_t TableValue::GetInteger() const {
case VT_int64:
return GetInt64();
default:
throw boost::bad_get();
throw std::bad_variant_access();
}
}
float TableValue::GetFloat() const {
return boost::get<float>(m_impl->m_value);
return std::get<float>(m_impl->m_value);
}
double TableValue::GetDouble() const {
return boost::get<double>(m_impl->m_value);
return std::get<double>(m_impl->m_value);
}
double TableValue::GetReal() const {
switch (m_impl->m_value.which()) {
switch (m_impl->m_value.index()) {
case VT_float:
return GetFloat();
case VT_double:
return GetDouble();
default:
throw boost::bad_get();
throw std::bad_variant_access();
}
}
std::string TableValue::GetString() const {
return boost::get<std::string>(m_impl->m_value);
return std::get<std::string>(m_impl->m_value);
}
std::vector<TableValue> TableValue::GetArray() const {
return boost::get<Detail::array_t>(m_impl->m_value);
return std::get<Detail::array_t>(m_impl->m_value);
}
Table TableValue::GetTable() const {
return boost::get<Table>(m_impl->m_value);
return std::get<Table>(m_impl->m_value);
}
void TableValue::Set() { m_impl->m_value = Detail::void_t(); }
void TableValue::Set(bool value) { m_impl->m_value = value; }
void TableValue::Set(boost::uint8_t value) { m_impl->m_value = value; }
void TableValue::Set(uint8_t value) { m_impl->m_value = value; }
void TableValue::Set(boost::int8_t value) { m_impl->m_value = value; }
void TableValue::Set(int8_t value) { m_impl->m_value = value; }
void TableValue::Set(boost::uint16_t value) { m_impl->m_value = value; }
void TableValue::Set(uint16_t value) { m_impl->m_value = value; }
void TableValue::Set(boost::int16_t value) { m_impl->m_value = value; }
void TableValue::Set(int16_t value) { m_impl->m_value = value; }
void TableValue::Set(boost::uint32_t value) { m_impl->m_value = value; }
void TableValue::Set(uint32_t value) { m_impl->m_value = value; }
void TableValue::Set(boost::int32_t value) { m_impl->m_value = value; }
void TableValue::Set(int32_t value) { m_impl->m_value = value; }
void TableValue::SetTimestamp(std::time_t value) {
m_impl->m_value = static_cast<boost::uint64_t>(value);
m_impl->m_value = static_cast<uint64_t>(value);
}
void TableValue::Set(boost::int64_t value) { m_impl->m_value = value; }
void TableValue::Set(int64_t value) { m_impl->m_value = value; }
void TableValue::Set(float value) { m_impl->m_value = value; }

29
src/TableImpl.cpp
View File

@@ -36,9 +36,8 @@
#include <string.h>
#include <algorithm>
#include <boost/foreach.hpp>
#include <boost/variant/apply_visitor.hpp>
#include <boost/variant/static_visitor.hpp>
#include <variant>
#include <new>
#ifdef _MSC_VER
@@ -64,7 +63,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::uint8_t value) const {
const uint8_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_U8;
v.value.u8 = value;
@@ -72,7 +71,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::int8_t value) const {
const int8_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_I8;
v.value.i8 = value;
@@ -80,7 +79,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::uint16_t value) const {
const uint16_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_U16;
v.value.u16 = value;
@@ -88,7 +87,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::int16_t value) const {
const int16_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_I16;
v.value.i16 = value;
@@ -96,7 +95,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::uint32_t value) const {
const uint32_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_U32;
v.value.u32 = value;
@@ -104,7 +103,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::int32_t value) const {
const int32_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_I32;
v.value.i32 = value;
@@ -112,7 +111,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::uint64_t value) const {
const uint64_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_TIMESTAMP;
v.value.u64 = value;
@@ -120,7 +119,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
}
amqp_field_value_t TableValueImpl::generate_field_value::operator()(
const boost::int64_t value) const {
const int64_t value) const {
amqp_field_value_t v;
v.kind = AMQP_FIELD_KIND_I64;
v.value.i64 = value;
@@ -167,7 +166,7 @@ amqp_field_value_t TableValueImpl::generate_field_value::operator()(
for (array_t::const_iterator it = value.begin(); it != value.end();
++it, ++output_iterator) {
*output_iterator =
boost::apply_visitor(generate_field_value(pool), it->m_impl->m_value);
std::visit(generate_field_value(pool), it->m_impl->m_value);
}
return v;
}
@@ -191,7 +190,7 @@ amqp_table_t TableValueImpl::CreateAmqpTable(const Table &table,
return AMQP_EMPTY_TABLE;
}
pool = boost::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
pool = std::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
init_amqp_pool(pool.get(), 1024);
return CreateAmqpTableInner(table, *pool.get());
@@ -221,7 +220,7 @@ amqp_table_t TableValueImpl::CreateAmqpTableInner(const Table &table,
std::copy(it->first.begin(), it->first.end(), (char *)output_it->key.bytes);
output_it->value = boost::apply_visitor(
output_it->value = std::visit(
TableValueImpl::generate_field_value(pool), it->second.m_impl->m_value);
}
@@ -297,7 +296,7 @@ amqp_table_t TableValueImpl::CopyTable(const amqp_table_t &table,
return AMQP_EMPTY_TABLE;
}
pool = boost::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
pool = std::shared_ptr<amqp_pool_t>(new amqp_pool_t, free_pool);
init_amqp_pool(pool.get(), 1024);
return CopyTableInner(table, *pool.get());

7
testing/CMakeLists.txt
View File

@@ -1,4 +1,3 @@
include_directories(BEFORE SYSTEM ${gtest_SOURCE_DIR}/include)
include_directories(../src)
add_executable(test_api
@@ -15,5 +14,9 @@ add_executable(test_api
test_ack.cpp
test_nack.cpp
)
target_link_libraries(test_api SimpleAmqpClient gtest gtest_main)
target_link_libraries(test_api SimpleAmqpClient xgoogletest::xgoogletest)
add_test(test_api test_api)
if(MSVC)
target_compile_options(test_api PRIVATE /utf-8)
endif()

2
testing/connected_test.h
View File

@@ -51,7 +51,7 @@ class connected_test : public ::testing::Test {
if (NULL != host) {
return std::string(host);
}
return std::string("");
return std::string("127.0.0.1");
}
};

1
testing/test_consume.cpp
View File

@@ -1,3 +1,4 @@
#include <functional>
/*
* ***** BEGIN LICENSE BLOCK *****
* Version: MIT

6
testing/test_message.cpp
View File

@@ -29,7 +29,7 @@
#include <amqp.h>
#include <algorithm>
#include <boost/array.hpp>
#include <array>
#include <iostream>
#include "connected_test.h"
@@ -103,13 +103,13 @@ TEST(basic_message, initial_message_replace2) {
}
TEST(basic_message, embedded_nulls) {
const boost::array<char, 7> message_data = {
const std::array<char, 7> message_data = {
{'a', 'b', 'c', 0, '1', '2', '3'}};
const std::string body(message_data.data(), message_data.size());
BasicMessage::ptr_t message = BasicMessage::Create(body);
EXPECT_EQ(body, message->Body());
const boost::array<char, 7> message_data2 = {
const std::array<char, 7> message_data2 = {
{'1', '2', '3', 0, 'a', 'b', 'c'}};
const std::string body2(message_data2.data(), message_data2.size());
message->Body(body2);

8
testing/test_queue.cpp
View File

@@ -83,8 +83,8 @@ TEST_F(connected_test, queue_declare_notautodelete) {
}
TEST_F(connected_test, queue_declare_counts) {
boost::uint32_t message_count = 123;
boost::uint32_t consumer_count = 123;
uint32_t message_count = 123;
uint32_t consumer_count = 123;
std::string queue = channel->DeclareQueueWithCounts(
"queue_declare_counts", message_count, consumer_count);
@@ -110,8 +110,8 @@ TEST_F(connected_test, queue_declare_counts) {
}
TEST_F(connected_test, queue_declare_counts_table) {
boost::uint32_t message_count = 123;
boost::uint32_t consumer_count = 123;
uint32_t message_count = 123;
uint32_t consumer_count = 123;
Table qTable;

900
testing/test_table.cpp
View File

File diff suppressed because it is too large Load Diff