mirror/oatpp
2
0
Fork 0
mirror of https://github.com/oatpp/oatpp.git synced 2025-03-31 18:30:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #805 from fhuberts/fix-Wold-style-cast

Browse Source 
Fix compiler warnings (-Wold-style-cast)
This commit is contained in:
Leonid Stryzhevskyi 2023-08-12 04:00:45 +03:00 committed by GitHub
commit 52b0d0b613
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
57 changed files with 235 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
cmake/compiler-flags.cmake
View File

@ -144,7 +144,7 @@ add_compiler_flags("-Wtrivial-auto-var-init") # gcc
#
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wctor-dtor-privacy") # gcc 4.6.0
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wnoexcept") # gcc 4.6.0
#add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wold-style-cast") # gcc 4.6.0
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wold-style-cast") # gcc 4.6.0
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Woverloaded-virtual") # gcc 4.6.0
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wsign-promo") # gcc 4.6.0
add_cxx_compiler_flags(CMAKE_CXX_FLAGS "-Wstrict-null-sentinel") # gcc 4.6.0

2
src/oatpp/algorithm/CRC.cpp
View File

@ -64,7 +64,7 @@ p_uint32 CRC32::generateTable(v_uint32 poly) {
v_uint32 CRC32::calc(const void *buffer, v_buff_size size, v_uint32 crc, v_uint32 initValue, v_uint32 xorOut, p_uint32 table) {
p_uint8 data = (p_uint8) buffer;
auto data = reinterpret_cast<const char*>(buffer);
crc = crc ^ initValue;
for(v_buff_size i = 0; i < size; i++) {

8
src/oatpp/codegen/dto/base_define.hpp
View File

@ -65,9 +65,9 @@ public: \
\
static v_int64 Z__PROPERTY_OFFSET_##NAME() { \
char buffer[sizeof(Z__CLASS)]; \
auto obj = static_cast<Z__CLASS*>((void*)buffer); \
auto obj = static_cast<Z__CLASS*>(reinterpret_cast<void*>(buffer)); \
auto ptr = &obj->NAME; \
return (v_int64) ptr - (v_int64) buffer; \
return reinterpret_cast<v_int64>(ptr) - reinterpret_cast<v_int64>(buffer); \
} \
\
static oatpp::data::mapping::type::BaseObject::Property* Z__PROPERTY_SINGLETON_##NAME() { \
@ -96,9 +96,9 @@ TYPE NAME = Z__PROPERTY_INITIALIZER_PROXY_##NAME()
\
static v_int64 Z__PROPERTY_OFFSET_##NAME() { \
char buffer[sizeof(Z__CLASS)]; \
auto obj = static_cast<Z__CLASS*>((void*)buffer); \
auto obj = static_cast<Z__CLASS*>(reinterpret_cast<void*>(buffer)); \
auto ptr = &obj->NAME; \
return (v_int64) ptr - (v_int64) buffer; \
return reinterpret_cast<v_int64>(ptr) - reinterpret_cast<v_int64>(buffer); \
} \
\
static oatpp::data::mapping::type::BaseObject::Property* Z__PROPERTY_SINGLETON_##NAME() { \

4
src/oatpp/core/async/worker/IOEventWorker_epoll.cpp
View File

@ -155,7 +155,7 @@ void IOEventWorker::consumeBacklog() {
void IOEventWorker::waitEvents() {
epoll_event* outEvents = (epoll_event*)m_outEvents.get();
epoll_event* outEvents = reinterpret_cast<epoll_event*>(m_outEvents.get());
auto eventsCount = epoll_wait(m_eventQueueHandle, outEvents, MAX_EVENTS, -1);
if((eventsCount < 0) && (errno != EINTR)) {
@ -184,7 +184,7 @@ void IOEventWorker::waitEvents() {
} else {
auto coroutine = (CoroutineHandle*) dataPtr;
auto coroutine = reinterpret_cast<CoroutineHandle*>(dataPtr);
Action action = coroutine->iterate();

26
src/oatpp/core/data/buffer/FIFOBuffer.cpp
View File

@ -30,7 +30,7 @@ namespace oatpp { namespace data{ namespace buffer {
FIFOBuffer::FIFOBuffer(void* buffer, v_buff_size bufferSize,
v_buff_size readPosition, v_buff_size writePosition,
bool canRead)
: m_buffer((p_char8)buffer)
: m_buffer(reinterpret_cast<p_char8>(buffer))
, m_bufferSize(bufferSize)
, m_readPosition(readPosition)
, m_writePosition(writePosition)
@ -84,7 +84,7 @@ v_io_size FIFOBuffer::read(void *data, v_buff_size count) {
if(size > count) {
size = count;
}
std::memcpy(data, &m_buffer[m_readPosition], (size_t)size);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(size));
m_readPosition += size;
if(m_readPosition == m_writePosition) {
m_canRead = false;
@ -95,18 +95,18 @@ v_io_size FIFOBuffer::read(void *data, v_buff_size count) {
auto size = m_bufferSize - m_readPosition;
if(size > count){
std::memcpy(data, &m_buffer[m_readPosition], (size_t)count);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(count));
m_readPosition += count;
return count;
}
std::memcpy(data, &m_buffer[m_readPosition], (size_t)size);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(size));
auto size2 = m_writePosition;
if(size2 > count - size) {
size2 = count - size;
}
std::memcpy(&((p_char8) data)[size], m_buffer, (size_t)size2);
std::memcpy(&(reinterpret_cast<p_char8>(data))[size], m_buffer, static_cast<size_t>(size2));
m_readPosition = size2;
if(m_readPosition == m_writePosition) {
m_canRead = false;
@ -133,24 +133,24 @@ v_io_size FIFOBuffer::peek(void *data, v_buff_size count) {
if(size > count) {
size = count;
}
std::memcpy(data, &m_buffer[m_readPosition], (size_t)size);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(size));
return size;
}
auto size = m_bufferSize - m_readPosition;
if(size > count){
std::memcpy(data, &m_buffer[m_readPosition], (size_t)count);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(count));
return count;
}
std::memcpy(data, &m_buffer[m_readPosition], (size_t)size);
std::memcpy(data, &m_buffer[m_readPosition], static_cast<size_t>(size));
auto size2 = m_writePosition;
if(size2 > count - size) {
size2 = count - size;
}
std::memcpy(&((p_char8) data)[size], m_buffer, (size_t)size2);
std::memcpy(&(reinterpret_cast<p_char8>(data))[size], m_buffer, static_cast<size_t>(size2));
return (size + size2);
@ -220,7 +220,7 @@ v_io_size FIFOBuffer::write(const void *data, v_buff_size count) {
if(size > count) {
size = count;
}
std::memcpy(&m_buffer[m_writePosition], data, (size_t)size);
std::memcpy(&m_buffer[m_writePosition], data, static_cast<size_t>(size));
m_writePosition += size;
return size;
}
@ -228,18 +228,18 @@ v_io_size FIFOBuffer::write(const void *data, v_buff_size count) {
auto size = m_bufferSize - m_writePosition;
if(size > count){
std::memcpy(&m_buffer[m_writePosition], data, (size_t)count);
std::memcpy(&m_buffer[m_writePosition], data, static_cast<size_t>(count));
m_writePosition += count;
return count;
}
std::memcpy(&m_buffer[m_writePosition], data, (size_t)size);
std::memcpy(&m_buffer[m_writePosition], data, static_cast<size_t>(size));
auto size2 = m_readPosition;
if(size2 > count - size) {
size2 = count - size;
}
std::memcpy(m_buffer, &((p_char8) data)[size], (size_t)size2);
std::memcpy(m_buffer, &(reinterpret_cast<const char*>(data))[size], static_cast<size_t>(size2));
m_writePosition = size2;
return (size + size2);

12
src/oatpp/core/data/buffer/Processor.cpp
View File

@ -45,12 +45,12 @@ void InlineReadData::set(void* data, v_buff_size size) {
}
void InlineReadData::inc(v_buff_size amount) {
currBufferPtr = &((p_char8) currBufferPtr)[amount];
currBufferPtr = &(reinterpret_cast<p_char8>(currBufferPtr))[amount];
bytesLeft -= amount;
}
void InlineReadData::setEof() {
currBufferPtr = &((p_char8) currBufferPtr)[bytesLeft];
currBufferPtr = &(reinterpret_cast<p_char8>(currBufferPtr))[bytesLeft];
bytesLeft = 0;
}
@ -73,12 +73,12 @@ void InlineWriteData::set(const void* data, v_buff_size size) {
}
void InlineWriteData::inc(v_buff_size amount) {
currBufferPtr = &((p_char8) currBufferPtr)[amount];
currBufferPtr = &(reinterpret_cast<p_char8>(const_cast<void*>(currBufferPtr)))[amount];
bytesLeft -= amount;
}
void InlineWriteData::setEof() {
currBufferPtr = &((p_char8) currBufferPtr)[bytesLeft];
currBufferPtr = &(reinterpret_cast<p_char8>(const_cast<void*>(currBufferPtr)))[bytesLeft];
bytesLeft = 0;
}
@ -102,7 +102,7 @@ v_int32 ProcessingPipeline::iterate(data::buffer::InlineReadData& dataIn,
return Error::FLUSH_DATA_OUT;
}
v_int32 i = 0;
v_buff_size i = 0;
v_int32 res = Error::OK;
while(res == Error::OK) {
@ -115,7 +115,7 @@ v_int32 ProcessingPipeline::iterate(data::buffer::InlineReadData& dataIn,
}
data::buffer::InlineReadData* currDataOut = &dataOut;
if(i < (v_int32) m_intermediateData.size()) {
if(i < m_intermediateData.size()) {
currDataOut = &m_intermediateData[i];
}

6
src/oatpp/core/data/mapping/type/Object.cpp
View File

@ -30,17 +30,17 @@ namespace oatpp { namespace data { namespace mapping { namespace type {
// BaseObject
void BaseObject::set(v_int64 offset, const Void& value) {
Void* property = (Void*)(((v_int64) m_basePointer) + offset);
Void* property = reinterpret_cast<Void*>((reinterpret_cast<v_int64>(m_basePointer)) + offset);
*property = value;
}
Void BaseObject::get(v_int64 offset) const {
Void* property = (Void*)(((v_int64) m_basePointer) + offset);
Void* property = reinterpret_cast<Void*>((reinterpret_cast<v_int64>(m_basePointer)) + offset);
return *property;
}
Void& BaseObject::getAsRef(v_int64 offset) const {
Void* property = (Void*)(((v_int64) m_basePointer) + offset);
Void* property = reinterpret_cast<Void*>((reinterpret_cast<v_int64>(m_basePointer)) + offset);
return *property;
}

2
src/oatpp/core/data/mapping/type/Object.hpp
View File

@ -466,7 +466,7 @@ private:
public:
virtual v_uint64 defaultHashCode() const {
return (v_uint64) reinterpret_cast<v_buff_usize>(this);
return reinterpret_cast<v_uint64>(this);
}
virtual bool defaultEquals(const DTO& other) const {

2
src/oatpp/core/data/mapping/type/Primitive.cpp
View File

@ -45,7 +45,7 @@ String String::loadFromFile(const char* filename) {
if (file.is_open()) {
auto result = data::mapping::type::String(file.tellg());
file.seekg(0, std::ios::beg);
file.read((char*) result->data(), result->size());
file.read(const_cast<char*>(result->data()), result->size());
file.close();
return result;
}

20
src/oatpp/core/data/mapping/type/Primitive.hpp
View File

@ -678,7 +678,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -691,7 +691,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -704,7 +704,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -717,7 +717,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -730,7 +730,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -743,7 +743,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -756,7 +756,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return static_cast<result_type>(*v);
}
};
@ -769,7 +769,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return (result_type) *v;
return (*v);
}
};
@ -782,7 +782,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return *((v_uint32*) v.get());
return *(reinterpret_cast<v_uint32*>(v.get()));
}
};
@ -795,7 +795,7 @@ namespace std {
result_type operator()(argument_type const& v) const noexcept {
if(v.get() == nullptr) return 0;
return *((result_type*) v.get());
return *(reinterpret_cast<result_type*>(v.get()));
}
};

4
src/oatpp/core/data/mapping/type/Type.cpp
View File

@ -53,7 +53,7 @@ std::vector<const char*>& ClassId::getClassNames() {
v_int32 ClassId::registerClassName(const char* name) {
std::lock_guard<std::mutex> lock(getClassMutex());
getClassNames().push_back(name);
return (v_int32) getClassNames().size() - 1;
return static_cast<v_int32>(getClassNames().size()) - 1;
}
ClassId::ClassId(const char* pName)
@ -63,7 +63,7 @@ ClassId::ClassId(const char* pName)
int ClassId::getClassCount() {
std::lock_guard<std::mutex> lock(getClassMutex());
return (int) getClassNames().size();
return static_cast<int>(getClassNames().size());
}
std::vector<const char*> ClassId::getRegisteredClassNames() {

2
src/oatpp/core/data/mapping/type/Type.hpp
View File

@ -641,7 +641,7 @@ struct hash<oatpp::data::mapping::type::Void> {
typedef v_uint64 result_type;
result_type operator()(argument_type const& v) const noexcept {
return (result_type) v.get();
return reinterpret_cast<result_type>(v.get());
}
};

6
src/oatpp/core/data/share/LazyStringMap.hpp
View File

@ -255,7 +255,7 @@ public:
if(it != m_map.end()) {
it->second.captureToOwnMemory();
const auto& label = it->second;
return T(label.getMemoryHandle(), (const char*) label.getData(), label.getSize());
return T(label.getMemoryHandle(), reinterpret_cast<const char*>(label.getData()), label.getSize());
}
return T(nullptr, nullptr, 0);
@ -278,7 +278,7 @@ public:
if(it != m_map.end()) {
const auto& label = it->second;
return T(label.getMemoryHandle(), (const char*)label.getData(), label.getSize());
return T(label.getMemoryHandle(), reinterpret_cast<const char*>(label.getData()), label.getSize());
}
return T(nullptr, nullptr, 0);
@ -321,7 +321,7 @@ public:
*/
v_int32 getSize() const {
std::lock_guard<concurrency::SpinLock> lock(m_lock);
return (v_int32) m_map.size();
return static_cast<v_int32>(m_map.size());
}
};

16
src/oatpp/core/data/share/MemoryLabel.hpp
View File

@ -73,7 +73,7 @@ public:
MemoryLabel(
ptr,
ptr ? ptr->data() : nullptr,
ptr ? (v_buff_size) ptr->size() : 0
ptr ? static_cast<v_buff_size>(ptr->size()) : 0
)
{}
@ -113,9 +113,9 @@ public:
* Capture data referenced by memory label to its own memory.
*/
void captureToOwnMemory() const {
if(!m_memoryHandle || m_memoryHandle->data() != (const char*)m_data || m_memoryHandle->size() != m_size) {
m_memoryHandle = std::make_shared<std::string>((const char*) m_data, m_size);
m_data = (p_char8) m_memoryHandle->data();
if(!m_memoryHandle || m_memoryHandle->data() != reinterpret_cast<const char*>(m_data) || m_memoryHandle->size() != m_size) {
m_memoryHandle = std::make_shared<std::string>(reinterpret_cast<const char*>(m_data), m_size);
m_data = reinterpret_cast<p_char8>(const_cast<char*>(m_memoryHandle->data()));
}
}
@ -146,7 +146,7 @@ public:
* @return oatpp::String(data, size)
*/
String toString() const {
return String((const char*) m_data, m_size);
return String(reinterpret_cast<const char*>(m_data), m_size);
}
/**
@ -154,7 +154,7 @@ public:
* @return std::string(data, size)
*/
std::string std_str() const {
return std::string((const char*) m_data, m_size);
return std::string(reinterpret_cast<const char*>(m_data), m_size);
}
inline bool operator==(std::nullptr_t) const {
@ -308,7 +308,7 @@ namespace std {
result_type operator()(oatpp::data::share::StringKeyLabel const& s) const noexcept {
auto data = (p_char8) s.getData();
auto data = reinterpret_cast<const char*>(s.getData());
result_type result = 0;
for(v_buff_size i = 0; i < s.getSize(); i++) {
v_char8 c = data[i];
@ -328,7 +328,7 @@ namespace std {
result_type operator()(oatpp::data::share::StringKeyLabelCI const& s) const noexcept {
auto data = (p_char8) s.getData();
auto data = reinterpret_cast<const char*>(s.getData());
result_type result = 0;
for(v_buff_size i = 0; i < s.getSize(); i++) {
v_char8 c = data[i] | 32;

4
src/oatpp/core/data/share/StringTemplate.cpp
View File

@ -76,7 +76,7 @@ StringTemplate::StringTemplate(const oatpp::String& text, std::vector<Variable>&
throw std::runtime_error("[oatpp::data::share::StringTemplate::StringTemplate()]: Error. The template variable can't have a negative size.");
}
if((size_t) var.posEnd >= m_text->size()) {
if(static_cast<size_t>(var.posEnd) >= m_text->size()) {
throw std::runtime_error("[oatpp::data::share::StringTemplate::StringTemplate()]: Error. The template variable can't out-bound the template text.");
}
}
@ -105,7 +105,7 @@ void StringTemplate::format(stream::ConsistentOutputStream* stream, ValueProvide
}
if((size_t) prevPos < m_text->size()) {
if(static_cast<size_t>(prevPos) < m_text->size()) {
stream->writeSimple(m_text->data() + prevPos, m_text->size() - prevPos);
}

10
src/oatpp/core/data/stream/BufferStream.cpp
View File

@ -126,14 +126,14 @@ void BufferOutputStream::reset(v_buff_size initialCapacity) {
}
oatpp::String BufferOutputStream::toString() {
return oatpp::String((const char*) m_data, m_position);
return oatpp::String(reinterpret_cast<const char*>(m_data), m_position);
}
oatpp::String BufferOutputStream::getSubstring(v_buff_size pos, v_buff_size count) {
if(pos + count <= m_position) {
return oatpp::String((const char *) (m_data + pos), count);
return oatpp::String(reinterpret_cast<const char*>(m_data + pos), count);
} else {
return oatpp::String((const char *) (m_data + pos), m_position - pos);
return oatpp::String(reinterpret_cast<const char*>(m_data + pos), m_position - pos);
}
}
@ -181,7 +181,7 @@ BufferInputStream::BufferInputStream(const std::shared_ptr<std::string>& memoryH
v_buff_size size,
const std::shared_ptr<void>& captureData)
: m_memoryHandle(memoryHandle)
, m_data((p_char8) data)
, m_data(reinterpret_cast<p_char8>(const_cast<void*>(data)))
, m_size(size)
, m_position(0)
, m_ioMode(IOMode::ASYNCHRONOUS)
@ -189,7 +189,7 @@ BufferInputStream::BufferInputStream(const std::shared_ptr<std::string>& memoryH
{}
BufferInputStream::BufferInputStream(const oatpp::String& data, const std::shared_ptr<void>& captureData)
: BufferInputStream(data.getPtr(), (p_char8) data->data(), data->size(), captureData)
: BufferInputStream(data.getPtr(), reinterpret_cast<p_char8>(const_cast<char*>(data->data())), data->size(), captureData)
{}
void BufferInputStream::reset(const std::shared_ptr<std::string>& memoryHandle,

12
src/oatpp/core/data/stream/FIFOStream.cpp
View File

@ -31,8 +31,8 @@ namespace oatpp { namespace data { namespace stream {
data::stream::DefaultInitializedContext FIFOInputStream::DEFAULT_CONTEXT(data::stream::StreamType::STREAM_FINITE);
FIFOInputStream::FIFOInputStream(v_buff_size initialSize)
: m_memoryHandle(std::make_shared<std::string>(initialSize, (char)0))
, m_fifo(std::make_shared<data::buffer::FIFOBuffer>((void*)m_memoryHandle->data(), m_memoryHandle->size(), 0, 0, false))
: m_memoryHandle(std::make_shared<std::string>(initialSize, static_cast<char>(0)))
, m_fifo(std::make_shared<data::buffer::FIFOBuffer>(reinterpret_cast<void*>(const_cast<char*>(m_memoryHandle->data())), m_memoryHandle->size(), 0, 0, false))
, m_maxCapacity(-1) {
}
@ -85,10 +85,10 @@ void FIFOInputStream::reserveBytesUpfront(v_buff_size count) {
}
// ToDo: In-Memory-Resize
auto newHandle = std::make_shared<std::string>(newCapacity, (char)0);
auto newHandle = std::make_shared<std::string>(newCapacity, static_cast<char>(0));
v_io_size oldSize = m_fifo->availableToRead();
m_fifo->read((void*)newHandle->data(), oldSize);
auto newFifo = std::make_shared<data::buffer::FIFOBuffer>((void*)newHandle->data(), newHandle->size(), 0, oldSize, oldSize > 0);
m_fifo->read(reinterpret_cast<void*>(const_cast<char*>(newHandle->data())), oldSize);
auto newFifo = std::make_shared<data::buffer::FIFOBuffer>(reinterpret_cast<void*>(const_cast<char*>(newHandle->data())), newHandle->size(), 0, oldSize, oldSize > 0);
m_memoryHandle = newHandle;
m_fifo = newFifo;
}
@ -133,4 +133,4 @@ v_io_size FIFOInputStream::commitReadOffset(v_buff_size count) {
return m_fifo->commitReadOffset(count);
}
}}}
}}}

2
src/oatpp/core/data/stream/Stream.hpp
View File

@ -230,7 +230,7 @@ public:
* @return - actual number of bytes written. &id:oatpp::v_io_size;.
*/
v_io_size writeSimple(const char* data){
return writeSimple((p_char8)data, std::strlen(data));
return writeSimple(data, std::strlen(data));
}
/**

4
src/oatpp/core/data/stream/StreamBufferedProxy.hpp
View File

@ -42,7 +42,7 @@ public:
const oatpp::data::share::MemoryLabel& memoryLabel)
: m_outputStream(outputStream)
, m_memoryLabel(memoryLabel)
, m_buffer((void *) memoryLabel.getData(), memoryLabel.getSize())
, m_buffer(const_cast<void *>(memoryLabel.getData()), memoryLabel.getSize())
{}
public:
@ -92,7 +92,7 @@ public:
bool bufferCanRead)
: m_inputStream(inputStream)
, m_memoryLabel(memoryLabel)
, m_buffer((void*) memoryLabel.getData(), memoryLabel.getSize(), bufferReadPosition, bufferWritePosition, bufferCanRead)
, m_buffer(const_cast<void*>(memoryLabel.getData()), memoryLabel.getSize(), bufferReadPosition, bufferWritePosition, bufferCanRead)
{}
public:

4
src/oatpp/core/macro/component.hpp
View File

@ -41,7 +41,7 @@
#include "oatpp/core/base/Environment.hpp"
#define OATPP_MACRO_GET_COMPONENT_1(TYPE) \
(*((TYPE*) oatpp::base::Environment::getComponent(typeid(TYPE).name())))
(*(reinterpret_cast<TYPE*>(oatpp::base::Environment::getComponent(typeid(TYPE).name()))))
#define OATPP_MACRO_GET_COMPONENT_2(TYPE, QUALIFIER) \
(*((TYPE*) oatpp::base::Environment::getComponent(typeid(TYPE).name(), QUALIFIER)))
@ -51,7 +51,7 @@ OATPP_MACRO_EXPAND(OATPP_MACRO_MACRO_SELECTOR(OATPP_MACRO_GET_COMPONENT_, (__VA_
#define OATPP_MACRO_COMPONENT_1(TYPE, NAME) \
TYPE& NAME = (*((TYPE*) oatpp::base::Environment::getComponent(typeid(TYPE).name())))
TYPE& NAME = (*(reinterpret_cast<TYPE*>(oatpp::base::Environment::getComponent(typeid(TYPE).name()))))
#define OATPP_MACRO_COMPONENT_2(TYPE, NAME, QUALIFIER) \
TYPE& NAME = (*((TYPE*) oatpp::base::Environment::getComponent(typeid(TYPE).name(), QUALIFIER)))

24
src/oatpp/core/parser/Caret.cpp
View File

@ -78,7 +78,7 @@ namespace oatpp { namespace parser {
if(end == -1){
end = m_caret->m_pos;
}
return oatpp::String((const char*)&m_caret->m_data[m_start], end - m_start);
return oatpp::String(&m_caret->m_data[m_start], end - m_start);
}
std::string Caret::Label::std_str(){
@ -86,7 +86,7 @@ namespace oatpp { namespace parser {
if(end == -1){
end = m_caret->m_pos;
}
return std::string((const char*) (&m_caret->m_data[m_start]), end - m_start);
return std::string(&m_caret->m_data[m_start], end - m_start);
}
Caret::Label::operator bool() const {
@ -352,45 +352,45 @@ v_int64 Caret::StateSaveGuard::getSavedErrorCode() {
v_int64 Caret::parseInt(int base) {
char* end;
char* start = (char*)&m_data[m_pos];
v_int64 result = (v_int64)std::strtoll(start, &end, base);
char* start = const_cast<char*>(&m_data[m_pos]);
v_int64 result = static_cast<v_int64>(std::strtoll(start, &end, base));
if(start == end){
m_errorMessage = ERROR_INVALID_INTEGER;
}
m_pos = ((v_buff_size) end - (v_buff_size) m_data);
m_pos = (reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(m_data));
return result;
}
v_uint64 Caret::parseUnsignedInt(int base) {
char* end;
char* start = (char*)&m_data[m_pos];
v_uint64 result = (v_uint64)std::strtoull(start, &end, base);
char* start = const_cast<char*>(&m_data[m_pos]);
v_uint64 result = static_cast<v_uint64>(std::strtoull(start, &end, base));
if(start == end){
m_errorMessage = ERROR_INVALID_INTEGER;
}
m_pos = ((v_buff_size) end - (v_buff_size) m_data);
m_pos = (reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(m_data));
return result;
}
v_float32 Caret::parseFloat32(){
char* end;
char* start = (char*)&m_data[m_pos];
char* start = const_cast<char*>(&m_data[m_pos]);
v_float32 result = std::strtof(start , &end);
if(start == end){
m_errorMessage = ERROR_INVALID_FLOAT;
}
m_pos = ((v_buff_size) end - (v_buff_size) m_data);
m_pos = (reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(m_data));
return result;
}
v_float64 Caret::parseFloat64(){
char* end;
char* start = (char*)&m_data[m_pos];
char* start = const_cast<char*>(&m_data[m_pos]);
v_float64 result = std::strtod(start , &end);
if(start == end){
m_errorMessage = ERROR_INVALID_FLOAT;
}
m_pos = ((v_buff_size) end - (v_buff_size) m_data);
m_pos = (reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(m_data));
return result;
}

52
src/oatpp/core/utils/ConversionUtils.cpp
View File

@ -30,25 +30,25 @@ namespace oatpp { namespace utils { namespace conversion {
v_int32 strToInt32(const char* str){
char* end;
return (v_int32) std::strtol(str, &end, 10);
return static_cast<v_int32>(std::strtol(str, &end, 10));
}
v_int32 strToInt32(const oatpp::String& str, bool& success){
char* end;
v_int32 result = (v_int32) std::strtol(str->data(), &end, 10);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
v_int32 result = static_cast<v_int32>(std::strtol(str->data(), &end, 10));
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
v_uint32 strToUInt32(const char* str){
char* end;
return (v_uint32) std::strtoul(str, &end, 10);
return static_cast<v_uint32>(std::strtoul(str, &end, 10));
}
v_uint32 strToUInt32(const oatpp::String& str, bool& success){
char* end;
v_uint32 result = (v_uint32) std::strtoul(str->data(), &end, 10);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
v_uint32 result = static_cast<v_uint32>(std::strtoul(str->data(), &end, 10));
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
@ -60,7 +60,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_int64 strToInt64(const oatpp::String& str, bool& success){
char* end;
v_int64 result = std::strtoll(str->data(), &end, 10);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
@ -72,31 +72,31 @@ namespace oatpp { namespace utils { namespace conversion {
v_uint64 strToUInt64(const oatpp::String& str, bool& success){
char* end;
v_uint64 result = std::strtoull(str->data(), &end, 10);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
v_buff_size int32ToCharSequence(v_int32 value, p_char8 data, v_buff_size n) {
return snprintf((char*)data, n, "%ld", (long) value);
return snprintf(reinterpret_cast<char*>(data), n, "%ld", static_cast<long>(value));
}
v_buff_size uint32ToCharSequence(v_uint32 value, p_char8 data, v_buff_size n) {
return snprintf((char*)data, n, "%lu", (unsigned long) value);
return snprintf(reinterpret_cast<char*>(data), n, "%lu", static_cast<unsigned long>(value));
}
v_buff_size int64ToCharSequence(v_int64 value, p_char8 data, v_buff_size n) {
return snprintf((char*)data, n, "%lld", (long long int) value);
return snprintf(reinterpret_cast<char*>(data), n, "%lld", static_cast<long long int>(value));
}
v_buff_size uint64ToCharSequence(v_uint64 value, p_char8 data, v_buff_size n) {
return snprintf((char*)data, n, "%llu", (long long unsigned int) value);
return snprintf(reinterpret_cast<char*>(data), n, "%llu", static_cast<long long unsigned int>(value));
}
oatpp::String int32ToStr(v_int32 value){
v_char8 buff [16]; // Max 10 digits with 1 sign. 16 is plenty enough.
auto size = int32ToCharSequence(value, &buff[0], 16);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}
@ -105,7 +105,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [16]; // Max 10 digits. 16 is plenty enough.
auto size = uint32ToCharSequence(value, &buff[0], 16);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}
@ -114,7 +114,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [32]; // Max 20 digits unsigned, 19 digits +1 sign signed.
auto size = int64ToCharSequence(value, &buff[0], 32);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}
@ -123,7 +123,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [32]; // Max 20 digits.
auto size = uint64ToCharSequence(value, &buff[0], 32);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}
@ -132,7 +132,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [16];
auto size = int32ToCharSequence(value, &buff[0], 16);
if(size > 0){
return std::string((const char*)buff, size);
return std::string(reinterpret_cast<const char*>(buff), size);
}
return nullptr;
}
@ -141,7 +141,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [16];
auto size = uint32ToCharSequence(value, &buff[0], 16);
if(size > 0){
return std::string((const char*)buff, size);
return std::string(reinterpret_cast<const char*>(buff), size);
}
return nullptr;
}
@ -150,7 +150,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [32];
v_int32 size = v_int32(int64ToCharSequence(value, &buff[0], 32));
if(size > 0){
return std::string((const char*)buff, size);
return std::string(reinterpret_cast<const char*>(buff), size);
}
return nullptr;
}
@ -159,7 +159,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [32];
auto size = uint64ToCharSequence(value, &buff[0], 32);
if(size > 0){
return std::string((const char*)buff, size);
return std::string(reinterpret_cast<const char*>(buff), size);
}
return nullptr;
}
@ -172,7 +172,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_float32 strToFloat32(const oatpp::String& str, bool& success) {
char* end;
v_float32 result = std::strtof(str->data(), &end);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
@ -184,23 +184,23 @@ namespace oatpp { namespace utils { namespace conversion {
v_float64 strToFloat64(const oatpp::String& str, bool& success) {
char* end;
v_float64 result = std::strtod(str->data(), &end);
success = (((v_buff_size)end - (v_buff_size)str->data()) == str->size());
success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(str->data())) == str->size());
return result;
}
v_buff_size float32ToCharSequence(v_float32 value, p_char8 data, v_buff_size n, const char* format) {
return snprintf((char*)data, n, format, value);
return snprintf(reinterpret_cast<char*>(data), n, format, value);
}
v_buff_size float64ToCharSequence(v_float64 value, p_char8 data, v_buff_size n, const char* format) {
return snprintf((char*)data, n, format, value);
return snprintf(reinterpret_cast<char*>(data), n, format, value);
}
oatpp::String float32ToStr(v_float32 value, const char* format) {
v_char8 buff [100];
auto size = float32ToCharSequence(value, &buff[0], 100, format);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}
@ -209,7 +209,7 @@ v_buff_size float64ToCharSequence(v_float64 value, p_char8 data, v_buff_size n,
v_char8 buff [100];
auto size = float64ToCharSequence(value, &buff[0], 100, format);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}

4
src/oatpp/core/utils/ConversionUtils.hpp
View File

@ -199,7 +199,7 @@ namespace oatpp { namespace utils { namespace conversion {
*/
template<typename T>
v_buff_size primitiveToCharSequence(T value, p_char8 data, v_buff_size n, const char *pattern) {
return snprintf((char*)data, n, pattern, value);
return snprintf(reinterpret_cast<char*>(data), n, pattern, value);
}
/**
@ -214,7 +214,7 @@ namespace oatpp { namespace utils { namespace conversion {
v_char8 buff [100];
auto size = primitiveToCharSequence(value, &buff[0], 100, pattern);
if(size > 0){
return oatpp::String((const char*)&buff[0], size);
return oatpp::String(reinterpret_cast<const char*>(&buff[0]), size);
}
return nullptr;
}

2
src/oatpp/core/utils/Random.cpp
View File

@ -42,7 +42,7 @@ void Random::randomBytes(p_char8 buffer, v_buff_size bufferSize) {
std::uniform_int_distribution<size_t> distribution(0, 255);
for(v_buff_size i = 0; i < bufferSize; i ++) {
buffer[i] = (v_char8) distribution(RANDOM_GENERATOR);
buffer[i] = static_cast<v_char8>(distribution(RANDOM_GENERATOR));
}
}

14
src/oatpp/core/utils/String.cpp
View File

@ -55,8 +55,8 @@ v_buff_size String::compareCI_ASCII(const void* data1, v_buff_size size1, const
if(data1 == nullptr) return -1;
if(data2 == nullptr) return 1;
auto d1 = (p_char8) data1;
auto d2 = (p_char8) data2;
auto d1 = reinterpret_cast<const char*>(data1);
auto d2 = reinterpret_cast<const char*>(data2);
v_buff_size size = size1;
if(size2 < size1) size = size2;
@ -70,7 +70,7 @@ v_buff_size String::compareCI_ASCII(const void* data1, v_buff_size size1, const
if(b >= 'A' && b <= 'Z') b |= 32;
if(a != b) {
return (int) a - (int) b;
return static_cast<v_buff_size>(a) - static_cast<v_buff_size>(b);
}
}
@ -84,15 +84,15 @@ v_buff_size String::compareCI_ASCII(const void* data1, v_buff_size size1, const
void String::lowerCase_ASCII(void* data, v_buff_size size) {
for(v_buff_size i = 0; i < size; i++) {
v_char8 a = ((p_char8) data)[i];
if(a >= 'A' && a <= 'Z') ((p_char8) data)[i] = a | 32;
v_char8 a = (reinterpret_cast<p_char8>(data))[i];
if(a >= 'A' && a <= 'Z') (reinterpret_cast<p_char8>(data))[i] = a | 32;
}
}
void String::upperCase_ASCII(void* data, v_buff_size size) {
for(v_buff_size i = 0; i < size; i++) {
v_char8 a = ((p_char8) data)[i];
if(a >= 'a' && a <= 'z') ((p_char8) data)[i] = a & 223;
v_char8 a = (reinterpret_cast<p_char8>(data))[i];
if(a >= 'a' && a <= 'z') (reinterpret_cast<p_char8>(data))[i] = a & 223;
}
}

8
src/oatpp/encoding/Base64.cpp
View File

@ -109,8 +109,8 @@ oatpp::String Base64::encode(const void* data, v_buff_size size, const char* alp
auto result = oatpp::String(resultSize);
p_char8 bdata = (p_char8) data;
p_char8 resultData = (p_char8) result->data();
p_char8 bdata = reinterpret_cast<p_char8>(const_cast<void*>(data));
p_char8 resultData = reinterpret_cast<p_char8>(const_cast<char*>(result->data()));
v_buff_size pos = 0;
while (pos + 2 < size) {
@ -159,7 +159,7 @@ oatpp::String Base64::decode(const char* data, v_buff_size size, const char* aux
}
auto result = oatpp::String(resultSize);
p_char8 resultData = (p_char8) result->data();
p_char8 resultData = reinterpret_cast<p_char8>(const_cast<char*>(result->data()));
v_buff_size pos = 0;
while (pos + 3 < base64StrLength) {
v_char8 b0 = getAlphabetCharIndex(data[pos], auxiliaryChars);
@ -193,7 +193,7 @@ oatpp::String Base64::decode(const char* data, v_buff_size size, const char* aux
}
oatpp::String Base64::decode(const oatpp::String& data, const char* auxiliaryChars) {
return decode((const char*)data->data(), data->size(), auxiliaryChars);
return decode(data->data(), data->size(), auxiliaryChars);
}
}}

6
src/oatpp/encoding/Hex.cpp
View File

@ -36,7 +36,7 @@ const char* Hex::ALPHABET_UPPER = "0123456789ABCDEF";
const char* Hex::ALPHABET_LOWER = "0123456789abcdef";
void Hex::writeUInt16(v_uint16 value, p_char8 buffer){
*((p_uint32) buffer) = htonl((ALPHABET_UPPER[ value & 0x000F ] ) |
*(reinterpret_cast<p_uint32>(buffer)) = htonl((ALPHABET_UPPER[ value & 0x000F ] ) |
(ALPHABET_UPPER[(value & 0x00F0) >> 4] << 8) |
(ALPHABET_UPPER[(value & 0x0F00) >> 8] << 16) |
(ALPHABET_UPPER[(value & 0xF000) >> 12] << 24));
@ -86,7 +86,7 @@ void Hex::encode(data::stream::ConsistentOutputStream* stream,
const void* data, v_buff_size size,
const char* alphabet)
{
p_char8 buffer = (p_char8) data;
auto buffer = reinterpret_cast<const char*>(data);
v_char8 oneByteBuffer[2];
for(v_buff_size i = 0; i < size; i ++) {
auto c = buffer[i];
@ -101,7 +101,7 @@ void Hex::encode(data::stream::ConsistentOutputStream* stream,
void Hex::decode(data::stream::ConsistentOutputStream* stream,
const void* data, v_buff_size size, bool allowSeparators)
{
p_char8 buffer = (p_char8) data;
auto buffer = reinterpret_cast<const char*>(data);
v_char8 byte = 0;
v_int32 shift = 4;
for(v_buff_size i = 0; i < size; i ++) {

14
src/oatpp/encoding/Unicode.cpp
View File

@ -87,7 +87,7 @@ v_int32 Unicode::encodeUtf8Char(const char* sequence, v_buff_size& length){
length = 3;
} else if((byte | 8) != byte){
length = 4;
v_int32 value = *((p_int32)sequence);
v_int32 value = *(reinterpret_cast<p_int32>(const_cast<char*>(sequence)));
code = ((7 & byte) << 18) |
(((value >> 24) & 0xFF) & 63) |
(((value >> 16) & 0xFF) & 63) << 6 |
@ -117,32 +117,32 @@ v_int32 Unicode::encodeUtf8Char(const char* sequence, v_buff_size& length){
v_buff_size Unicode::decodeUtf8Char(v_int32 code, p_char8 buffer) {
if(code >= 0x00000080 && code < 0x00000800){
*((p_int16) buffer) = htons(((((code >> 6) & 31) | 192) << 8) | ((code & 63) | 128));
*(reinterpret_cast<p_int16>(buffer)) = htons(((((code >> 6) & 31) | 192) << 8) | ((code & 63) | 128));
return 2;
} else if(code >= 0x00000800 && code < 0x00010000){
*((p_int16) buffer) = htons((((( code >> 12 ) & 15) | 224) << 8) |
*(reinterpret_cast<p_int16>(buffer)) = htons((((( code >> 12 ) & 15) | 224) << 8) |
(((code >> 6 ) & 63) | 128));
buffer[2] = (code & 63) | 128;
return 3;
} else if(code >= 0x00010000 && code < 0x00200000){
*((p_int32) buffer) = htonl(((((code >> 18 ) & 7) | 240) << 24) |
*(reinterpret_cast<p_int32>(buffer)) = htonl(((((code >> 18 ) & 7) | 240) << 24) |
((((code >> 12 ) & 63) | 128) << 16) |
((((code >> 6 ) & 63) | 128) << 8) |
(( code & 63) | 128) );
return 4;
} else if(code >= 0x00200000 && code < 0x04000000){
*((p_int32) buffer) = htonl(((((code >> 24 ) & 3) | 248) << 24) |
*(reinterpret_cast<p_int32>(buffer)) = htonl(((((code >> 24 ) & 3) | 248) << 24) |
((((code >> 18 ) & 63) | 128) << 16) |
((((code >> 12 ) & 63) | 128) << 8) |
(((code >> 6 ) & 63) | 128));
buffer[4] = (code & 63) | 128;
return 5;
} else if(code >= 0x04000000){
*((p_int32) buffer) = htonl(((((code >> 30 ) & 1) | 252) << 24) |
*(reinterpret_cast<p_int32>(buffer)) = htonl(((((code >> 30 ) & 1) | 252) << 24) |
((((code >> 24 ) & 63) | 128) << 16) |
((((code >> 18 ) & 63) | 128) << 8) |
(((code >> 12 ) & 63) | 128));
*((p_int16) &buffer[4]) = htons(((((code >> 6 ) & 63) | 128) << 8) | (code & 63));
*(reinterpret_cast<p_int16>(&buffer[4])) = htons(((((code >> 6 ) & 63) | 128) << 8) | (code & 63));
return 6;
}
buffer[0] = v_char8(code);

6
src/oatpp/encoding/Url.cpp
View File

@ -65,7 +65,7 @@ void Url::Config::disallowCharRange(v_char8 from, v_char8 to) {
void Url::encode(data::stream::ConsistentOutputStream *stream, const void *data, v_buff_size size, const Config& config) {
p_char8 pdata = (p_char8) data;
auto pdata = reinterpret_cast<const char*>(data);
for(v_buff_size i = 0; i < size; i++) {
v_char8 c = pdata[i];
@ -83,7 +83,7 @@ void Url::encode(data::stream::ConsistentOutputStream *stream, const void *data,
void Url::decode(data::stream::ConsistentOutputStream* stream, const void* data, v_buff_size size) {
p_char8 pdata = (p_char8) data;
auto pdata = reinterpret_cast<const char*>(data);
v_buff_size i = 0;
while (i < size) {
@ -120,4 +120,4 @@ oatpp::String Url::decode(const oatpp::String data) {
return stream.toString();
}
}}
}}

12
src/oatpp/network/Url.cpp
View File

@ -36,7 +36,7 @@ oatpp::String Url::Parser::parseScheme(oatpp::parser::Caret& caret) {
std::unique_ptr<v_char8[]> buff(new v_char8[size]);
std::memcpy(buff.get(), &caret.getData()[pos0], size);
utils::String::lowerCase_ASCII(buff.get(), size);
return oatpp::String((const char*)buff.get(), size);
return oatpp::String(reinterpret_cast<const char*>(buff.get()), size);
}
return nullptr;
}
@ -75,19 +75,19 @@ Url::Authority Url::Parser::parseAuthority(oatpp::parser::Caret& caret) {
Url::Authority result;
if(atPos > -1) {
result.userInfo = oatpp::String((const char*)&data[pos0], atPos - pos0);
result.userInfo = oatpp::String(&data[pos0], atPos - pos0);
}
if(portPos > hostPos) {
result.host = oatpp::String((const char*)&data[hostPos], portPos - 1 - hostPos);
result.host = oatpp::String(&data[hostPos], portPos - 1 - hostPos);
char* end;
result.port = std::strtol((const char*)&data[portPos], &end, 10);
bool success = (((v_buff_size)end - (v_buff_size)&data[portPos]) == pos - portPos);
result.port = std::strtol(&data[portPos], &end, 10);
bool success = ((reinterpret_cast<v_buff_size>(end) - reinterpret_cast<v_buff_size>(&data[portPos])) == pos - portPos);
if(!success) {
caret.setError("Invalid port string");
}
} else {
result.host = oatpp::String((const char*)&data[hostPos], pos - pos0);
result.host = oatpp::String(&data[hostPos], pos - pos0);
}
return result;

6
src/oatpp/network/monitor/ConnectionMonitor.cpp
View File

@ -50,7 +50,7 @@ ConnectionMonitor::ConnectionProxy::ConnectionProxy(const std::shared_ptr<Monito
ConnectionMonitor::ConnectionProxy::~ConnectionProxy() {
m_monitor->removeConnection((v_uint64) this);
m_monitor->removeConnection(reinterpret_cast<v_uint64>(this));
std::lock_guard<std::mutex> lock(m_statsMutex);
@ -122,7 +122,7 @@ void ConnectionMonitor::Monitor::monitorTask(std::shared_ptr<Monitor> monitor) {
for(auto& caddr : monitor->m_connections) {
auto connection = (ConnectionProxy*) caddr;
auto connection = reinterpret_cast<ConnectionProxy*>(caddr);
std::lock_guard<std::mutex> dataLock(connection->m_statsMutex);
std::lock_guard<std::mutex> analysersLock(monitor->m_checkMutex);
@ -174,7 +174,7 @@ std::shared_ptr<ConnectionMonitor::Monitor> ConnectionMonitor::Monitor::createSh
void ConnectionMonitor::Monitor::addConnection(ConnectionProxy* connection) {
std::lock_guard<std::mutex> lock(m_connectionsMutex);
m_connections.insert((v_uint64) connection);
m_connections.insert(reinterpret_cast<v_uint64>(connection));
}
void ConnectionMonitor::Monitor::freeConnectionStats(ConnectionStats& stats) {

4
src/oatpp/network/tcp/Connection.cpp
View File

@ -111,7 +111,7 @@ v_io_size Connection::write(const void *buff, v_buff_size count, async::Action&
flags |= MSG_NOSIGNAL;
#endif
auto result = ::send(m_handle, buff, (size_t)count, flags);
auto result = ::send(m_handle, buff, static_cast<size_t>(count), flags);
if(result < 0) {
auto e = errno;
@ -169,7 +169,7 @@ v_io_size Connection::read(void *buff, v_buff_size count, async::Action& action)
errno = 0;
auto result = ::read(m_handle, buff, (size_t)count);
auto result = ::read(m_handle, buff, static_cast<size_t>(count));
if(result < 0) {
auto e = errno;

4
src/oatpp/network/tcp/client/ConnectionProvider.cpp
View File

@ -123,7 +123,7 @@ provider::ResourceHandle<data::stream::IOStream> ConnectionProvider::get() {
if(clientHandle >= 0) {
if(connect(clientHandle, currResult->ai_addr, (int)currResult->ai_addrlen) == 0) {
if(connect(clientHandle, currResult->ai_addr, static_cast<int>(currResult->ai_addrlen)) == 0) {
break;
} else {
err = errno;
@ -282,7 +282,7 @@ oatpp::async::CoroutineStarterForResult<const provider::ResourceHandle<data::str
Action doConnect() {
errno = 0;
auto res = connect(m_clientHandle, m_currentResult->ai_addr, (int)m_currentResult->ai_addrlen);
auto res = connect(m_clientHandle, m_currentResult->ai_addr, static_cast<int>(m_currentResult->ai_addrlen));
#if defined(WIN32) || defined(_WIN32)

14
src/oatpp/network/tcp/server/ConnectionProvider.cpp
View File

@ -280,7 +280,7 @@ oatpp::v_io_handle ConnectionProvider::instantiateServer(){
"Warning. Failed to set %s for accepting socket: %s", "SO_REUSEADDR", strerror(errno));
}
if (bind(serverHandle, currResult->ai_addr, (int) currResult->ai_addrlen) == 0 &&
if (bind(serverHandle, currResult->ai_addr, static_cast<int>(currResult->ai_addrlen)) == 0 &&
listen(serverHandle, 10000) == 0)
{
break;
@ -310,7 +310,7 @@ oatpp::v_io_handle ConnectionProvider::instantiateServer(){
::sockaddr_in s_in;
::memset(&s_in, 0, sizeof(s_in));
::socklen_t s_in_len = sizeof(s_in);
::getsockname(serverHandle, (sockaddr *)&s_in, &s_in_len);
::getsockname(serverHandle, reinterpret_cast<sockaddr*>(&s_in), &s_in_len);
setProperty(PROPERTY_PORT, oatpp::utils::conversion::int32ToStr(ntohs(s_in.sin_port)));
return serverHandle;
@ -355,7 +355,7 @@ provider::ResourceHandle<data::stream::IOStream> ConnectionProvider::getExtended
data::stream::Context::Properties properties;
oatpp::v_io_handle handle = accept(m_serverHandle, (sockaddr*) &clientAddress, &clientAddressSize);
oatpp::v_io_handle handle = accept(m_serverHandle, reinterpret_cast<sockaddr*>(&clientAddress), &clientAddressSize);
if(!oatpp::isValidIOHandle(handle)) {
return nullptr;
@ -364,20 +364,20 @@ provider::ResourceHandle<data::stream::IOStream> ConnectionProvider::getExtended
if (clientAddress.ss_family == AF_INET) {
char strIp[INET_ADDRSTRLEN];
sockaddr_in* sockAddress = (sockaddr_in*) &clientAddress;
sockaddr_in* sockAddress = reinterpret_cast<sockaddr_in*>(&clientAddress);
inet_ntop(AF_INET, &sockAddress->sin_addr, strIp, INET_ADDRSTRLEN);
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS, oatpp::String((const char*) strIp));
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS, oatpp::String(reinterpret_cast<const char*>(strIp)));
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS_FORMAT, "ipv4");
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_PORT, oatpp::utils::conversion::int32ToStr(sockAddress->sin_port));
} else if (clientAddress.ss_family == AF_INET6) {
char strIp[INET6_ADDRSTRLEN];
sockaddr_in6* sockAddress = (sockaddr_in6*) &clientAddress;
sockaddr_in6* sockAddress = reinterpret_cast<sockaddr_in6*>(&clientAddress);
inet_ntop(AF_INET6, &sockAddress->sin6_addr, strIp, INET6_ADDRSTRLEN);
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS, oatpp::String((const char*) strIp));
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS, oatpp::String(reinterpret_cast<const char*>(strIp)));
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_ADDRESS_FORMAT, "ipv6");
properties.put_LockFree(ExtendedConnection::PROPERTY_PEER_PORT, oatpp::utils::conversion::int32ToStr(sockAddress->sin6_port));

10
src/oatpp/network/virtual_/Interface.cpp
View File

@ -84,7 +84,7 @@ Interface::~Interface() {
{
std::lock_guard<std::mutex> lock(m_listenerMutex);
if ((void*)m_listenerLock != nullptr) {
if (m_listenerLock != nullptr) {
OATPP_LOGE("[oatpp::network::virtual_::Interface::~Interface()]",
"Error! Interface destructor called, but listener is still bonded!!!");
m_listenerLock.load()->m_interface = nullptr;
@ -161,7 +161,7 @@ std::shared_ptr<Socket> Interface::acceptSubmission(const std::shared_ptr<Connec
std::shared_ptr<Interface::ListenerLock> Interface::bind() {
std::lock_guard<std::mutex> lock(m_listenerMutex);
if((void*)m_listenerLock == nullptr) {
if(m_listenerLock == nullptr) {
m_listenerLock = new ListenerLock(this);
return std::shared_ptr<ListenerLock>(m_listenerLock.load());
}
@ -171,7 +171,7 @@ std::shared_ptr<Interface::ListenerLock> Interface::bind() {
void Interface::unbindListener(ListenerLock* listenerLock) {
std::lock_guard<std::mutex> lock(m_listenerMutex);
if((void*)m_listenerLock && m_listenerLock == listenerLock) {
if(m_listenerLock != nullptr && m_listenerLock == listenerLock) {
m_listenerLock = nullptr;
dropAllConnection();
} else {
@ -180,7 +180,7 @@ void Interface::unbindListener(ListenerLock* listenerLock) {
}
std::shared_ptr<Interface::ConnectionSubmission> Interface::connect() {
if((void*)m_listenerLock) {
if(m_listenerLock != nullptr) {
auto submission = std::make_shared<ConnectionSubmission>(true);
{
std::lock_guard<std::mutex> lock(m_mutex);
@ -193,7 +193,7 @@ std::shared_ptr<Interface::ConnectionSubmission> Interface::connect() {
}
std::shared_ptr<Interface::ConnectionSubmission> Interface::connectNonBlocking() {
if((void*)m_listenerLock) {
if(m_listenerLock != nullptr) {
std::shared_ptr<ConnectionSubmission> submission;
{
std::unique_lock<std::mutex> lock(m_mutex, std::try_to_lock);

2
src/oatpp/parser/json/Beautifier.cpp
View File

@ -53,7 +53,7 @@ v_io_size Beautifier::write(const void *data, v_buff_size count, async::Action&
for(v_buff_size i = 0; i < count; i ++) {
v_char8 c = ((p_char8) data) [i];
v_char8 c = (reinterpret_cast<const char*>(data)) [i];
if(m_isCharEscaped) {
m_isCharEscaped = false;

16
src/oatpp/parser/json/Utils.cpp
View File

@ -223,10 +223,10 @@ oatpp::String Utils::escapeString(const char* data, v_buff_size size, v_uint32 f
v_buff_size safeSize;
v_buff_size escapedSize = calcEscapedStringSize(data, size, safeSize, flags);
if(escapedSize == size) {
return String((const char*)data, size);
return String(data, size);
}
auto result = String(escapedSize);
p_char8 resultData = (p_char8) result->data();
p_char8 resultData = reinterpret_cast<p_char8>(const_cast<char*>(result->data()));
v_buff_size pos = 0;
{
@ -285,7 +285,7 @@ oatpp::String Utils::escapeString(const char* data, v_buff_size size, v_uint32 f
v_buff_size charSize = oatpp::encoding::Unicode::getUtf8CharSequenceLength(a);
if (charSize != 0) {
if (!(flags & FLAG_ESCAPE_UTF8CHAR)) {
std::memcpy((void*)&resultData[pos], (void*)&data[i], charSize);
std::memcpy(reinterpret_cast<void*>(&resultData[pos]), reinterpret_cast<void*>(const_cast<char*>(&data[i])), charSize);
pos += charSize;
}
else {
@ -304,7 +304,7 @@ oatpp::String Utils::escapeString(const char* data, v_buff_size size, v_uint32 f
}
if(size > safeSize){
for(v_buff_size i = pos; (size_t) i < result->size(); i ++){
for(v_buff_size i = pos; static_cast<size_t>(i) < result->size(); i ++){
resultData[i] = '?';
}
}
@ -377,9 +377,9 @@ oatpp::String Utils::unescapeString(const char* data, v_buff_size size, v_int64&
}
auto result = String(unescapedSize);
if(unescapedSize == size) {
std::memcpy((void*) result->data(), data, size);
std::memcpy(reinterpret_cast<void*>(const_cast<char*>(result->data())), data, size);
} else {
unescapeStringToBuffer(data, size, (p_char8) result->data());
unescapeStringToBuffer(data, size, reinterpret_cast<p_char8>(const_cast<char*>(result->data())));
}
return result;
@ -394,9 +394,9 @@ std::string Utils::unescapeStringToStdString(const char* data, v_buff_size size,
std::string result;
result.resize(unescapedSize);
if(unescapedSize == size) {
std::memcpy((p_char8) result.data(), data, size);
std::memcpy(reinterpret_cast<void*>(const_cast<char*>(result.data())), data, size);
} else {
unescapeStringToBuffer(data, size, (p_char8) result.data());
unescapeStringToBuffer(data, size, reinterpret_cast<p_char8>(const_cast<char*>(result.data())));
}
return result;

8
src/oatpp/web/mime/multipart/StatefulParser.cpp
View File

@ -159,7 +159,7 @@ StatefulParser::ListenerCall StatefulParser::parseNext_Boundary(data::buffer::In
checkSize = size;
}
parser::Caret caret((const char*)data, size);
parser::Caret caret(reinterpret_cast<const char*>(data), size);
if(caret.isAtText(&sampleData[m_currBoundaryCharIndex], checkSize, true)) {
@ -198,7 +198,7 @@ StatefulParser::ListenerCall StatefulParser::parseNext_Boundary(data::buffer::In
void StatefulParser::parseNext_AfterBoundary(data::buffer::InlineWriteData& inlineData) {
p_char8 data = (p_char8) inlineData.currBufferPtr;
p_char8 data = reinterpret_cast<p_char8>(const_cast<void*>(inlineData.currBufferPtr));
auto size = inlineData.bytesLeft;
if(m_currBoundaryCharIndex == 0) {
@ -242,7 +242,7 @@ StatefulParser::ListenerCall StatefulParser::parseNext_Headers(data::buffer::Inl
ListenerCall result;
p_char8 data = (p_char8) inlineData.currBufferPtr;
p_char8 data = reinterpret_cast<p_char8>(const_cast<void*>(inlineData.currBufferPtr));
auto size = inlineData.bytesLeft;
for(v_buff_size i = 0; i < size; i ++) {
@ -286,7 +286,7 @@ StatefulParser::ListenerCall StatefulParser::parseNext_Data(data::buffer::Inline
ListenerCall result;
const char* data = (const char*) inlineData.currBufferPtr;
const char* data = reinterpret_cast<const char*>(inlineData.currBufferPtr);
auto size = inlineData.bytesLeft;
parser::Caret caret(data, size);

14
src/oatpp/web/protocol/http/Http.cpp
View File

@ -172,8 +172,8 @@ Range Range::parse(oatpp::parser::Caret& caret) {
caret.findRN();
endLabel.end();
auto start = oatpp::utils::conversion::strToInt64((const char*) startLabel.getData());
auto end = oatpp::utils::conversion::strToInt64((const char*) endLabel.getData());
auto start = oatpp::utils::conversion::strToInt64(startLabel.getData());
auto end = oatpp::utils::conversion::strToInt64(endLabel.getData());
return Range(unitsLabel.toString(), start, end);
}
@ -232,13 +232,13 @@ ContentRange ContentRange::parse(oatpp::parser::Caret& caret) {
caret.findRN();
sizeLabel.end();
v_int64 start = oatpp::utils::conversion::strToInt64((const char*) startLabel.getData());
v_int64 end = oatpp::utils::conversion::strToInt64((const char*) endLabel.getData());
v_int64 start = oatpp::utils::conversion::strToInt64(startLabel.getData());
v_int64 end = oatpp::utils::conversion::strToInt64(endLabel.getData());
v_int64 size = 0;
bool isSizeKnown = false;
if(sizeLabel.getData()[0] != '*') {
isSizeKnown = true;
size = oatpp::utils::conversion::strToInt64((const char*) sizeLabel.getData());
size = oatpp::utils::conversion::strToInt64(sizeLabel.getData());
}
return ContentRange(unitsLabel.toString(), start, end, size, isSizeKnown);
@ -325,7 +325,7 @@ void Parser::parseResponseStartingLine(ResponseStartingLine& line,
return;
}
line.statusCode = (v_int32)caret.parseInt();
line.statusCode = static_cast<v_int32>(caret.parseInt());
auto descriptionLabel = caret.putLabel();
if(caret.findRN()){
@ -381,7 +381,7 @@ void Parser::parseHeaders(Headers& headers,
void Parser::parseHeaderValueData(HeaderValueData& data, const oatpp::data::share::StringKeyLabel& headerValue, char separator) {
oatpp::parser::Caret caret((const char*) headerValue.getData(), headerValue.getSize());
oatpp::parser::Caret caret(reinterpret_cast<const char*>(headerValue.getData()), headerValue.getSize());
const char charSet[5] = {' ', '=', separator, '\r', '\n'};
const char charSet2[4] = {' ', separator, '\r', '\n'};

8
src/oatpp/web/protocol/http/encoding/Chunked.cpp
View File

@ -69,7 +69,7 @@ v_int32 EncoderChunked::iterate(data::buffer::InlineReadData& dataIn, data::buff
stream.write("\r\n", 2, action);
m_chunkHeader = stream.toString();
dataOut.set((p_char8) m_chunkHeader->data(), m_chunkHeader->size());
dataOut.set(reinterpret_cast<p_char8>(const_cast<char*>(m_chunkHeader->data())), m_chunkHeader->size());
m_firstChunk = false;
m_writeChunkHeader = false;
@ -96,7 +96,7 @@ v_int32 EncoderChunked::iterate(data::buffer::InlineReadData& dataIn, data::buff
stream.write("0\r\n\r\n", 5, action);
m_chunkHeader = stream.toString();
dataOut.set((p_char8) m_chunkHeader->data(), m_chunkHeader->size());
dataOut.set(reinterpret_cast<p_char8>(const_cast<char*>(m_chunkHeader->data())), m_chunkHeader->size());
m_firstChunk = false;
m_writeChunkHeader = false;
@ -147,10 +147,10 @@ v_int32 DecoderChunked::readHeader(data::buffer::InlineReadData& dataIn) {
if (pos > 2 && m_chunkHeaderBuffer.getData()[pos - 2] == '\r' && m_chunkHeaderBuffer.getData()[pos - 1] == '\n') {
if(m_firstChunk) {
m_currentChunkSize = strtol((const char *) m_chunkHeaderBuffer.getData(), nullptr, 16);
m_currentChunkSize = strtol(reinterpret_cast<const char *>(m_chunkHeaderBuffer.getData()), nullptr, 16);
} else {
// skip "/r/n" before chunk size
m_currentChunkSize = strtol((const char *) (m_chunkHeaderBuffer.getData() + 2), nullptr, 16);
m_currentChunkSize = strtol(reinterpret_cast<const char *>(m_chunkHeaderBuffer.getData() + 2), nullptr, 16);
}
if (m_currentChunkSize > 0) {

4
src/oatpp/web/protocol/http/incoming/RequestHeadersReader.cpp
View File

@ -93,7 +93,7 @@ RequestHeadersReader::Result RequestHeadersReader::readHeaders(data::stream::Inp
}
if(error.ioStatus > 0) {
oatpp::parser::Caret caret ((const char*) m_bufferStream->getData(), m_bufferStream->getCurrentPosition());
oatpp::parser::Caret caret (reinterpret_cast<const char*>(m_bufferStream->getData()), m_bufferStream->getCurrentPosition());
http::Status status;
http::Parser::parseRequestStartingLine(result.startingLine, nullptr, caret, status);
if(status.code == 0) {
@ -153,7 +153,7 @@ RequestHeadersReader::readHeadersAsync(const std::shared_ptr<data::stream::Input
Action parseHeaders() {
oatpp::parser::Caret caret ((const char*) m_this->m_bufferStream->getData(), m_this->m_bufferStream->getCurrentPosition());
oatpp::parser::Caret caret (reinterpret_cast<const char*>(m_this->m_bufferStream->getData()), m_this->m_bufferStream->getCurrentPosition());
http::Status status;
http::Parser::parseRequestStartingLine(m_result.startingLine, nullptr, caret, status);
if(status.code == 0) {

2
src/oatpp/web/protocol/http/incoming/ResponseHeadersReader.cpp
View File

@ -43,7 +43,7 @@ v_io_size ResponseHeadersReader::readHeadersSectionIterative(ReadHeadersIteratio
}
}
auto bufferData = (p_char8) m_buffer.getData();
auto bufferData = reinterpret_cast<p_char8>(const_cast<void*>(m_buffer.getData()));
auto res = connection->read(bufferData, desiredToRead, action);
if(res > 0) {

4
src/oatpp/web/protocol/http/outgoing/BufferBody.cpp
View File

@ -29,7 +29,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
BufferBody::BufferBody(const oatpp::String &buffer, const data::share::StringKeyLabel &contentType)
: m_buffer(buffer ? buffer : "")
, m_contentType(contentType)
, m_inlineData((void*) m_buffer->data(), m_buffer->size())
, m_inlineData(reinterpret_cast<void*>(const_cast<char*>(m_buffer->data())), m_buffer->size())
{}
std::shared_ptr<BufferBody> BufferBody::createShared(const oatpp::String &buffer,
@ -67,7 +67,7 @@ void BufferBody::declareHeaders(Headers &headers) {
}
p_char8 BufferBody::getKnownData() {
return (p_char8) m_buffer->data();
return reinterpret_cast<p_char8>(const_cast<char*>(m_buffer->data()));
}
v_int64 BufferBody::getKnownSize() {

6
src/oatpp/web/protocol/http/outgoing/MultipartBody.cpp
View File

@ -55,7 +55,7 @@ v_io_size MultipartBody::read(void *buffer, v_buff_size count, async::Action& ac
return 0;
}
p_char8 currBufferPtr = (p_char8) buffer;
p_char8 currBufferPtr = reinterpret_cast<p_char8>(buffer);
v_io_size bytesLeft = count;
v_io_size res = 0;
@ -134,7 +134,7 @@ v_io_size MultipartBody::readBoundary(const std::shared_ptr<Multipart>& multipar
boundary = "\r\n--" + multipart->getBoundary() + "\r\n";
}
readStream.reset(boundary.getPtr(), (p_char8) boundary->data(), boundary->size());
readStream.reset(boundary.getPtr(), reinterpret_cast<p_char8>(const_cast<char*>(boundary->data())), boundary->size());
}
@ -161,7 +161,7 @@ v_io_size MultipartBody::readHeaders(const std::shared_ptr<Multipart>& multipart
http::Utils::writeHeaders(part->getHeaders(), &stream);
stream.writeSimple("\r\n", 2);
auto str = stream.toString();
readStream.reset(str.getPtr(), (p_char8) str->data(), str->size());
readStream.reset(str.getPtr(), reinterpret_cast<p_char8>(const_cast<char*>(str->data())), str->size());
}

4
src/oatpp/web/server/AsyncHttpConnectionHandler.cpp
View File

@ -29,7 +29,7 @@ namespace oatpp { namespace web { namespace server {
void AsyncHttpConnectionHandler::onTaskStart(const provider::ResourceHandle<data::stream::IOStream>& connection) {
std::lock_guard<oatpp::concurrency::SpinLock> lock(m_connectionsLock);
m_connections.insert({(v_uint64) connection.object.get(), connection});
m_connections.insert({reinterpret_cast<v_uint64>(connection.object.get()), connection});
if(!m_continue.load()) {
connection.invalidator->invalidate(connection.object);
@ -39,7 +39,7 @@ void AsyncHttpConnectionHandler::onTaskStart(const provider::ResourceHandle<data
void AsyncHttpConnectionHandler::onTaskEnd(const provider::ResourceHandle<data::stream::IOStream>& connection) {
std::lock_guard<oatpp::concurrency::SpinLock> lock(m_connectionsLock);
m_connections.erase((v_uint64) connection.object.get());
m_connections.erase(reinterpret_cast<v_uint64>(connection.object.get()));
}
void AsyncHttpConnectionHandler::invalidateAllConnections() {

4
src/oatpp/web/server/HttpConnectionHandler.cpp
View File

@ -40,7 +40,7 @@ namespace oatpp { namespace web { namespace server {
void HttpConnectionHandler::onTaskStart(const provider::ResourceHandle<data::stream::IOStream>& connection) {
std::lock_guard<oatpp::concurrency::SpinLock> lock(m_connectionsLock);
m_connections.insert({(v_uint64) connection.object.get(), connection});
m_connections.insert({reinterpret_cast<v_uint64>(connection.object.get()), connection});
if(!m_continue.load()) {
connection.invalidator->invalidate(connection.object);
@ -50,7 +50,7 @@ void HttpConnectionHandler::onTaskStart(const provider::ResourceHandle<data::str
void HttpConnectionHandler::onTaskEnd(const provider::ResourceHandle<data::stream::IOStream>& connection) {
std::lock_guard<oatpp::concurrency::SpinLock> lock(m_connectionsLock);
m_connections.erase((v_uint64) connection.object.get());
m_connections.erase(reinterpret_cast<v_uint64>(connection.object.get()));
}
void HttpConnectionHandler::invalidateAllConnections() {

4
src/oatpp/web/server/handler/AuthorizationHandler.cpp
View File

@ -68,8 +68,8 @@ std::shared_ptr<handler::AuthorizationObject> BasicAuthorizationHandler::handleA
parser::Caret caret(auth);
if (caret.findChar(':')) {
oatpp::String userId((const char *) &caret.getData()[0], caret.getPosition());
oatpp::String password((const char *) &caret.getData()[caret.getPosition() + 1],
oatpp::String userId(&caret.getData()[0], caret.getPosition());
oatpp::String password(&caret.getData()[caret.getPosition() + 1],
caret.getDataSize() - caret.getPosition() - 1);
auto authResult = authorize(userId, password);
if(authResult) {

18
src/oatpp/web/url/mapping/Pattern.cpp
View File

@ -50,7 +50,7 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_buff_size size){
if(a == '/'){
if(i - lastPos > 0){
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String((const char*)&data[lastPos], i - lastPos));
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String(reinterpret_cast<const char*>(&data[lastPos]), i - lastPos));
result->m_parts->push_back(part);
}
@ -59,10 +59,10 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_buff_size size){
} else if(a == '*'){
lastPos = i + 1;
if(size > lastPos){
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String((const char*)&data[lastPos], size - lastPos));
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String(reinterpret_cast<const char*>(&data[lastPos]), size - lastPos));
result->m_parts->push_back(part);
}else{
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String((v_buff_size)0));
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String(0));
result->m_parts->push_back(part);
}
return result;
@ -75,10 +75,10 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_buff_size size){
}
if(i > lastPos){
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String((const char*)&data[lastPos], i - lastPos));
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String(reinterpret_cast<const char*>(&data[lastPos]), i - lastPos));
result->m_parts->push_back(part);
}else{
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String((v_buff_size)0));
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String(0));
result->m_parts->push_back(part);
}
@ -91,7 +91,7 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_buff_size size){
}
if(i - lastPos > 0){
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String((const char*)&data[lastPos], i - lastPos));
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String(reinterpret_cast<const char*>(&data[lastPos]), i - lastPos));
result->m_parts->push_back(part);
}
@ -99,11 +99,11 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_buff_size size){
}
std::shared_ptr<Pattern> Pattern::parse(const char* data){
return parse((p_char8) data, std::strlen(data));
return parse(reinterpret_cast<p_char8>(const_cast<char*>(data)), std::strlen(data));
}
std::shared_ptr<Pattern> Pattern::parse(const oatpp::String& data){
return parse((p_char8) data->data(), data->size());
return parse(reinterpret_cast<p_char8>(const_cast<char*>(data->data())), data->size());
}
v_char8 Pattern::findSysChar(oatpp::parser::Caret& caret) {
@ -121,7 +121,7 @@ v_char8 Pattern::findSysChar(oatpp::parser::Caret& caret) {
bool Pattern::match(const StringKeyLabel& url, MatchMap& matchMap) {
oatpp::parser::Caret caret((const char*) url.getData(), url.getSize());
oatpp::parser::Caret caret(reinterpret_cast<const char*>(url.getData()), url.getSize());
if (m_parts->empty()) {
return !caret.skipChar('/');

2
src/oatpp/web/url/mapping/Router.hpp
View File

@ -148,7 +148,7 @@ public:
for(auto& pair : m_endpointsByPattern) {
auto mapping = pair.first->toString();
OATPP_LOGD("Router", "url '%s %s' -> mapped", (const char*)branch.getData(), mapping->c_str());
OATPP_LOGD("Router", "url '%s %s' -> mapped", reinterpret_cast<const char*>(branch.getData()), mapping->c_str());
}
}

12
test/oatpp/core/async/LockTest.cpp
View File

@ -174,17 +174,17 @@ void LockTest::onRun() {
oatpp::async::Executor executor(10, 1, 1);
for (v_int32 c = 0; c <= 127; c++) {
executor.execute<TestCoroutine>((char)c, &buff, &lock);
executor.execute<TestCoroutine>(static_cast<char>(c), &buff, &lock);
}
for (v_int32 c = 128; c <= 200; c++) {
executor.execute<TestCoroutine2>((char)c, &buff, &lock);
executor.execute<TestCoroutine2>(static_cast<char>(c), &buff, &lock);
}
std::list<std::thread> threads;
for (v_int32 c = 201; c <= 255; c++) {
threads.push_back(std::thread(testMethod, (char)c, &buff, &lock));
threads.push_back(std::thread(testMethod, static_cast<char>(c), &buff, &lock));
}
for (std::thread &thread : threads) {
@ -198,10 +198,10 @@ void LockTest::onRun() {
auto result = buffer.toString();
for (v_int32 c = 0; c <= 255; c++) {
bool check = checkSymbol((char)c, result);
bool check = checkSymbol(static_cast<char>(c), result);
if(!check) {
v_int32 code = c;
auto str = oatpp::String((const char*)&c, 1);
auto str = oatpp::String(reinterpret_cast<const char*>(&c), 1);
OATPP_LOGE(TAG, "Failed for symbol %d, '%s'", code, str->data());
}
OATPP_ASSERT(check);
@ -209,4 +209,4 @@ void LockTest::onRun() {
}
}}}
}}}

10
test/oatpp/core/data/mapping/type/StringTest.cpp
View File

@ -42,7 +42,7 @@ void StringTest::onRun() {
oatpp::String s;
OATPP_ASSERT(!s);
OATPP_ASSERT(s == nullptr);
OATPP_ASSERT(s == (const char*) nullptr);
OATPP_ASSERT(s == static_cast<const char*>(nullptr));
OATPP_ASSERT(s.getValueType() == oatpp::String::Class::getType());
OATPP_LOGI(TAG, "OK");
}
@ -52,7 +52,6 @@ void StringTest::onRun() {
oatpp::String s(nullptr);
OATPP_ASSERT(!s);
OATPP_ASSERT(s == nullptr);
OATPP_ASSERT(s == (const char*) nullptr);
OATPP_ASSERT(s.getValueType() == oatpp::String::Class::getType());
OATPP_LOGI(TAG, "OK");
}
@ -62,7 +61,6 @@ void StringTest::onRun() {
oatpp::String s("abc\0xyz");
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 3);
OATPP_ASSERT(s == "abc");
OATPP_ASSERT(s == "abc\0xyz");
@ -75,7 +73,6 @@ void StringTest::onRun() {
oatpp::String s(a);
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 7);
OATPP_ASSERT(s != "abc");
OATPP_ASSERT(s != "abc\0xyz");
@ -90,7 +87,6 @@ void StringTest::onRun() {
oatpp::String s(std::move(a));
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 7);
OATPP_ASSERT(s != "abc");
OATPP_ASSERT(s != "abc\0xyz");
@ -105,7 +101,6 @@ void StringTest::onRun() {
s = "abc\0xyz";
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 3);
OATPP_ASSERT(s == "abc");
OATPP_ASSERT(s == "abc\0xyz");
@ -119,7 +114,6 @@ void StringTest::onRun() {
s = a;
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 7);
OATPP_ASSERT(s != "abc");
OATPP_ASSERT(s != "abc\0xyz");
@ -135,7 +129,6 @@ void StringTest::onRun() {
s = std::move(a);
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 7);
OATPP_ASSERT(s != "abc");
OATPP_ASSERT(s != "abc\0xyz");
@ -149,7 +142,6 @@ void StringTest::onRun() {
oatpp::String s = "";
OATPP_ASSERT(s);
OATPP_ASSERT(s != nullptr);
OATPP_ASSERT(s != (const char*) nullptr)
OATPP_ASSERT(s->size() == 0);
OATPP_LOGI(TAG, "OK");
}

6
test/oatpp/core/data/stream/BufferStreamTest.cpp
View File

@ -47,11 +47,11 @@ void BufferStreamTest::onRun() {
OATPP_ASSERT(stream.toString() == oatpp::utils::conversion::int32ToStr(101));
stream.setCurrentPosition(0);
stream << (v_float32)101.1;
stream << static_cast<v_float32>(101.1);
OATPP_ASSERT(stream.toString() == oatpp::utils::conversion::float32ToStr(101.1f));
stream.setCurrentPosition(0);
stream << (v_float64)101.1;
stream << static_cast<v_float64>(101.1);
OATPP_ASSERT(stream.toString() == oatpp::utils::conversion::float64ToStr(101.1));
stream.setCurrentPosition(0);
@ -146,4 +146,4 @@ void BufferStreamTest::onRun() {
}
}}}}}
}}}}}

14
test/oatpp/encoding/UnicodeTest.cpp
View File

@ -50,7 +50,7 @@ void writeBinaryInt(v_int32 value){
}
}
OATPP_LOGV("bin", "value='%s'", (const char*) &buff);
OATPP_LOGV("bin", "value='%s'", reinterpret_cast<const char*>(&buff));
}
@ -68,7 +68,7 @@ void UnicodeTest::onRun(){
for(v_int32 c = 128; c < 2048; c ++){
auto size = oatpp::encoding::Unicode::decodeUtf8Char(c, buff);
OATPP_ASSERT(size == 2);
auto code = oatpp::encoding::Unicode::encodeUtf8Char((const char*) buff, cnt);
auto code = oatpp::encoding::Unicode::encodeUtf8Char(reinterpret_cast<const char*>(buff), cnt);
OATPP_ASSERT(cnt == 2);
OATPP_ASSERT(code == c);
}
@ -78,7 +78,7 @@ void UnicodeTest::onRun(){
for(v_int32 c = 2048; c < 65536; c ++){
auto size = oatpp::encoding::Unicode::decodeUtf8Char(c, buff);
OATPP_ASSERT(size == 3);
auto code = oatpp::encoding::Unicode::encodeUtf8Char((const char*) buff, cnt);
auto code = oatpp::encoding::Unicode::encodeUtf8Char(reinterpret_cast<const char*>(buff), cnt);
OATPP_ASSERT(cnt == 3);
OATPP_ASSERT(code == c);
}
@ -88,7 +88,7 @@ void UnicodeTest::onRun(){
for(v_int32 c = 65536; c < 2097152; c ++){
auto size = oatpp::encoding::Unicode::decodeUtf8Char(c, buff);
OATPP_ASSERT(size == 4);
auto code = oatpp::encoding::Unicode::encodeUtf8Char((const char*) buff, cnt);
auto code = oatpp::encoding::Unicode::encodeUtf8Char(reinterpret_cast<const char*>(buff), cnt);
OATPP_ASSERT(cnt == 4);
OATPP_ASSERT(code == c);
}
@ -98,7 +98,7 @@ void UnicodeTest::onRun(){
for(v_int32 c = 2097152; c < 67108864; c ++){
auto size = oatpp::encoding::Unicode::decodeUtf8Char(c, buff);
OATPP_ASSERT(size == 5);
auto code = oatpp::encoding::Unicode::encodeUtf8Char((const char*) buff, cnt);
auto code = oatpp::encoding::Unicode::encodeUtf8Char(reinterpret_cast<const char*>(buff), cnt);
OATPP_ASSERT(cnt == 5);
OATPP_ASSERT(code == c);
}
@ -106,9 +106,9 @@ void UnicodeTest::onRun(){
// 6 byte test
for (v_int64 c = 67108864; c < 2147483647; c = c + 100) {
auto size = oatpp::encoding::Unicode::decodeUtf8Char((v_int32) c, buff);
auto size = oatpp::encoding::Unicode::decodeUtf8Char(static_cast<v_int32>(c), buff);
OATPP_ASSERT(size == 6);
auto code = oatpp::encoding::Unicode::encodeUtf8Char((const char*) buff, cnt);
auto code = oatpp::encoding::Unicode::encodeUtf8Char(reinterpret_cast<const char*>(buff), cnt);
OATPP_ASSERT(cnt == 6);
OATPP_ASSERT(code == c);
}

4
test/oatpp/encoding/UrlTest.cpp
View File

@ -37,7 +37,7 @@ void UrlTest::onRun(){
for(v_int32 i = 0; i < 100; i++) {
oatpp::String buff(100);
utils::random::Random::randomBytes((p_char8) buff->data(), buff->size());
utils::random::Random::randomBytes(reinterpret_cast<p_char8>(const_cast<char*>(buff->data())), buff->size());
auto encoded = oatpp::encoding::Url::encode(buff, config);
auto decoded = oatpp::encoding::Url::decode(encoded);
OATPP_ASSERT(decoded == buff);
@ -50,7 +50,7 @@ void UrlTest::onRun(){
for(v_int32 i = 0; i < 100; i++) {
oatpp::String buff(100);
utils::random::Random::randomBytes((p_char8) buff->data(), buff->size());
utils::random::Random::randomBytes(reinterpret_cast<p_char8>(const_cast<char*>(buff->data())), buff->size());
auto encoded = oatpp::encoding::Url::encode(buff, config);
auto decoded = oatpp::encoding::Url::decode(encoded);
OATPP_ASSERT(decoded == buff);

2
test/oatpp/network/monitor/ConnectionMonitorTest.cpp
View File

@ -49,7 +49,7 @@ public:
v_io_size read(void *buffer, v_buff_size count, async::Action &action) override {
OATPP_LOGI("TEST", "read(...)")
std::this_thread::sleep_for(std::chrono::milliseconds(100));
char* data = (char*) buffer;
char* data = reinterpret_cast<char*>(buffer);
data[0] = 'A';
return 1;
}

2
test/oatpp/web/ClientRetryTest.cpp
View File

@ -137,7 +137,7 @@ void runServer(v_uint16 port, v_int32 delaySeconds, v_int32 iterations, bool sta
std::this_thread::sleep_for(std::chrono::seconds(delaySeconds));
if(!stable) {
controller->available = !controller->available;
OATPP_LOGI("Server", "Available=%d", (v_int32)controller->available.load());
OATPP_LOGI("Server", "Available=%d", static_cast<v_int32>(controller->available.load()));
}
}

4
test/oatpp/web/server/ServerStopTest.cpp
View File

@ -44,7 +44,7 @@ public:
v_io_size read(void *buffer, v_buff_size count, async::Action &action) override {
std::this_thread::sleep_for(std::chrono::milliseconds(100));
char *data = (char *) buffer;
char *data = reinterpret_cast<char*>(buffer);
data[0] = 'A';
return 1;
}
@ -63,7 +63,7 @@ public:
oatpp::base::Environment::getMicroTickCount() + 100 * 1000);
return oatpp::IOError::RETRY_READ;
}
char *data = (char *) buffer;
char *data = reinterpret_cast<char*>(buffer);
data[0] = 'A';
return 1;
}