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

new string concept. basic refactoring

Browse Source
This commit is contained in:
lganzzzo 2018-06-26 02:30:01 +03:00
parent eb6d1b2362
commit 938592ff67
62 changed files with 580 additions and 615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
core/Types.cpp Normal file
View File

@ -0,0 +1,9 @@
//
// Types.cpp
// tls-libressl
//
// Created by Leonid on 6/26/18.
// Copyright © 2018 oatpp. All rights reserved.
//
#include "Types.hpp"

20
core/Types.hpp Normal file
View File

@ -0,0 +1,20 @@
//
// Types.hpp
// tls-libressl
//
// Created by Leonid on 6/26/18.
// Copyright © 2018 oatpp. All rights reserved.
//
#ifndef oatpp_Types_hpp
#define oatpp_Types_hpp
#include "oatpp/core/data/mapping/type/Primitive.hpp"
namespace oatpp {
typedef oatpp::data::mapping::type::String String;
}
#endif /* oatpp_Types_hpp */

115
core/base/String.cpp → core/base/StrBuffer.cpp
View File

@ -22,17 +22,17 @@
*
***************************************************************************/
#include "String.hpp"
#include "StrBuffer.hpp"
namespace oatpp { namespace base {
void String::set(const void* data, v_int32 size, bool hasOwnData) {
void StrBuffer::set(const void* data, v_int32 size, bool hasOwnData) {
m_data = (p_char8) data;
m_size = size;
m_hasOwnData = hasOwnData;
}
void String::setAndCopy(const void* data, const void* originData, v_int32 size){
void StrBuffer::setAndCopy(const void* data, const void* originData, v_int32 size){
m_data = (p_char8) data;
m_size = size;
//m_hasOwnData = false;
@ -42,17 +42,17 @@ void String::setAndCopy(const void* data, const void* originData, v_int32 size){
m_data[size] = 0;
}
std::shared_ptr<String> String::allocShared(const void* data, v_int32 size, bool copyAsOwnData) {
std::shared_ptr<StrBuffer> StrBuffer::allocShared(const void* data, v_int32 size, bool copyAsOwnData) {
if(copyAsOwnData) {
memory::AllocationExtras extras(size + 1);
const auto& ptr = memory::allocateSharedWithExtras<String>(extras);
const auto& ptr = memory::allocateSharedWithExtras<StrBuffer>(extras);
ptr->setAndCopy(extras.extraPtr, data, size);
return ptr;
}
return std::make_shared<String>(data, size, copyAsOwnData);
return std::make_shared<StrBuffer>(data, size, copyAsOwnData);
}
p_char8 String::allocString(const void* originData, v_int32 size, bool copyAsOwnData) {
p_char8 StrBuffer::allocStrBuffer(const void* originData, v_int32 size, bool copyAsOwnData) {
if(copyAsOwnData) {
p_char8 data = new v_char8[size + 1];
data[size] = 0;
@ -64,102 +64,94 @@ p_char8 String::allocString(const void* originData, v_int32 size, bool copyAsOwn
return (p_char8) originData;
}
String::~String() {
StrBuffer::~StrBuffer() {
if(m_hasOwnData) {
delete [] m_data;
}
m_data = nullptr;
}
std::shared_ptr<String> String::createShared(const void* data, v_int32 size, bool copyAsOwnData) {
std::shared_ptr<StrBuffer> StrBuffer::createShared(const void* data, v_int32 size, bool copyAsOwnData) {
return allocShared(data, size, copyAsOwnData);
}
std::shared_ptr<String> String::createShared(const char* data, bool copyAsOwnData) {
std::shared_ptr<StrBuffer> StrBuffer::createShared(const char* data, bool copyAsOwnData) {
return allocShared(data, (v_int32) std::strlen(data), copyAsOwnData);
}
std::shared_ptr<String> String::createShared(String* other, bool copyAsOwnData) {
std::shared_ptr<StrBuffer> StrBuffer::createShared(StrBuffer* other, bool copyAsOwnData) {
return allocShared(other->getData(), other->getSize(), copyAsOwnData);
}
std::shared_ptr<String> String::createShared(v_int32 size) {
std::shared_ptr<StrBuffer> StrBuffer::createShared(v_int32 size) {
return allocShared(nullptr, size, true);
}
std::shared_ptr<String> String::createSharedConcatenated(const void* data1, v_int32 size1, const void* data2, v_int32 size2) {
std::shared_ptr<StrBuffer> StrBuffer::createSharedConcatenated(const void* data1, v_int32 size1, const void* data2, v_int32 size2) {
const auto& ptr = allocShared(nullptr, size1 + size2, true);
std::memcpy(ptr->m_data, data1, size1);
std::memcpy(ptr->m_data + size1, data2, size2);
return ptr;
}
p_char8 String::getData() const {
p_char8 StrBuffer::getData() const {
return m_data;
}
v_int32 String::getSize() const {
v_int32 StrBuffer::getSize() const {
return m_size;
}
const char* String::c_str() const {
const char* StrBuffer::c_str() const {
return (const char*) m_data;
}
std::string String::std_str() const {
std::string StrBuffer::std_str() const {
return std::string((const char*) m_data, m_size);
}
bool String::hasOwnData() const {
bool StrBuffer::hasOwnData() const {
return m_hasOwnData;
}
std::shared_ptr<String> String::toLowerCase() const {
std::shared_ptr<StrBuffer> StrBuffer::toLowerCase() const {
const auto& ptr = allocShared(m_data, m_size, true);
lowerCase(ptr->m_data, ptr->m_size);
return ptr;
}
std::shared_ptr<String> String::toUpperCase() const {
std::shared_ptr<StrBuffer> StrBuffer::toUpperCase() const {
const auto& ptr = allocShared(m_data, m_size, true);
upperCase(ptr->m_data, ptr->m_size);
return ptr;
}
bool String::equals(const void* data, v_int32 size) const {
bool StrBuffer::equals(const void* data, v_int32 size) const {
if(m_size == size) {
return equals(m_data, data, size);
}
return false;
}
bool String::equals(const char* data) const {
bool StrBuffer::equals(const char* data) const {
if(m_size == (v_int32) std::strlen(data)) {
return equals(m_data, data, m_size);
}
return false;
}
bool String::equals(String* other) const {
return equals((String*) this, other);
}
bool String::equals(const String::PtrWrapper& other) const {
return equals((String*) this, other.get());
bool StrBuffer::equals(StrBuffer* other) const {
return equals((StrBuffer*) this, other);
}
bool String::equals(const std::shared_ptr<String>& other) const {
return equals((String*) this, other.get());
}
bool String::startsWith(const void* data, v_int32 size) const {
bool StrBuffer::startsWith(const void* data, v_int32 size) const {
if(m_size >= size) {
return equals(m_data, data, size);
}
return false;
}
bool String::startsWith(const char* data) const {
bool StrBuffer::startsWith(const char* data) const {
v_int32 length = (v_int32) std::strlen(data);
if(m_size >= length) {
return equals(m_data, data, length);
@ -167,7 +159,7 @@ bool String::startsWith(const char* data) const {
return false;
}
bool String::startsWith(String* data) const {
bool StrBuffer::startsWith(StrBuffer* data) const {
if(m_size >= data->m_size) {
return equals(m_data, data, data->m_size);
}
@ -176,11 +168,11 @@ bool String::startsWith(String* data) const {
// static
v_int32 String::compare(const void* data1, const void* data2, v_int32 size) {
v_int32 StrBuffer::compare(const void* data1, const void* data2, v_int32 size) {
return std::memcmp(data1, data2, size);
}
v_int32 String::compare(String* str1, String* str2) {
v_int32 StrBuffer::compare(StrBuffer* str1, StrBuffer* str2) {
if(str1 == str2) {
return 0;
}
@ -191,25 +183,25 @@ v_int32 String::compare(String* str1, String* str2) {
}
}
bool String::equals(const void* data1, const void* data2, v_int32 size) {
bool StrBuffer::equals(const void* data1, const void* data2, v_int32 size) {
return (data1 == data2) || (std::memcmp(data1, data2, size) == 0);
}
bool String::equals(const char* data1, const char* data2) {
bool StrBuffer::equals(const char* data1, const char* data2) {
if(data1 == data2) return true;
if(data1 == nullptr && data2 == nullptr) return false;
v_int32 size = (v_int32) std::strlen(data1);
return (size == (v_int32) std::strlen(data2) && std::memcmp(data1, data2, size) == 0);
}
bool String::equals(String* str1, String* str2) {
bool StrBuffer::equals(StrBuffer* str1, StrBuffer* str2) {
return (str1 == str2) ||
(str1 != nullptr && str2 != nullptr && str1->m_size == str2->m_size &&
(str1->m_data == str2->m_data || std::memcmp(str1->m_data, str2->m_data, str1->m_size) == 0)
);
}
bool String::equalsCI(const void* data1, const void* data2, v_int32 size) {
bool StrBuffer::equalsCI(const void* data1, const void* data2, v_int32 size) {
for(v_int32 i = 0; i < size; i++) {
v_char8 a = ((p_char8) data1) [i];
v_char8 b = ((p_char8) data2) [i];
@ -222,21 +214,21 @@ bool String::equalsCI(const void* data1, const void* data2, v_int32 size) {
return true;
}
bool String::equalsCI(const char* data1, const char* data2) {
bool StrBuffer::equalsCI(const char* data1, const char* data2) {
if(data1 == data2) return true;
if(data1 == nullptr && data2 == nullptr) return false;
v_int32 size = (v_int32) std::strlen(data1);
return (size == (v_int32) std::strlen(data2) && equalsCI(data1, data2, size) == 0);
}
bool String::equalsCI(String* str1, String* str2) {
bool StrBuffer::equalsCI(StrBuffer* str1, StrBuffer* str2) {
return (str1 == str2) ||
(str1 != nullptr && str2 != nullptr && str1->m_size == str2->m_size &&
(str1->m_data == str2->m_data || equalsCI(str1->m_data, str2->m_data, str1->m_size))
);
}
bool String::equalsCI_FAST(const void* data1, const void* data2, v_int32 size) {
bool StrBuffer::equalsCI_FAST(const void* data1, const void* data2, v_int32 size) {
for(v_int32 i = 0; i < size; i++) {
if((((p_char8) data1) [i] | 32) != (((p_char8) data2) [i] | 32)) {
return false;
@ -245,33 +237,33 @@ bool String::equalsCI_FAST(const void* data1, const void* data2, v_int32 size) {
return true;
}
bool String::equalsCI_FAST(const char* data1, const char* data2) {
bool StrBuffer::equalsCI_FAST(const char* data1, const char* data2) {
if(data1 == data2) return true;
if(data1 == nullptr && data2 == nullptr) return false;
v_int32 size = (v_int32) std::strlen(data1);
return (size == (v_int32) std::strlen(data2) && equalsCI_FAST(data1, data2, size) == 0);
}
bool String::equalsCI_FAST(String* str1, String* str2) {
bool StrBuffer::equalsCI_FAST(StrBuffer* str1, StrBuffer* str2) {
return (str1 == str2) ||
(str1 != nullptr && str2 != nullptr && str1->m_size == str2->m_size &&
(str1->m_data == str2->m_data || equalsCI_FAST(str1->m_data, str2->m_data, str1->m_size))
);
}
bool String::equalsCI_FAST(const String::PtrWrapper& str1, const char* str2) {
bool StrBuffer::equalsCI_FAST(StrBuffer* str1, const char* str2) {
v_int32 len = (v_int32) std::strlen(str2);
return (str1->getSize() == len && equalsCI_FAST(str1->m_data, str2, str1->m_size));
}
void String::lowerCase(const void* data, v_int32 size) {
void StrBuffer::lowerCase(const void* data, v_int32 size) {
for(v_int32 i = 0; i < size; i++) {
v_char8 a = ((p_char8) data)[i];
if(a >= 'A' && a <= 'Z') ((p_char8) data)[i] = a | 32;
}
}
void String::upperCase(const void* data, v_int32 size) {
void StrBuffer::upperCase(const void* data, v_int32 size) {
for(v_int32 i = 0; i < size; i++) {
v_char8 a = ((p_char8) data)[i];
if(a >= 'a' && a <= 'z') ((p_char8) data)[i] = a & 223;
@ -279,25 +271,26 @@ void String::upperCase(const void* data, v_int32 size) {
}
// Operator
oatpp::base::PtrWrapper<String> operator + (const char* a, const oatpp::base::PtrWrapper<String>& b){
return String::createSharedConcatenated(a, (v_int32) std::strlen(a), b->getData(), b->getSize());
/*
oatpp::base::PtrWrapper<StrBuffer> operator + (const char* a, const oatpp::base::PtrWrapper<StrBuffer>& b){
return StrBuffer::createSharedConcatenated(a, (v_int32) std::strlen(a), b->getData(), b->getSize());
}
oatpp::base::PtrWrapper<String> operator + (const oatpp::base::PtrWrapper<String>& b, const char* a){
return String::createSharedConcatenated(b->getData(), b->getSize(), a, (v_int32) std::strlen(a));
oatpp::base::PtrWrapper<StrBuffer> operator + (const oatpp::base::PtrWrapper<StrBuffer>& b, const char* a){
return StrBuffer::createSharedConcatenated(b->getData(), b->getSize(), a, (v_int32) std::strlen(a));
}
oatpp::base::PtrWrapper<String> operator + (const oatpp::base::PtrWrapper<String>& a, const oatpp::base::PtrWrapper<String>& b) {
return String::createSharedConcatenated(a->getData(), a->getSize(), b->getData(), b->getSize());
oatpp::base::PtrWrapper<StrBuffer> operator + (const oatpp::base::PtrWrapper<StrBuffer>& a, const oatpp::base::PtrWrapper<StrBuffer>& b) {
return StrBuffer::createSharedConcatenated(a->getData(), a->getSize(), b->getData(), b->getSize());
}
std::shared_ptr<String> operator + (const char* a, const std::shared_ptr<String>& b){
return String::createSharedConcatenated(a, (v_int32) std::strlen(a), b->getData(), b->getSize());
std::shared_ptr<StrBuffer> operator + (const char* a, const std::shared_ptr<StrBuffer>& b){
return StrBuffer::createSharedConcatenated(a, (v_int32) std::strlen(a), b->getData(), b->getSize());
}
std::shared_ptr<String> operator + (const std::shared_ptr<String>& b, const char* a){
return String::createSharedConcatenated(b->getData(), b->getSize(), a, (v_int32) std::strlen(a));
std::shared_ptr<StrBuffer> operator + (const std::shared_ptr<StrBuffer>& b, const char* a){
return StrBuffer::createSharedConcatenated(b->getData(), b->getSize(), a, (v_int32) std::strlen(a));
}
*/
}}

156
core/base/StrBuffer.hpp Normal file
View File

@ -0,0 +1,156 @@
/***************************************************************************
*
* Project _____ __ ____ _ _
* ( _ ) /__\ (_ _)_| |_ _| |_
* )(_)( /(__)\ )( (_ _)(_ _)
* (_____)(__)(__)(__) |_| |_|
*
*
* Copyright 2018-present, Leonid Stryzhevskyi, <lganzzzo@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
***************************************************************************/
#ifndef oatpp_base_StrBuffer_hpp
#define oatpp_base_StrBuffer_hpp
#include "memory/ObjectPool.hpp"
#include "./Controllable.hpp"
#include "./PtrWrapper.hpp"
#include <cstring> // c
namespace oatpp { namespace base {
class StrBuffer : public oatpp::base::Controllable {
public:
OBJECT_POOL_THREAD_LOCAL(StrBuffer_Pool, StrBuffer, 32)
private:
p_char8 m_data;
v_int32 m_size;
bool m_hasOwnData;
private:
void set(const void* data, v_int32 size, bool hasOwnData);
void setAndCopy(const void* data, const void* originData, v_int32 size);
static std::shared_ptr<StrBuffer> allocShared(const void* data, v_int32 size, bool copyAsOwnData);
/**
* Allocate memory for string or use originData
* if copyAsOwnData == false return originData
*/
static p_char8 allocStrBuffer(const void* originData, v_int32 size, bool copyAsOwnData);
public:
StrBuffer()
: m_data((p_char8)"[<nullptr>]")
, m_size(11)
, m_hasOwnData(false)
{}
StrBuffer(const void* data, v_int32 size, bool copyAsOwnData)
: m_data(allocStrBuffer(data, size, copyAsOwnData))
, m_size(size)
, m_hasOwnData(copyAsOwnData)
{}
public:
virtual ~StrBuffer();
static std::shared_ptr<StrBuffer> createShared(v_int32 size);
static std::shared_ptr<StrBuffer> createShared(const void* data, v_int32 size, bool copyAsOwnData = true);
static std::shared_ptr<StrBuffer> createShared(const char* data, bool copyAsOwnData = true);
static std::shared_ptr<StrBuffer> createShared(StrBuffer* other, bool copyAsOwnData = true);
static std::shared_ptr<StrBuffer> createSharedConcatenated(const void* data1, v_int32 size1, const void* data2, v_int32 size2);
static std::shared_ptr<StrBuffer> createFromCString(const char* data, bool copyAsOwnData = true) {
if(data != nullptr) {
return allocShared(data, (v_int32) std::strlen(data), copyAsOwnData);
}
return nullptr;
}
p_char8 getData() const;
v_int32 getSize() const;
const char* c_str() const;
std::string std_str() const;
bool hasOwnData() const;
/**
* (correct for ACII only)
*/
std::shared_ptr<StrBuffer> toLowerCase() const;
/**
* (correct for ACII only)
*/
std::shared_ptr<StrBuffer> toUpperCase() const;
bool equals(const void* data, v_int32 size) const;
bool equals(const char* data) const;
bool equals(StrBuffer* other) const;
bool startsWith(const void* data, v_int32 size) const;
bool startsWith(const char* data) const;
bool startsWith(StrBuffer* data) const;
public:
static v_int32 compare(const void* data1, const void* data2, v_int32 size);
static v_int32 compare(StrBuffer* str1, StrBuffer* str2);
static bool equals(const void* data1, const void* data2, v_int32 size);
static bool equals(const char* data1, const char* data2);
static bool equals(StrBuffer* str1, StrBuffer* str2);
// Case Insensitive (correct for ASCII only)
static bool equalsCI(const void* data1, const void* data2, v_int32 size);
static bool equalsCI(const char* data1, const char* data2);
static bool equalsCI(StrBuffer* str1, StrBuffer* str2);
// Case Insensitive Fast (ASCII only, correct compare if one of strings contains letters only)
static bool equalsCI_FAST(const void* data1, const void* data2, v_int32 size);
static bool equalsCI_FAST(const char* data1, const char* data2);
static bool equalsCI_FAST(StrBuffer* str1, StrBuffer* str2);
static bool equalsCI_FAST(StrBuffer* str1, const char* str2);
/**
* lower case chars in the buffer @data (correct for ACII only)
*/
static void lowerCase(const void* data, v_int32 size);
/**
* upper case chars in the buffer @data (correct for ACII only)
*/
static void upperCase(const void* data, v_int32 size);
};
/*
oatpp::base::PtrWrapper<StrBuffer> operator + (const char* a, const oatpp::base::PtrWrapper<StrBuffer>& b);
oatpp::base::PtrWrapper<StrBuffer> operator + (const oatpp::base::PtrWrapper<StrBuffer>& b, const char* a);
oatpp::base::PtrWrapper<StrBuffer> operator + (const oatpp::base::PtrWrapper<StrBuffer>& a, const oatpp::base::PtrWrapper<StrBuffer>& b);
std::shared_ptr<StrBuffer> operator + (const char* a, const std::shared_ptr<StrBuffer>& b);
std::shared_ptr<StrBuffer> operator + (const std::shared_ptr<StrBuffer>& b, const char* a);
*/
}}
#endif /* oatpp_base_StrBuffer_hpp */

213
core/base/String.hpp
View File

@ -1,213 +0,0 @@
/***************************************************************************
*
* Project _____ __ ____ _ _
* ( _ ) /__\ (_ _)_| |_ _| |_
* )(_)( /(__)\ )( (_ _)(_ _)
* (_____)(__)(__)(__) |_| |_|
*
*
* Copyright 2018-present, Leonid Stryzhevskyi, <lganzzzo@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
***************************************************************************/
#ifndef oatpp_base_String_hpp
#define oatpp_base_String_hpp
#include "memory/ObjectPool.hpp"
#include "./Controllable.hpp"
#include "./PtrWrapper.hpp"
#include <cstring> // c
namespace oatpp { namespace base {
class String : public oatpp::base::Controllable {
public:
class PtrWrapper : public oatpp::base::PtrWrapper<String> {
public:
PtrWrapper() {}
PtrWrapper(const std::shared_ptr<String>& ptr)
: oatpp::base::PtrWrapper<String>(ptr)
{}
PtrWrapper(std::shared_ptr<String>&& ptr)
: oatpp::base::PtrWrapper<String>(std::move(ptr))
{}
PtrWrapper(const char* str)
: oatpp::base::PtrWrapper<String>(createFromCString(str))
{}
PtrWrapper(const oatpp::base::PtrWrapper<String>& other)
: oatpp::base::PtrWrapper<String>(other)
{}
PtrWrapper(oatpp::base::PtrWrapper<String>&& other)
: oatpp::base::PtrWrapper<String>(std::move(other))
{}
PtrWrapper& operator = (const char* str) {
m_ptr = String::createFromCString(str);
return *this;
}
PtrWrapper& operator = (const oatpp::base::PtrWrapper<String>& other){
oatpp::base::PtrWrapper<String>::operator=(other);
return *this;
}
PtrWrapper& operator = (oatpp::base::PtrWrapper<String>&& other){
oatpp::base::PtrWrapper<String>::operator=(std::move(other));
return *this;
}
PtrWrapper operator + (const char* str) const{
return String::createSharedConcatenated(m_ptr.get()->m_data, m_ptr.get()->m_size, str, (v_int32) std::strlen(str));
}
PtrWrapper operator + (const oatpp::base::PtrWrapper<String>& other) const{
return String::createSharedConcatenated(m_ptr.get()->m_data, m_ptr.get()->m_size, other.get()->m_data, other.get()->m_size);
}
static const PtrWrapper& empty(){
static PtrWrapper empty;
return empty;
}
};
public:
OBJECT_POOL_THREAD_LOCAL(String_Pool, String, 32)
private:
p_char8 m_data;
v_int32 m_size;
bool m_hasOwnData;
private:
void set(const void* data, v_int32 size, bool hasOwnData);
void setAndCopy(const void* data, const void* originData, v_int32 size);
static std::shared_ptr<String> allocShared(const void* data, v_int32 size, bool copyAsOwnData);
/**
* Allocate memory for string or use originData
* if copyAsOwnData == false return originData
*/
static p_char8 allocString(const void* originData, v_int32 size, bool copyAsOwnData);
public:
String()
: m_data((p_char8)"[<nullptr>]")
, m_size(11)
, m_hasOwnData(false)
{}
String(const void* data, v_int32 size, bool copyAsOwnData)
: m_data(allocString(data, size, copyAsOwnData))
, m_size(size)
, m_hasOwnData(copyAsOwnData)
{}
public:
virtual ~String();
static std::shared_ptr<String> createShared(v_int32 size);
static std::shared_ptr<String> createShared(const void* data, v_int32 size, bool copyAsOwnData = true);
static std::shared_ptr<String> createShared(const char* data, bool copyAsOwnData = true);
static std::shared_ptr<String> createShared(String* other, bool copyAsOwnData = true);
static std::shared_ptr<String> createSharedConcatenated(const void* data1, v_int32 size1, const void* data2, v_int32 size2);
static std::shared_ptr<String> createFromCString(const char* data, bool copyAsOwnData = true) {
if(data != nullptr) {
return allocShared(data, (v_int32) std::strlen(data), copyAsOwnData);
}
return nullptr;
}
p_char8 getData() const;
v_int32 getSize() const;
const char* c_str() const;
std::string std_str() const;
bool hasOwnData() const;
/**
* (correct for ACII only)
*/
std::shared_ptr<String> toLowerCase() const;
/**
* (correct for ACII only)
*/
std::shared_ptr<String> toUpperCase() const;
bool equals(const void* data, v_int32 size) const;
bool equals(const char* data) const;
bool equals(String* other) const;
bool equals(const String::PtrWrapper& other) const;
bool equals(const std::shared_ptr<String>& other) const;
bool startsWith(const void* data, v_int32 size) const;
bool startsWith(const char* data) const;
bool startsWith(String* data) const;
public:
static v_int32 compare(const void* data1, const void* data2, v_int32 size);
static v_int32 compare(String* str1, String* str2);
static bool equals(const void* data1, const void* data2, v_int32 size);
static bool equals(const char* data1, const char* data2);
static bool equals(String* str1, String* str2);
// Case Insensitive (correct for ASCII only)
static bool equalsCI(const void* data1, const void* data2, v_int32 size);
static bool equalsCI(const char* data1, const char* data2);
static bool equalsCI(String* str1, String* str2);
// Case Insensitive Fast (ASCII only, correct compare if one of strings contains letters only)
static bool equalsCI_FAST(const void* data1, const void* data2, v_int32 size);
static bool equalsCI_FAST(const char* data1, const char* data2);
static bool equalsCI_FAST(String* str1, String* str2);
static bool equalsCI_FAST(const String::PtrWrapper& str1, const char* str2);
/**
* lower case chars in the buffer @data (correct for ACII only)
*/
static void lowerCase(const void* data, v_int32 size);
/**
* upper case chars in the buffer @data (correct for ACII only)
*/
static void upperCase(const void* data, v_int32 size);
};
oatpp::base::PtrWrapper<String> operator + (const char* a, const oatpp::base::PtrWrapper<String>& b);
oatpp::base::PtrWrapper<String> operator + (const oatpp::base::PtrWrapper<String>& b, const char* a);
oatpp::base::PtrWrapper<String> operator + (const oatpp::base::PtrWrapper<String>& a, const oatpp::base::PtrWrapper<String>& b);
std::shared_ptr<String> operator + (const char* a, const std::shared_ptr<String>& b);
std::shared_ptr<String> operator + (const std::shared_ptr<String>& b, const char* a);
}}
#endif /* oatpp_base_String_hpp */

2
core/collection/ListMap.hpp
View File

@ -123,7 +123,7 @@ private:
Entry* curr = m_first;
while(curr != nullptr){
if(key->equals(curr->key)){
if(key.equals(curr->key)){
return curr;
}
curr = curr->next;

4
core/data/mapping/ObjectMapper.hpp
View File

@ -63,7 +63,7 @@ public:
virtual type::AbstractPtrWrapper read(const std::shared_ptr<oatpp::parser::ParsingCaret>& caret,
const type::Type* const type) const = 0;
std::shared_ptr<oatpp::base::String> writeToString(const type::AbstractPtrWrapper& variant) const {
oatpp::String writeToString(const type::AbstractPtrWrapper& variant) const {
auto stream = stream::ChunkedBuffer::createShared();
write(stream, variant);
return stream->toString();
@ -76,7 +76,7 @@ public:
}
template<class Class>
typename Class::PtrWrapper readFromString(const oatpp::base::String::PtrWrapper& str) const {
typename Class::PtrWrapper readFromString(const oatpp::String& str) const {
auto type = Class::PtrWrapper::Class::getType();
auto caret = oatpp::parser::ParsingCaret::createShared(str.getPtr());
return oatpp::base::static_wrapper_cast<typename Class::PtrWrapper::ObjectType>(read(caret, type));

2
core/data/mapping/type/List.hpp
View File

@ -31,7 +31,7 @@
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {

4
core/data/mapping/type/Object.hpp
View File

@ -32,7 +32,7 @@
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {
@ -59,7 +59,7 @@ namespace __class {
class Object : public oatpp::base::Controllable {
public:
typedef oatpp::data::mapping::type::StringPtrWrapper String;
typedef oatpp::String String;
typedef oatpp::data::mapping::type::Int32::PtrWrapper Int32;
typedef oatpp::data::mapping::type::Int64::PtrWrapper Int64;
typedef oatpp::data::mapping::type::Float32::PtrWrapper Float32;

23
core/data/mapping/type/Primitive.cpp
View File

@ -24,42 +24,37 @@
#include "./Primitive.hpp"
#include "oatpp/core/utils/ConversionUtils.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {
StringPtrWrapper::StringPtrWrapper(const std::shared_ptr<oatpp::base::String>& ptr, const type::Type* const valueType)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::String, __class::String>(ptr)
String::String(const std::shared_ptr<oatpp::base::StrBuffer>& ptr, const type::Type* const valueType)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(ptr)
{
if(type::__class::String::getType() != valueType) {
throw std::runtime_error("Value type does not match");
}
}
StringPtrWrapper::operator std::string() const {
if(m_ptr){
return m_ptr->std_str();
}
return "";
}
namespace __class {
type::Int32::PtrWrapper Int32::parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success) {
type::Int32::PtrWrapper Int32::parseFromString(const oatpp::String& str, bool& success) {
return utils::conversion::strToInt32(str, success);
}
type::Int64::PtrWrapper Int64::parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success) {
type::Int64::PtrWrapper Int64::parseFromString(const oatpp::String& str, bool& success) {
return utils::conversion::strToInt64(str, success);
}
type::Float32::PtrWrapper Float32::parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success) {
type::Float32::PtrWrapper Float32::parseFromString(const oatpp::String& str, bool& success) {
return utils::conversion::strToFloat32(str, success);
}
type::Float64::PtrWrapper Float64::parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success) {
type::Float64::PtrWrapper Float64::parseFromString(const oatpp::String& str, bool& success) {
return utils::conversion::strToFloat64(str, success);
}
type::Boolean::PtrWrapper Boolean::parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success) {
type::Boolean::PtrWrapper Boolean::parseFromString(const oatpp::String& str, bool& success) {
return utils::conversion::strToBool(str, success);
}

116
core/data/mapping/type/Primitive.hpp
View File

@ -27,11 +27,9 @@
#include "./Type.hpp"
#include "oatpp/core/utils/ConversionUtils.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/base/StrBuffer.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
@ -47,74 +45,82 @@ namespace __class {
class Boolean; // FWD
}
class StringPtrWrapper : public oatpp::data::mapping::type::PtrWrapper<oatpp::base::String, __class::String> {
class String : public oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String> {
public:
StringPtrWrapper(const std::shared_ptr<oatpp::base::String>& ptr, const type::Type* const valueType);
String(const std::shared_ptr<oatpp::base::StrBuffer>& ptr, const type::Type* const valueType);
public:
StringPtrWrapper() {}
String() {}
StringPtrWrapper(const std::shared_ptr<oatpp::base::String>& ptr)
: type::PtrWrapper<oatpp::base::String, __class::String>(ptr)
String(v_int32 size)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(oatpp::base::StrBuffer::createShared(size))
{}
StringPtrWrapper(std::shared_ptr<oatpp::base::String>&& ptr)
: type::PtrWrapper<oatpp::base::String, __class::String>(std::move(ptr))
String(const void* data, v_int32 size, bool copyAsOwnData = true)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(oatpp::base::StrBuffer::createShared(data, size, copyAsOwnData))
{}
StringPtrWrapper(const char* str)
: type::PtrWrapper<oatpp::base::String, __class::String>(oatpp::base::String::createFromCString(str))
String(const void* data1, v_int32 size1, const void* data2, v_int32 size2)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(oatpp::base::StrBuffer::createSharedConcatenated(data1, size1, data2, size2))
{}
StringPtrWrapper(const std::string& str)
: type::PtrWrapper<oatpp::base::String, __class::String>
(oatpp::base::String::createShared(str.data(), str.size()))
String(const char* data, bool copyAsOwnData = true)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(oatpp::base::StrBuffer::createFromCString(data, copyAsOwnData))
{}
StringPtrWrapper(const oatpp::base::PtrWrapper<oatpp::base::String>& other)
: type::PtrWrapper<oatpp::base::String, __class::String>(other)
String(const std::shared_ptr<oatpp::base::StrBuffer>& ptr)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(ptr)
{}
StringPtrWrapper(oatpp::base::PtrWrapper<oatpp::base::String>&& other)
: type::PtrWrapper<oatpp::base::String, __class::String>(std::move(other))
String(std::shared_ptr<oatpp::base::StrBuffer>&& ptr)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(std::move(ptr))
{}
StringPtrWrapper& operator = (const char* str) {
m_ptr = oatpp::base::String::createFromCString(str);
String(const String& other)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(other)
{}
String(String&& other)
: oatpp::data::mapping::type::PtrWrapper<oatpp::base::StrBuffer, __class::String>(std::move(other))
{}
String& operator = (const char* str) {
m_ptr = oatpp::base::StrBuffer::createFromCString(str);
return *this;
}
StringPtrWrapper& operator = (const std::string& str) {
m_ptr = oatpp::base::String::createShared(str.data(), str.size());
String& operator = (const String& other){
oatpp::base::PtrWrapper<oatpp::base::StrBuffer>::operator=(other);
return *this;
}
StringPtrWrapper& operator = (const oatpp::base::PtrWrapper<oatpp::base::String>& other){
oatpp::base::PtrWrapper<oatpp::base::String>::operator=(other);
String& operator = (String&& other){
oatpp::base::PtrWrapper<oatpp::base::StrBuffer>::operator=(std::move(other));
return *this;
}
StringPtrWrapper& operator = (oatpp::base::PtrWrapper<oatpp::base::String>&& other){
oatpp::base::PtrWrapper<oatpp::base::String>::operator=(std::move(other));
return *this;
String operator + (const char* str) const{
return oatpp::base::StrBuffer::createSharedConcatenated(m_ptr.get()->getData(), m_ptr.get()->getSize(), str, (v_int32) std::strlen(str));
}
StringPtrWrapper operator + (const char* str) const{
return oatpp::base::String::createSharedConcatenated(m_ptr.get()->getData(), m_ptr.get()->getSize(), str, (v_int32) std::strlen(str));
String operator + (const String& other) const{
return oatpp::base::StrBuffer::createSharedConcatenated(m_ptr.get()->getData(), m_ptr.get()->getSize(), other.get()->getData(), other.get()->getSize());
}
StringPtrWrapper operator + (const oatpp::base::PtrWrapper<oatpp::base::String>& other) const{
return oatpp::base::String::createSharedConcatenated(m_ptr.get()->getData(), m_ptr.get()->getSize(), other.get()->getData(), other.get()->getSize());
}
operator std::string() const;
static const StringPtrWrapper& empty(){
static StringPtrWrapper empty;
static const String& empty(){
static String empty;
return empty;
}
bool equals(const String& other) const {
return m_ptr->equals(other.get());
}
explicit operator bool() const {
return m_ptr.operator bool();
}
};
template<typename ValueType, class Clazz>
@ -225,7 +231,7 @@ namespace __class {
return &type;
}
static type::StringPtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success){
static oatpp::data::mapping::type::String parseFromString(const oatpp::data::mapping::type::String& str, bool& success){
success = true;
return str;
}
@ -241,7 +247,7 @@ namespace __class {
return &type;
}
static type::Int32::PtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success);
static type::Int32::PtrWrapper parseFromString(const oatpp::data::mapping::type::String& str, bool& success);
};
@ -254,7 +260,7 @@ namespace __class {
return &type;
}
static type::Int64::PtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success);
static type::Int64::PtrWrapper parseFromString(const oatpp::data::mapping::type::String& str, bool& success);
};
@ -267,7 +273,7 @@ namespace __class {
return &type;
}
static type::Float32::PtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success);
static type::Float32::PtrWrapper parseFromString(const oatpp::data::mapping::type::String& str, bool& success);
};
@ -280,7 +286,7 @@ namespace __class {
return &type;
}
static type::Float64::PtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success);
static type::Float64::PtrWrapper parseFromString(const oatpp::data::mapping::type::String& str, bool& success);
};
@ -293,32 +299,12 @@ namespace __class {
return &type;
}
static type::Boolean::PtrWrapper parseFromString(const oatpp::base::String::PtrWrapper& str, bool& success);
static type::Boolean::PtrWrapper parseFromString(const oatpp::data::mapping::type::String& str, bool& success);
};
}
template<class T>
base::PtrWrapper<base::String>
primitiveToStr(const oatpp::data::mapping::type::PolymorphicWrapper<T>& primitive) {
auto type = primitive.valueType;
if(type == oatpp::data::mapping::type::__class::String::getType()) {
return std::static_pointer_cast<base::String>(primitive.getPtr());
} else if(type == oatpp::data::mapping::type::__class::Int32::getType()) {
return utils::conversion::int32ToStr(static_cast<oatpp::data::mapping::type::Int32*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Int64::getType()) {
return utils::conversion::int64ToStr(static_cast<oatpp::data::mapping::type::Int64*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Float32::getType()) {
return utils::conversion::float32ToStr(static_cast<oatpp::data::mapping::type::Float32*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Float64::getType()) {
return utils::conversion::float64ToStr(static_cast<oatpp::data::mapping::type::Float64*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Boolean::getType()) {
return utils::conversion::boolToStr(static_cast<oatpp::data::mapping::type::Boolean*>(primitive.get())->getValue());
}
throw std::runtime_error("[oatpp::data::mapping::type::primitiveToStr]: Invalid primitive type");
}
}}}}
#endif /* oatpp_base_controllable_PrimitiveDataTypes_hpp */

4
core/data/stream/ChunkedBuffer.cpp
View File

@ -181,9 +181,9 @@ os::io::Library::v_size ChunkedBuffer::readSubstring(void *buffer,
}
std::shared_ptr<oatpp::base::String> ChunkedBuffer::getSubstring(os::io::Library::v_size pos,
oatpp::String ChunkedBuffer::getSubstring(os::io::Library::v_size pos,
os::io::Library::v_size count){
auto str = oatpp::base::String::createShared((v_int32) count);
auto str = oatpp::String((v_int32) count);
readSubstring(str->getData(), pos, count);
return str;
}

4
core/data/stream/ChunkedBuffer.hpp
View File

@ -149,10 +149,10 @@ public:
os::io::Library::v_size pos,
os::io::Library::v_size count);
std::shared_ptr<oatpp::base::String> getSubstring(os::io::Library::v_size pos,
oatpp::String getSubstring(os::io::Library::v_size pos,
os::io::Library::v_size count);
std::shared_ptr<oatpp::base::String> toString() {
oatpp::String toString() {
return getSubstring(0, m_size);
}

2
core/data/stream/Stream.cpp
View File

@ -137,7 +137,7 @@ oatpp::async::Action IOStream::readExactSizeDataAsyncInline(oatpp::data::stream:
// Functions
const std::shared_ptr<OutputStream>& operator <<
(const std::shared_ptr<OutputStream>& s, const base::String::PtrWrapper& str) {
(const std::shared_ptr<OutputStream>& s, const oatpp::String& str) {
s->write(str);
return s;
}

6
core/data/stream/Stream.hpp
View File

@ -27,7 +27,7 @@
#include "oatpp/core/data/buffer/IOBuffer.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/async/Coroutine.hpp"
@ -45,7 +45,7 @@ public:
return write((p_char8)data, std::strlen(data));
}
os::io::Library::v_size write(const oatpp::base::PtrWrapper<oatpp::base::String>& str){
os::io::Library::v_size write(const oatpp::String& str){
return write(str->getData(), str->getSize());
}
@ -131,7 +131,7 @@ public:
};
const std::shared_ptr<OutputStream>& operator <<
(const std::shared_ptr<OutputStream>& s, const base::String::PtrWrapper& str);
(const std::shared_ptr<OutputStream>& s, const oatpp::String& str);
const std::shared_ptr<OutputStream>& operator <<
(const std::shared_ptr<OutputStream>& s, const char* str);

18
core/parser/ParsingCaret.cpp
View File

@ -50,7 +50,7 @@ namespace oatpp { namespace parser {
, m_error(nullptr)
{}
ParsingCaret::ParsingCaret(const std::shared_ptr<base::String>& str)
ParsingCaret::ParsingCaret(const oatpp::String& str)
: m_data(str->getData())
, m_size(str->getSize())
, m_pos(0)
@ -65,7 +65,7 @@ namespace oatpp { namespace parser {
return std::shared_ptr<ParsingCaret>(new ParsingCaret(parseData, dataSize));
}
std::shared_ptr<ParsingCaret> ParsingCaret::createShared(const std::shared_ptr<base::String>& str){
std::shared_ptr<ParsingCaret> ParsingCaret::createShared(const oatpp::String& str){
return std::shared_ptr<ParsingCaret>(new ParsingCaret(str->getData(), str->getSize()));
}
@ -277,7 +277,7 @@ namespace oatpp { namespace parser {
if(len > 0){
auto str = base::String::createShared(&m_data[ipos], len, true);
auto str = oatpp::String(&m_data[ipos], len, true);
v_int32 result = atoi((const char*)str->getData());
if(negative){
@ -442,7 +442,7 @@ namespace oatpp { namespace parser {
}
std::shared_ptr<base::String> ParsingCaret::parseStringEnclosed(char openChar, char closeChar, char escapeChar, bool saveAsOwnData){
oatpp::String ParsingCaret::parseStringEnclosed(char openChar, char closeChar, char escapeChar, bool saveAsOwnData){
if(m_data[m_pos] == openChar){
@ -455,7 +455,7 @@ namespace oatpp { namespace parser {
if(m_data[m_pos] == escapeChar){
m_pos++;
}else if(m_data[m_pos] == closeChar){
std::shared_ptr<base::String> result = base::String::createShared(&m_data[ipos], m_pos - ipos, saveAsOwnData);
oatpp::String result = oatpp::String(&m_data[ipos], m_pos - ipos, saveAsOwnData);
m_pos++;
return result;
}
@ -473,7 +473,7 @@ namespace oatpp { namespace parser {
}
std::shared_ptr<base::String> ParsingCaret::parseName(bool saveAsOwnData){
oatpp::String ParsingCaret::parseName(bool saveAsOwnData){
v_int32 ipos = m_pos;
while(m_pos < m_size){
@ -488,7 +488,7 @@ namespace oatpp { namespace parser {
}else{
if(ipos < m_pos){
return base::String::createShared(&m_data[ipos], m_pos - ipos, saveAsOwnData);
return oatpp::String(&m_data[ipos], m_pos - ipos, saveAsOwnData);
}else{
m_error = ERROR_NAME_EXPECTED;
return nullptr;
@ -499,7 +499,7 @@ namespace oatpp { namespace parser {
}
if(ipos < m_pos){
return base::String::createShared(&m_data[ipos], m_pos - ipos, saveAsOwnData);
return oatpp::String(&m_data[ipos], m_pos - ipos, saveAsOwnData);
}else{
m_error = ERROR_NAME_EXPECTED;
return nullptr;
@ -507,7 +507,7 @@ namespace oatpp { namespace parser {
}
std::shared_ptr<oatpp::base::String> ParsingCaret::findTextFromList(const std::shared_ptr<oatpp::collection::LinkedList<std::shared_ptr<oatpp::base::String>>>& list){
oatpp::String ParsingCaret::findTextFromList(const std::shared_ptr<oatpp::collection::LinkedList<oatpp::String>>& list){
while(m_pos < m_size){

18
core/parser/ParsingCaret.hpp
View File

@ -26,7 +26,7 @@
#define oatpp_parser_ParsingCaret_hpp
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace parser {
@ -64,15 +64,15 @@ public:
return m_end - m_start;
}
std::shared_ptr<oatpp::base::String> toString(bool saveAsOwnData){
oatpp::String toString(bool saveAsOwnData){
v_int32 end = m_end;
if(end == -1){
end = m_caret.m_pos;
}
return oatpp::base::String::createShared(&m_caret.m_data[m_start], end - m_start, saveAsOwnData);
return oatpp::String(&m_caret.m_data[m_start], end - m_start, saveAsOwnData);
}
std::shared_ptr<oatpp::base::String> toString(){
oatpp::String toString(){
return toString(true);
}
@ -93,12 +93,12 @@ private:
public:
ParsingCaret(const char* text);
ParsingCaret(p_char8 parseData, v_int32 dataSize);
ParsingCaret(const std::shared_ptr<base::String>& str);
ParsingCaret(const oatpp::String& str);
public:
static std::shared_ptr<ParsingCaret> createShared(const char* text);
static std::shared_ptr<ParsingCaret> createShared(p_char8 parseData, v_int32 dataSize);
static std::shared_ptr<ParsingCaret> createShared(const std::shared_ptr<base::String>& str);
static std::shared_ptr<ParsingCaret> createShared(const oatpp::String& str);
virtual ~ParsingCaret();
@ -153,10 +153,10 @@ public:
bool proceedIfFollowsWord(const char* text); // not increases pos if false
bool proceedIfFollowsWord(p_char8 text, v_int32 textSize); // not increases pos if false
std::shared_ptr<base::String> parseStringEnclosed(char openChar, char closeChar, char escapeChar, bool saveAsOwnData);
std::shared_ptr<base::String> parseName(bool saveAsOwnData);
oatpp::String parseStringEnclosed(char openChar, char closeChar, char escapeChar, bool saveAsOwnData);
oatpp::String parseName(bool saveAsOwnData);
std::shared_ptr<base::String> findTextFromList(const std::shared_ptr<oatpp::collection::LinkedList<std::shared_ptr<base::String>>>& list);
oatpp::String findTextFromList(const std::shared_ptr<oatpp::collection::LinkedList<oatpp::String>>& list);
bool notAtCharFromSet(const char* set) const;
bool notAtCharFromSet(p_char8 set, v_int32 setSize) const;

40
core/utils/ConversionUtils.cpp
View File

@ -33,7 +33,7 @@ namespace oatpp { namespace utils { namespace conversion {
return (v_int32) std::strtol(str, &end, 10);
}
v_int32 strToInt32(const base::PtrWrapper<base::String>& str, bool& success){
v_int32 strToInt32(const oatpp::String& str, bool& success){
char* end;
v_int32 result = (v_int32) std::strtol((const char*)str->getData(), &end, 10);
success = (((v_int64)end - (v_int64)str->getData()) == str->getSize());
@ -45,7 +45,7 @@ namespace oatpp { namespace utils { namespace conversion {
return std::strtoll(str, &end, 10);
}
v_int64 strToInt64(const base::PtrWrapper<base::String>& str, bool& success){
v_int64 strToInt64(const oatpp::String& str, bool& success){
char* end;
v_int64 result = std::strtoll((const char*)str->getData(), &end, 10);
success = (((v_int64)end - (v_int64)str->getData()) == str->getSize());
@ -60,22 +60,22 @@ namespace oatpp { namespace utils { namespace conversion {
return sprintf((char*)data, "%lld", value);
}
base::PtrWrapper<base::String> int32ToStr(v_int32 value){
oatpp::String int32ToStr(v_int32 value){
v_char8 buff [100];
v_int32 size = int32ToCharSequence(value, &buff[0]);
if(size > 0){
return base::String::createShared(&buff[0], size, true);
return oatpp::String(&buff[0], size, true);
}
return base::PtrWrapper<base::String>::empty();
return oatpp::String::empty();
}
base::PtrWrapper<base::String> int64ToStr(v_int64 value){
oatpp::String int64ToStr(v_int64 value){
v_char8 buff [100];
v_int32 size = int64ToCharSequence(value, &buff[0]);
if(size > 0){
return base::String::createShared(&buff[0], size, true);
return oatpp::String(&buff[0], size, true);
}
return base::PtrWrapper<base::String>::empty();
return oatpp::String::empty();
}
std::string int32ToStdStr(v_int32 value){
@ -101,7 +101,7 @@ namespace oatpp { namespace utils { namespace conversion {
return std::strtof(str, &end);
}
v_float32 strToFloat32(const base::PtrWrapper<base::String>& str, bool& success) {
v_float32 strToFloat32(const oatpp::String& str, bool& success) {
char* end;
v_float32 result = std::strtof((const char*)str->getData(), &end);
success = (((v_int64)end - (v_int64)str->getData()) == str->getSize());
@ -113,7 +113,7 @@ namespace oatpp { namespace utils { namespace conversion {
return std::strtod(str, &end);
}
v_float64 strToFloat64(const base::PtrWrapper<base::String>& str, bool& success) {
v_float64 strToFloat64(const oatpp::String& str, bool& success) {
char* end;
v_float64 result = std::strtod((const char*)str->getData(), &end);
success = (((v_int64)end - (v_int64)str->getData()) == str->getSize());
@ -128,33 +128,33 @@ namespace oatpp { namespace utils { namespace conversion {
return sprintf((char*)data, "%f", value);
}
base::PtrWrapper<base::String> float32ToStr(v_float32 value){
oatpp::String float32ToStr(v_float32 value){
v_char8 buff [100];
v_int32 size = float32ToCharSequence(value, &buff[0]);
if(size > 0){
return base::String::createShared(&buff[0], size, true);
return oatpp::String(&buff[0], size, true);
}
return base::PtrWrapper<base::String>::empty();
return oatpp::String::empty();
}
base::PtrWrapper<base::String> float64ToStr(v_float64 value){
oatpp::String float64ToStr(v_float64 value){
v_char8 buff [100];
v_int32 size = float32ToCharSequence(value, &buff[0]);
if(size > 0){
return base::String::createShared(&buff[0], size, true);
return oatpp::String(&buff[0], size, true);
}
return base::PtrWrapper<base::String>::empty();
return oatpp::String::empty();
}
base::PtrWrapper<base::String> boolToStr(bool value) {
oatpp::String boolToStr(bool value) {
if(value){
return base::String::createShared((p_char8)"true", 4, false);
return oatpp::String((p_char8)"true", 4, false);
} else {
return base::String::createShared((p_char8)"false", 5, false);
return oatpp::String((p_char8)"false", 5, false);
}
}
bool strToBool(const base::PtrWrapper<base::String>& str, bool& success) {
bool strToBool(const oatpp::String& str, bool& success) {
if(str->equals((p_char8)"true", 4)){
success = true;
return true;

48
core/utils/ConversionUtils.hpp
View File

@ -25,7 +25,8 @@
#ifndef oatpp_utils_ConversionUtils_hpp
#define oatpp_utils_ConversionUtils_hpp
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/data/mapping/type/Primitive.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
#include "oatpp/core/base/Controllable.hpp"
@ -36,15 +37,15 @@
namespace oatpp { namespace utils { namespace conversion {
v_int32 strToInt32(const char* str);
v_int32 strToInt32(const base::PtrWrapper<base::String>& str, bool& success);
v_int32 strToInt32(const oatpp::String& str, bool& success);
v_int64 strToInt64(const char* str);
v_int64 strToInt64(const base::PtrWrapper<base::String>& str, bool& success);
v_int64 strToInt64(const oatpp::String& str, bool& success);
v_int32 int32ToCharSequence(v_int32 value, p_char8 data);
v_int32 int64ToCharSequence(v_int64 value, p_char8 data);
base::PtrWrapper<base::String> int32ToStr(v_int32 value);
base::PtrWrapper<base::String> int64ToStr(v_int64 value);
oatpp::String int32ToStr(v_int32 value);
oatpp::String int64ToStr(v_int64 value);
std::string int32ToStdStr(v_int32 value);
std::string int64ToStdStr(v_int64 value);
@ -55,29 +56,48 @@ namespace oatpp { namespace utils { namespace conversion {
}
template<typename T>
base::PtrWrapper<base::String> primitiveToStr(T value, const char* pattern){
oatpp::String primitiveToStr(T value, const char* pattern){
v_char8 buff [100];
v_int32 size = primitiveToCharSequence(value, &buff[0], pattern);
if(size > 0){
return base::String::createShared(&buff[0], size, true);
return oatpp::String(&buff[0], size, true);
}
return base::PtrWrapper<base::String>::empty();
return oatpp::String::empty();
}
v_float32 strToFloat32(const char* str);
v_float32 strToFloat32(const base::PtrWrapper<base::String>& str, bool& success);
v_float32 strToFloat32(const oatpp::String& str, bool& success);
v_float64 strToFloat64(const char* str);
v_float64 strToFloat64(const base::PtrWrapper<base::String>& str, bool& success);
v_float64 strToFloat64(const oatpp::String& str, bool& success);
v_int32 float32ToCharSequence(v_float32 value, p_char8 data);
v_int32 float64ToCharSequence(v_float64 value, p_char8 data);
base::PtrWrapper<base::String> float32ToStr(v_float32 value);
base::PtrWrapper<base::String> float64ToStr(v_float64 value);
oatpp::String float32ToStr(v_float32 value);
oatpp::String float64ToStr(v_float64 value);
base::PtrWrapper<base::String> boolToStr(bool value);
bool strToBool(const base::PtrWrapper<base::String>& str, bool& success);
oatpp::String boolToStr(bool value);
bool strToBool(const oatpp::String& str, bool& success);
template<class T>
oatpp::String
primitiveToStr(const oatpp::data::mapping::type::PolymorphicWrapper<T>& primitive) {
auto type = primitive.valueType;
if(type == oatpp::data::mapping::type::__class::String::getType()) {
return std::static_pointer_cast<oatpp::base::StrBuffer>(primitive.getPtr());
} else if(type == oatpp::data::mapping::type::__class::Int32::getType()) {
return utils::conversion::int32ToStr(static_cast<oatpp::data::mapping::type::Int32*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Int64::getType()) {
return utils::conversion::int64ToStr(static_cast<oatpp::data::mapping::type::Int64*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Float32::getType()) {
return utils::conversion::float32ToStr(static_cast<oatpp::data::mapping::type::Float32*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Float64::getType()) {
return utils::conversion::float64ToStr(static_cast<oatpp::data::mapping::type::Float64*>(primitive.get())->getValue());
} else if(type == oatpp::data::mapping::type::__class::Boolean::getType()) {
return utils::conversion::boolToStr(static_cast<oatpp::data::mapping::type::Boolean*>(primitive.get())->getValue());
}
throw std::runtime_error("[oatpp::utils::conversion::primitiveToStr]: Invalid primitive type");
}
}}}

6
network/ConnectionProvider.hpp
View File

@ -59,16 +59,16 @@ public:
class ClientConnectionProvider : public ConnectionProvider {
protected:
oatpp::base::String::PtrWrapper m_host;
oatpp::String m_host;
v_word16 m_port;
public:
ClientConnectionProvider(const oatpp::base::String::PtrWrapper& host, v_word16 port)
ClientConnectionProvider(const oatpp::String& host, v_word16 port)
: m_host(host)
, m_port(port)
{}
oatpp::base::String::PtrWrapper getHost() {
oatpp::String getHost() {
return m_host;
}

4
network/client/SimpleTCPConnectionProvider.cpp
View File

@ -81,13 +81,13 @@ oatpp::async::Action SimpleTCPConnectionProvider::getConnectionAsync(oatpp::asyn
class ConnectCoroutine : public oatpp::async::CoroutineWithResult<ConnectCoroutine, std::shared_ptr<oatpp::data::stream::IOStream>> {
private:
oatpp::base::String::PtrWrapper m_host;
oatpp::String m_host;
v_int32 m_port;
oatpp::os::io::Library::v_handle m_clientHandle;
struct sockaddr_in m_client;
public:
ConnectCoroutine(const oatpp::base::String::PtrWrapper& host, v_int32 port)
ConnectCoroutine(const oatpp::String& host, v_int32 port)
: m_host(host)
, m_port(port)
{}

6
network/client/SimpleTCPConnectionProvider.hpp
View File

@ -28,19 +28,19 @@
#include "oatpp/network/ConnectionProvider.hpp"
#include "oatpp/core/data/stream/Stream.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace network { namespace client {
class SimpleTCPConnectionProvider : public base::Controllable, public ClientConnectionProvider {
public:
SimpleTCPConnectionProvider(const oatpp::base::String::PtrWrapper& host, v_int32 port)
SimpleTCPConnectionProvider(const oatpp::String& host, v_int32 port)
: ClientConnectionProvider(host, port)
{}
public:
static std::shared_ptr<SimpleTCPConnectionProvider>
createShared(const oatpp::base::String::PtrWrapper& host, v_int32 port){
createShared(const oatpp::String& host, v_int32 port){
return std::shared_ptr<SimpleTCPConnectionProvider>(new SimpleTCPConnectionProvider(host, port));
}

4
network/server/Server.hpp
View File

@ -31,7 +31,7 @@
#include "oatpp/core/concurrency/Runnable.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Environment.hpp"
@ -56,7 +56,7 @@ private:
std::atomic<v_int32> m_status;
std::shared_ptr<base::String> m_port;
oatpp::String m_port;
std::shared_ptr<ServerConnectionProvider> m_connectionProvider;
std::shared_ptr<ConnectionHandler> m_connectionHandler;

2
network/server/SimpleTCPConnectionProvider.hpp
View File

@ -28,7 +28,7 @@
#include "oatpp/network/ConnectionProvider.hpp"
#include "oatpp/core/data/stream/Stream.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/os/io/Library.hpp"
namespace oatpp { namespace network { namespace server {

12
parser/json/Utils.cpp
View File

@ -200,13 +200,13 @@ v_int32 Utils::escapeUtf8Char(p_char8 sequence, p_char8 buffer){
}
}
std::shared_ptr<Utils::String> Utils::escapeString(p_char8 data, v_int32 size) {
oatpp::String Utils::escapeString(p_char8 data, v_int32 size) {
v_int32 safeSize;
v_int32 escapedSize = calcEscapedStringSize(data, size, safeSize);
if(escapedSize == size) {
return String::createShared(data, size, true);
return String(data, size, true);
}
auto result = String::createShared(escapedSize);
auto result = String(escapedSize);
v_int32 i = 0;
p_char8 resultData = result->getData();
v_int32 pos = 0;
@ -322,14 +322,14 @@ void Utils::unescapeStringToBuffer(p_char8 data, v_int32 size, p_char8 resultDat
}
std::shared_ptr<Utils::String> Utils::unescapeString(p_char8 data, v_int32 size,
oatpp::String Utils::unescapeString(p_char8 data, v_int32 size,
const char* & error, v_int32& errorPosition) {
v_int32 unescapedSize = calcUnescapedStringSize(data, size, error, errorPosition);
if(error != nullptr){
return nullptr;
}
auto result = String::createShared(unescapedSize);
auto result = String(unescapedSize);
if(unescapedSize == size) {
std::memcpy(result->getData(), data, size);
} else {
@ -385,7 +385,7 @@ p_char8 Utils::preparseString(const std::shared_ptr<ParsingCaret>& caret, v_int3
}
std::shared_ptr<Utils::String> Utils::parseString(const std::shared_ptr<ParsingCaret>& caret) {
oatpp::String Utils::parseString(const std::shared_ptr<ParsingCaret>& caret) {
v_int32 size;
p_char8 data = preparseString(caret, size);

10
parser/json/Utils.hpp
View File

@ -26,7 +26,7 @@
#define oatpp_parser_json_Utils_hpp
#include "oatpp/core/parser/ParsingCaret.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include <string>
@ -39,7 +39,7 @@ public:
static const char* const ERROR_PARSER_QUOTE_EXPECTED;
public:
typedef oatpp::base::String String;
typedef oatpp::String String;
typedef oatpp::parser::ParsingCaret ParsingCaret;
private:
static v_int32 escapeUtf8Char(p_char8 sequence, p_char8 buffer);
@ -49,12 +49,12 @@ private:
static p_char8 preparseString(const std::shared_ptr<ParsingCaret>& caret, v_int32& size);
public:
static std::shared_ptr<String> escapeString(p_char8 data, v_int32 size);
static std::shared_ptr<String> unescapeString(p_char8 data, v_int32 size, const char* & error, v_int32& errorPosition);
static String escapeString(p_char8 data, v_int32 size);
static String unescapeString(p_char8 data, v_int32 size, const char* & error, v_int32& errorPosition);
static std::string unescapeStringToStdString(p_char8 data, v_int32 size,
const char* & error, v_int32& errorPosition);
static std::shared_ptr<String> parseString(const std::shared_ptr<ParsingCaret>& caret);
static String parseString(const std::shared_ptr<ParsingCaret>& caret);
static std::string parseStringToStdString(const std::shared_ptr<ParsingCaret>& caret);
};

4
parser/json/mapping/Deserializer.hpp
View File

@ -33,7 +33,7 @@
#include "oatpp/core/parser/ParsingCaret.hpp"
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace parser { namespace json { namespace mapping {
@ -47,7 +47,7 @@ public:
typedef oatpp::data::mapping::type::Object Object;
private:
typedef oatpp::data::mapping::type::StringPtrWrapper String;
typedef oatpp::data::mapping::type::String String;
typedef oatpp::data::mapping::type::Int32 Int32;
typedef oatpp::data::mapping::type::Int64 Int64;
typedef oatpp::data::mapping::type::Float32 Float32;

4
parser/json/mapping/Serializer.cpp
View File

@ -31,7 +31,7 @@ namespace oatpp { namespace parser { namespace json { namespace mapping {
void Serializer::writeString(oatpp::data::stream::OutputStream* stream,
void* object,
Property* field) {
auto value = oatpp::base::static_wrapper_cast<String>(field->get(object));
auto value = oatpp::base::static_wrapper_cast<oatpp::base::StrBuffer>(field->get(object));
stream->writeChar('\"');
stream->write(field->name);
stream->write("\": ", 3);
@ -68,7 +68,7 @@ void Serializer::writeListOfString(oatpp::data::stream::OutputStream* stream,
auto curr = list->getFirstNode();
while(curr != nullptr){
auto value = oatpp::base::static_wrapper_cast<String>(curr->getData());
auto value = oatpp::base::static_wrapper_cast<oatpp::base::StrBuffer>(curr->getData());
if(first){
first = false;

4
parser/json/mapping/Serializer.hpp
View File

@ -34,7 +34,7 @@
#include "oatpp/core/parser/ParsingCaret.hpp"
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace parser { namespace json { namespace mapping {
@ -64,7 +64,7 @@ public:
};
public:
typedef oatpp::base::String String;
typedef oatpp::String String;
private:
static void writeString(oatpp::data::stream::OutputStream* stream,

53
test/core/base/RegRuleTest.cpp
View File

@ -25,7 +25,7 @@
#include "RegRuleTest.hpp"
#include "oatpp/core/data/mapping/type/Primitive.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace test { namespace base {
@ -61,7 +61,7 @@ namespace {
};
typedef oatpp::base::String String;
typedef oatpp::String String;
template<typename T>
using PtrWrapper = oatpp::base::PtrWrapper<T>;
@ -72,7 +72,6 @@ namespace {
template<typename T>
using TypePtrWrapper = oatpp::data::mapping::type::PtrWrapper<T, oatpp::data::mapping::type::__class::Void>;
typedef oatpp::data::mapping::type::StringPtrWrapper StringPtrWrapper;
typedef oatpp::data::mapping::type::Int32 Int32;
typedef oatpp::data::mapping::type::Int64 Int64;
typedef oatpp::data::mapping::type::Float32 Float32;
@ -84,61 +83,61 @@ namespace {
bool RegRuleTest::onRun() {
{
String::PtrWrapper reg1("");
String::PtrWrapper reg2(reg1);
String reg1("");
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
String::PtrWrapper reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
String::PtrWrapper reg4 = String::createShared(100);
String reg4 = String(100);
}
{
String::PtrWrapper reg1("");
base::PtrWrapper<String> reg2(reg1);
String reg1("");
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
base::PtrWrapper<String> reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
base::PtrWrapper<String> reg4 = String::createShared(100) + "Leonid";
String reg4 = String(100) + "Leonid";
}
{
base::PtrWrapper<String> reg1 = String::createShared(100);
String::PtrWrapper reg2(reg1);
String reg1 = String(100);
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
String::PtrWrapper reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
}
{
String::PtrWrapper reg1(String::createShared(100) + "Leonid");
StringPtrWrapper reg2(reg1);
String reg1(String(100) + "Leonid");
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
StringPtrWrapper reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
StringPtrWrapper reg4 = String::createShared(100);
String reg4 = String(100);
}
{
StringPtrWrapper reg1 = String::createShared(100);
String::PtrWrapper reg2(reg1);
String reg1 = String(100);
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
String::PtrWrapper reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
}
{
base::PtrWrapper<String> reg1 = String::createShared(100);
StringPtrWrapper reg2(reg1);
String reg1 = String(100);
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
StringPtrWrapper reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
}
{
StringPtrWrapper reg1 = String::createShared(100);
base::PtrWrapper<String> reg2(reg1);
String reg1 = String(100);
String reg2(reg1);
OATPP_ASSERT(!reg1.isNull());
base::PtrWrapper<String> reg3(std::move(reg1));
String reg3(std::move(reg1));
OATPP_ASSERT(reg1.isNull());
}

2
test/core/base/collection/LinkedListTest.cpp
View File

@ -24,7 +24,7 @@
#include "LinkedListTest.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/test/Checker.hpp"
#include <list>

2
test/core/base/memory/PerfTest.cpp
View File

@ -25,7 +25,7 @@
#include "PerfTest.hpp"
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/concurrency/Thread.hpp"
#include <list>

2
test/parser/json/mapping/DTOMapperTest.cpp
View File

@ -170,7 +170,7 @@ bool DTOMapperTest::onRun(){
auto obj = mapper->readFromCaret<Test>(caret);
OATPP_ASSERT(obj->_string.isNull() == false);
OATPP_ASSERT(obj->_string->equals(test1->_string));
OATPP_ASSERT(obj->_string.equals(test1->_string));
OATPP_ASSERT(obj->_int32.isNull() == false);
OATPP_ASSERT(obj->_int32->getValue() == test1->_int32->getValue());

10
web/client/ApiClient.cpp
View File

@ -78,13 +78,13 @@ void ApiClient::formatPath(oatpp::data::stream::OutputStream* stream,
if(seg.type == PathSegment::SEG_PATH) {
stream->write(seg.text.data(), seg.text.size());
} else {
auto key = base::String::createShared((p_char8) seg.text.data(), (v_int32) seg.text.length(), false);
auto key = oatpp::String((p_char8) seg.text.data(), (v_int32) seg.text.length(), false);
auto& param = params->get(key, oatpp::data::mapping::type::AbstractPtrWrapper::empty());
if(param.isNull()){
OATPP_LOGD(TAG, "Path parameter '%s' not provided in the api call", (const char*) seg.text.c_str());
throw std::runtime_error("[oatpp::web::client::ApiClient]: Path parameter missing");
}
auto value = oatpp::data::mapping::type::primitiveToStr(param);
auto value = oatpp::utils::conversion::primitiveToStr(param);
stream->data::stream::OutputStream::write(value);
}
}
@ -99,13 +99,13 @@ void ApiClient::addPathQueryParams(oatpp::data::stream::OutputStream* stream,
stream->write("?", 1);
stream->data::stream::OutputStream::write(curr->getKey());
stream->write("=", 1);
stream->data::stream::OutputStream::write(oatpp::data::mapping::type::primitiveToStr(curr->getValue()));
stream->data::stream::OutputStream::write(oatpp::utils::conversion::primitiveToStr(curr->getValue()));
curr = curr->getNext();
while (curr != nullptr) {
stream->write("&", 1);
stream->data::stream::OutputStream::write(curr->getKey());
stream->write("=", 1);
stream->data::stream::OutputStream::write(oatpp::data::mapping::type::primitiveToStr(curr->getValue()));
stream->data::stream::OutputStream::write(oatpp::utils::conversion::primitiveToStr(curr->getValue()));
curr = curr->getNext();
}
}
@ -122,7 +122,7 @@ std::shared_ptr<ApiClient::StringToStringMap> ApiClient::convertParamsMap(const
auto curr = params->getFirstEntry();
while (curr != nullptr) {
result->put(curr->getKey(), oatpp::data::mapping::type::primitiveToStr(curr->getValue()));
result->put(curr->getKey(), oatpp::utils::conversion::primitiveToStr(curr->getValue()));
curr = curr->getNext();
}

16
web/client/ApiClient.hpp
View File

@ -56,21 +56,21 @@ public:
static constexpr const char* const TAG = "Client";
protected:
typedef oatpp::collection::ListMap<
oatpp::base::String::PtrWrapper,
oatpp::String,
oatpp::data::mapping::type::AbstractPtrWrapper
> StringToParamMap;
protected:
typedef std::unordered_map<std::string, std::shared_ptr<oatpp::base::String>> PathVariablesMap;
typedef std::unordered_map<std::string, oatpp::String> PathVariablesMap;
private:
typedef oatpp::collection::ListMap<
oatpp::base::String::PtrWrapper,
oatpp::base::String::PtrWrapper
oatpp::String,
oatpp::String
> StringToStringMap;
public:
typedef oatpp::web::protocol::http::Status Status;
typedef oatpp::web::protocol::http::Header Header;
public:
typedef oatpp::data::mapping::type::StringPtrWrapper String;
typedef oatpp::data::mapping::type::String String;
typedef oatpp::data::mapping::type::Int32::PtrWrapper Int32;
typedef oatpp::data::mapping::type::Int64::PtrWrapper Int64;
typedef oatpp::data::mapping::type::Float32::PtrWrapper Float32;
@ -133,7 +133,7 @@ public:
protected:
virtual oatpp::base::String::PtrWrapper formatPath(const PathPattern& pathPattern,
virtual oatpp::String formatPath(const PathPattern& pathPattern,
const std::shared_ptr<StringToParamMap>& pathParams,
const std::shared_ptr<StringToParamMap>& queryParams) {
oatpp::data::stream::ChunkedBuffer stream;
@ -144,7 +144,7 @@ protected:
return stream.toString();
}
virtual std::shared_ptr<Response> executeRequest(const oatpp::base::String::PtrWrapper& method,
virtual std::shared_ptr<Response> executeRequest(const oatpp::String& method,
const PathPattern& pathPattern,
const std::shared_ptr<StringToParamMap>& headers,
const std::shared_ptr<StringToParamMap>& pathParams,
@ -160,7 +160,7 @@ protected:
virtual oatpp::async::Action executeRequestAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
AsyncCallback callback,
const oatpp::base::String::PtrWrapper& method,
const oatpp::String& method,
const PathPattern& pathPattern,
const std::shared_ptr<StringToParamMap>& headers,
const std::shared_ptr<StringToParamMap>& pathParams,

16
web/client/HttpRequestExecutor.cpp
View File

@ -41,8 +41,8 @@
namespace oatpp { namespace web { namespace client {
std::shared_ptr<HttpRequestExecutor::Response>
HttpRequestExecutor::execute(const String::PtrWrapper& method,
const String::PtrWrapper& path,
HttpRequestExecutor::execute(const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) {
@ -105,16 +105,16 @@ HttpRequestExecutor::execute(const String::PtrWrapper& method,
oatpp::async::Action HttpRequestExecutor::executeAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
AsyncCallback callback,
const String::PtrWrapper& method,
const String::PtrWrapper& path,
const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) {
class ExecutorCoroutine : public oatpp::async::CoroutineWithResult<ExecutorCoroutine, std::shared_ptr<HttpRequestExecutor::Response>> {
private:
std::shared_ptr<oatpp::network::ClientConnectionProvider> m_connectionProvider;
String::PtrWrapper m_method;
String::PtrWrapper m_path;
String m_method;
String m_path;
std::shared_ptr<Headers> m_headers;
std::shared_ptr<Body> m_body;
private:
@ -125,8 +125,8 @@ oatpp::async::Action HttpRequestExecutor::executeAsync(oatpp::async::AbstractCor
public:
ExecutorCoroutine(const std::shared_ptr<oatpp::network::ClientConnectionProvider>& connectionProvider,
const String::PtrWrapper& method,
const String::PtrWrapper& path,
const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body)
: m_connectionProvider(connectionProvider)

8
web/client/HttpRequestExecutor.hpp
View File

@ -44,15 +44,15 @@ public:
return std::shared_ptr<HttpRequestExecutor>(new HttpRequestExecutor(connectionProvider));
}
std::shared_ptr<Response> execute(const String::PtrWrapper& method,
const String::PtrWrapper& path,
std::shared_ptr<Response> execute(const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) override;
Action executeAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
AsyncCallback callback,
const String::PtrWrapper& method,
const String::PtrWrapper& path,
const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) override;

10
web/client/RequestExecutor.hpp
View File

@ -33,7 +33,7 @@ namespace oatpp { namespace web { namespace client {
class RequestExecutor {
public:
typedef oatpp::base::String String;
typedef oatpp::String String;
typedef oatpp::async::Action Action;
public:
typedef oatpp::web::protocol::http::Protocol::Headers Headers;
@ -43,15 +43,15 @@ public:
typedef Action (oatpp::async::AbstractCoroutine::*AsyncCallback)(const std::shared_ptr<Response>&);
public:
virtual std::shared_ptr<Response> execute(const String::PtrWrapper& method,
const String::PtrWrapper& path,
virtual std::shared_ptr<Response> execute(const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) = 0;
virtual Action executeAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
AsyncCallback callback,
const String::PtrWrapper& method,
const String::PtrWrapper& path,
const String& method,
const String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) = 0;

8
web/client/macro/zzz_macro_define_ApiClient_.hpp
View File

@ -130,7 +130,7 @@ OATPP_MACRO_API_CLIENT_PARAM_MACRO X
// API_CALL MACRO
#define OATPP_API_CALL_0(NAME, METHOD, PATH, LIST) \
static PathPattern Z_getPathPattern_##NAME(const oatpp::base::String::PtrWrapper& path) { \
static PathPattern Z_getPathPattern_##NAME(const oatpp::String& path) { \
static PathPattern pattern = parsePathPattern(path->getData(), path->getSize()); \
return pattern; \
} \
@ -146,7 +146,7 @@ std::shared_ptr<oatpp::web::protocol::http::incoming::Response> NAME() { \
}
#define OATPP_API_CALL_1(NAME, METHOD, PATH, LIST) \
static PathPattern Z_getPathPattern_##NAME(const oatpp::base::String::PtrWrapper& path) { \
static PathPattern Z_getPathPattern_##NAME(const oatpp::String& path) { \
static PathPattern pattern = parsePathPattern(path->getData(), path->getSize()); \
return pattern; \
} \
@ -177,7 +177,7 @@ OATPP_API_CALL___(NAME, METHOD, PATH, (__VA_ARGS__))
// API_CALL_ASYNC MACRO
#define OATPP_API_CALL_ASYNC_0(NAME, METHOD, PATH, LIST) \
static PathPattern Z_getPathPattern_##NAME(const oatpp::base::String::PtrWrapper& path) { \
static PathPattern Z_getPathPattern_##NAME(const oatpp::String& path) { \
static PathPattern pattern = parsePathPattern(path->getData(), path->getSize()); \
return pattern; \
} \
@ -198,7 +198,7 @@ oatpp::async::Action NAME(\
}
#define OATPP_API_CALL_ASYNC_1(NAME, METHOD, PATH, LIST) \
static PathPattern Z_getPathPattern_##NAME(const oatpp::base::String::PtrWrapper& path) { \
static PathPattern Z_getPathPattern_##NAME(const oatpp::String& path) { \
static PathPattern pattern = parsePathPattern(path->getData(), path->getSize()); \
return pattern; \
} \

10
web/protocol/http/Http.cpp
View File

@ -120,7 +120,7 @@ const char* const Header::HOST = "Host";
const char* const Header::USER_AGENT = "User-Agent";
const char* const Header::SERVER = "Server";
oatpp::base::String::PtrWrapper Range::toString() const {
oatpp::String Range::toString() const {
oatpp::data::stream::ChunkedBuffer stream;
stream.write(units->getData(), units->getSize());
stream.write("=", 1);
@ -161,12 +161,12 @@ Range Range::parse(oatpp::parser::ParsingCaret& caret) {
}
Range Range::parse(const std::shared_ptr<oatpp::base::String>& str) {
Range Range::parse(const oatpp::String& str) {
oatpp::parser::ParsingCaret caret(str);
return parse(caret);
}
oatpp::base::String::PtrWrapper ContentRange::toString() const {
oatpp::String ContentRange::toString() const {
oatpp::data::stream::ChunkedBuffer stream;
stream.write(units->getData(), units->getSize());
stream.write(" ", 1);
@ -229,7 +229,7 @@ ContentRange ContentRange::parse(oatpp::parser::ParsingCaret& caret) {
}
ContentRange ContentRange::parse(const std::shared_ptr<oatpp::base::String>& str) {
ContentRange ContentRange::parse(const oatpp::String& str) {
oatpp::parser::ParsingCaret caret(str);
return parse(caret);
}
@ -299,7 +299,7 @@ std::shared_ptr<ResponseStartingLine> Protocol::parseResponseStartingLine(oatpp:
}
std::shared_ptr<oatpp::base::String> Protocol::parseHeaderName(oatpp::parser::ParsingCaret& caret) {
oatpp::String Protocol::parseHeaderName(oatpp::parser::ParsingCaret& caret) {
p_char8 data = caret.getData();
oatpp::parser::ParsingCaret::Label label(caret);
for(v_int32 i = caret.getPosition(); i < caret.getSize(); i++) {

32
web/protocol/http/Http.hpp
View File

@ -31,7 +31,7 @@
#include "oatpp/core/data/stream/Delegate.hpp"
#include "oatpp/core/collection/ListMap.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace web { namespace protocol { namespace http {
@ -157,7 +157,7 @@ private:
{}
public:
Range(const oatpp::base::String::PtrWrapper& pUnits,
Range(const oatpp::String& pUnits,
const oatpp::os::io::Library::v_size& pStart,
const oatpp::os::io::Library::v_size& pEnd)
: units(pUnits)
@ -165,18 +165,18 @@ public:
, end(pEnd)
{}
oatpp::base::String::PtrWrapper units;
oatpp::String units;
oatpp::os::io::Library::v_size start;
oatpp::os::io::Library::v_size end;
oatpp::base::String::PtrWrapper toString() const;
oatpp::String toString() const;
bool isValid() const {
return units.get() != nullptr;
}
static Range parse(oatpp::parser::ParsingCaret& caret);
static Range parse(const std::shared_ptr<oatpp::base::String>& str);
static Range parse(const oatpp::String& str);
};
@ -189,7 +189,7 @@ private:
{}
public:
ContentRange(const oatpp::base::String::PtrWrapper& pUnits,
ContentRange(const oatpp::String& pUnits,
const oatpp::os::io::Library::v_size& pStart,
const oatpp::os::io::Library::v_size& pEnd,
const oatpp::os::io::Library::v_size& pSize,
@ -201,20 +201,20 @@ public:
, isSizeKnown(pIsSizeKnown)
{}
oatpp::base::String::PtrWrapper units;
oatpp::String units;
oatpp::os::io::Library::v_size start;
oatpp::os::io::Library::v_size end;
oatpp::os::io::Library::v_size size;
bool isSizeKnown;
oatpp::base::String::PtrWrapper toString() const;
oatpp::String toString() const;
bool isValid() const {
return units.get() != nullptr;
}
static ContentRange parse(oatpp::parser::ParsingCaret& caret);
static ContentRange parse(const std::shared_ptr<oatpp::base::String>& str);
static ContentRange parse(const oatpp::String& str);
};
@ -231,9 +231,9 @@ public:
return Shared_RequestStartingLine_Pool::allocateShared();
}
std::shared_ptr<base::String> method; // GET, POST ...
std::shared_ptr<base::String> path;
std::shared_ptr<base::String> protocol;
oatpp::String method; // GET, POST ...
oatpp::String path;
oatpp::String protocol;
};
@ -250,17 +250,17 @@ public:
return Shared_ResponseStartingLine_Pool::allocateShared();
}
std::shared_ptr<base::String> protocol;
oatpp::String protocol;
v_int32 statusCode;
std::shared_ptr<base::String> description;
oatpp::String description;
};
class Protocol {
public:
typedef oatpp::collection::ListMap<base::String::PtrWrapper, base::String::PtrWrapper> Headers;
typedef oatpp::collection::ListMap<oatpp::String, oatpp::String> Headers;
private:
static std::shared_ptr<oatpp::base::String> parseHeaderName(oatpp::parser::ParsingCaret& caret);
static oatpp::String parseHeaderName(oatpp::parser::ParsingCaret& caret);
public:
static std::shared_ptr<RequestStartingLine> parseRequestStartingLine(oatpp::parser::ParsingCaret& caret);

6
web/protocol/http/incoming/BodyDecoder.hpp
View File

@ -34,7 +34,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
class BodyDecoder {
private:
class ToStringDecoder : public oatpp::async::CoroutineWithResult<ToStringDecoder, std::shared_ptr<oatpp::base::String>> {
class ToStringDecoder : public oatpp::async::CoroutineWithResult<ToStringDecoder, oatpp::String> {
private:
std::shared_ptr<Protocol::Headers> m_headers;
std::shared_ptr<oatpp::data::stream::InputStream> m_bodyStream;
@ -104,7 +104,7 @@ public:
const std::shared_ptr<oatpp::data::stream::InputStream>& bodyStream,
const std::shared_ptr<oatpp::data::stream::OutputStream>& toStream);
static std::shared_ptr<oatpp::base::String>
static oatpp::String
decodeToString(const std::shared_ptr<Protocol::Headers>& headers,
const std::shared_ptr<oatpp::data::stream::InputStream>& bodyStream) {
auto chunkedBuffer = oatpp::data::stream::ChunkedBuffer::createShared();
@ -130,7 +130,7 @@ public:
template<typename ParentCoroutineType>
static oatpp::async::Action
decodeToStringAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::base::String::PtrWrapper&),
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::String&),
const std::shared_ptr<Protocol::Headers>& headers,
const std::shared_ptr<oatpp::data::stream::InputStream>& bodyStream) {
return parentCoroutine->startCoroutineForResult<ToStringDecoder>(callback, headers, bodyStream);

10
web/protocol/http/incoming/Request.hpp
View File

@ -60,7 +60,7 @@ public:
std::shared_ptr<http::Protocol::Headers> headers;
std::shared_ptr<oatpp::data::stream::InputStream> bodyStream;
base::String::PtrWrapper getHeader(const base::String::PtrWrapper& headerName) const{
oatpp::String getHeader(const oatpp::String& headerName) const{
auto entry = headers->find(headerName);
if(entry != nullptr) {
return entry->getValue();
@ -68,7 +68,7 @@ public:
return nullptr;
}
base::String::PtrWrapper getPathVariable(const base::String::PtrWrapper& name) const{
oatpp::String getPathVariable(const oatpp::String& name) const{
auto entry = pathVariables->getVariable(name);
if(entry != nullptr) {
return entry->getValue();
@ -76,7 +76,7 @@ public:
return nullptr;
}
base::String::PtrWrapper getPathTail() const{
oatpp::String getPathTail() const{
return pathVariables->tail;
}
@ -84,7 +84,7 @@ public:
protocol::http::incoming::BodyDecoder::decode(headers, bodyStream, toStream);
}
std::shared_ptr<oatpp::base::String> readBodyToString() const {
oatpp::String readBodyToString() const {
return protocol::http::incoming::BodyDecoder::decodeToString(headers, bodyStream);
}
@ -111,7 +111,7 @@ public:
template<typename ParentCoroutineType>
oatpp::async::Action readBodyToStringAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::base::String::PtrWrapper&)) const {
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::String&)) const {
return protocol::http::incoming::BodyDecoder::decodeToStringAsync(parentCoroutine, callback, headers, bodyStream);
}

10
web/protocol/http/incoming/Response.hpp
View File

@ -36,7 +36,7 @@ public:
SHARED_OBJECT_POOL(Shared_Incoming_Response_Pool, Response, 32)
public:
Response(v_int32 pStatusCode,
const oatpp::base::String::PtrWrapper& pStatusDescription,
const oatpp::String& pStatusDescription,
const std::shared_ptr<http::Protocol::Headers>& pHeaders,
const std::shared_ptr<oatpp::data::stream::InputStream>& pBodyStream)
: statusCode(pStatusCode)
@ -47,14 +47,14 @@ public:
public:
static std::shared_ptr<Response> createShared(v_int32 statusCode,
const oatpp::base::String::PtrWrapper& statusDescription,
const oatpp::String& statusDescription,
const std::shared_ptr<http::Protocol::Headers>& headers,
const std::shared_ptr<oatpp::data::stream::InputStream>& bodyStream) {
return Shared_Incoming_Response_Pool::allocateShared(statusCode, statusDescription, headers, bodyStream);
}
const v_int32 statusCode;
const oatpp::base::String::PtrWrapper statusDescription;
const oatpp::String statusDescription;
const std::shared_ptr<http::Protocol::Headers> headers;
const std::shared_ptr<oatpp::data::stream::InputStream> bodyStream;
@ -62,7 +62,7 @@ public:
protocol::http::incoming::BodyDecoder::decode(headers, bodyStream, toStream);
}
oatpp::base::String::PtrWrapper readBodyToString() const {
oatpp::String readBodyToString() const {
return protocol::http::incoming::BodyDecoder::decodeToString(headers, bodyStream);
}
@ -82,7 +82,7 @@ public:
template<typename ParentCoroutineType>
oatpp::async::Action readBodyToStringAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::base::String::PtrWrapper&)) const {
oatpp::async::Action (ParentCoroutineType::*callback)(const oatpp::String&)) const {
return protocol::http::incoming::BodyDecoder::decodeToStringAsync(parentCoroutine, callback, headers, bodyStream);
}

2
web/protocol/http/outgoing/Body.hpp
View File

@ -35,7 +35,7 @@ class Body {
protected:
typedef oatpp::async::Action Action;
protected:
typedef oatpp::collection::ListMap<base::String::PtrWrapper, base::String::PtrWrapper> Headers;
typedef oatpp::collection::ListMap<oatpp::String, oatpp::String> Headers;
typedef oatpp::data::stream::OutputStream OutputStream;
public:
virtual void declareHeaders(const std::shared_ptr<Headers>& headers) = 0;

6
web/protocol/http/outgoing/BufferBody.hpp
View File

@ -36,14 +36,14 @@ public:
OBJECT_POOL(Http_Outgoing_BufferBody_Pool, BufferBody, 32)
SHARED_OBJECT_POOL(Shared_Http_Outgoing_BufferBody_Pool, BufferBody, 32)
private:
oatpp::base::String::PtrWrapper m_buffer;
oatpp::String m_buffer;
public:
BufferBody(const oatpp::base::String::PtrWrapper& buffer)
BufferBody(const oatpp::String& buffer)
: m_buffer(buffer)
{}
public:
static std::shared_ptr<BufferBody> createShared(const oatpp::base::String::PtrWrapper& buffer) {
static std::shared_ptr<BufferBody> createShared(const oatpp::String& buffer) {
return Shared_Http_Outgoing_BufferBody_Pool::allocateShared(buffer);
}

12
web/protocol/http/outgoing/Request.hpp
View File

@ -39,8 +39,8 @@ public:
public:
Request() {}
Request(const base::String::PtrWrapper& pMethod,
const base::String::PtrWrapper& pPath,
Request(const oatpp::String& pMethod,
const oatpp::String& pPath,
const std::shared_ptr<Headers>& pHeaders,
const std::shared_ptr<Body>& pBody)
: method(pMethod)
@ -51,15 +51,15 @@ public:
public:
static std::shared_ptr<Request> createShared(const base::String::PtrWrapper& method,
const base::String::PtrWrapper& path,
static std::shared_ptr<Request> createShared(const oatpp::String& method,
const oatpp::String& path,
const std::shared_ptr<Headers>& headers,
const std::shared_ptr<Body>& body) {
return Shared_Outgoing_Request_Pool::allocateShared(method, path, headers, body);
}
const base::String::PtrWrapper method;
const base::String::PtrWrapper path;
const oatpp::String method;
const oatpp::String path;
const std::shared_ptr<Headers> headers;
const std::shared_ptr<Body> body;

2
web/protocol/http/outgoing/Response.hpp
View File

@ -33,7 +33,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
class Response : public oatpp::base::Controllable {
public:
typedef oatpp::collection::ListMap<base::String::PtrWrapper, base::String::PtrWrapper> Headers;
typedef oatpp::collection::ListMap<oatpp::String, oatpp::String> Headers;
public:
OBJECT_POOL(Outgoing_Response_Pool, Response, 32)
SHARED_OBJECT_POOL(Shared_Outgoing_Response_Pool, Response, 32)

2
web/protocol/http/outgoing/ResponseFactory.cpp
View File

@ -31,7 +31,7 @@
namespace oatpp { namespace web { namespace protocol { namespace http { namespace outgoing {
std::shared_ptr<Response>
ResponseFactory::createShared(const Status& status, const oatpp::base::String::PtrWrapper& text) {
ResponseFactory::createShared(const Status& status, const oatpp::String& text) {
return Response::createShared(status, BufferBody::createShared(text));
}

2
web/protocol/http/outgoing/ResponseFactory.hpp
View File

@ -36,7 +36,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
class ResponseFactory {
public:
static std::shared_ptr<Response> createShared(const Status& status, const oatpp::base::String::PtrWrapper& text);
static std::shared_ptr<Response> createShared(const Status& status, const oatpp::String& text);
static std::shared_ptr<Response> createShared(const Status& status, const std::shared_ptr<oatpp::data::stream::ChunkedBuffer>& segBuffer);
static std::shared_ptr<Response> createShared(const Status& status,
const oatpp::data::mapping::type::AbstractPtrWrapper& dto,

8
web/server/HttpError.hpp
View File

@ -26,18 +26,18 @@
#define oatpp_web_server_HttpError_hpp
#include "oatpp/web/protocol/http/Http.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
namespace oatpp { namespace web { namespace server {
class HttpError : public std::runtime_error {
private:
oatpp::web::protocol::http::Status m_status;
oatpp::base::String::PtrWrapper m_message;
oatpp::String m_message;
public:
HttpError(const oatpp::web::protocol::http::Status& status,
const oatpp::base::String::PtrWrapper& message)
const oatpp::String& message)
:std::runtime_error(status.description)
, m_status(status)
, m_message(message)
@ -47,7 +47,7 @@ public:
return m_status;
}
oatpp::base::String::PtrWrapper& getMessage(){
oatpp::String& getMessage(){
return m_message;
}

6
web/server/HttpProcessor.cpp
View File

@ -35,19 +35,19 @@ bool HttpProcessor::considerConnectionKeepAlive(const std::shared_ptr<protocol::
if(request) {
auto& inKeepAlive = request->headers->get(protocol::http::Header::CONNECTION, nullptr);
if(!inKeepAlive.isNull() && base::String::equalsCI_FAST(inKeepAlive, protocol::http::Header::Value::CONNECTION_KEEP_ALIVE)) {
if(!inKeepAlive.isNull() && oatpp::base::StrBuffer::equalsCI_FAST(inKeepAlive.get(), protocol::http::Header::Value::CONNECTION_KEEP_ALIVE)) {
if(response->headers->putIfNotExists(protocol::http::Header::CONNECTION, inKeepAlive)){
return true;
} else {
auto& outKeepAlive = response->headers->get(protocol::http::Header::CONNECTION, nullptr);
return (!outKeepAlive.isNull() && base::String::equalsCI_FAST(outKeepAlive, protocol::http::Header::Value::CONNECTION_KEEP_ALIVE));
return (!outKeepAlive.isNull() && oatpp::base::StrBuffer::equalsCI_FAST(outKeepAlive.get(), protocol::http::Header::Value::CONNECTION_KEEP_ALIVE));
}
}
}
if(!response->headers->putIfNotExists(protocol::http::Header::CONNECTION, protocol::http::Header::Value::CONNECTION_CLOSE)) {
auto& outKeepAlive = response->headers->get(protocol::http::Header::CONNECTION, nullptr);
return (!outKeepAlive.isNull() && base::String::equalsCI_FAST(outKeepAlive, protocol::http::Header::Value::CONNECTION_KEEP_ALIVE));
return (!outKeepAlive.isNull() && oatpp::base::StrBuffer::equalsCI_FAST(outKeepAlive.get(), protocol::http::Header::Value::CONNECTION_KEEP_ALIVE));
}
return false;

12
web/server/HttpRouter.hpp
View File

@ -39,12 +39,12 @@ public:
std::shared_ptr<oatpp::web::protocol::http::outgoing::Response>
> BranchRouter;
typedef BranchRouter::UrlSubscriber Subscriber;
typedef oatpp::collection::ListMap<oatpp::base::String::PtrWrapper, std::shared_ptr<BranchRouter>> BranchMap;
typedef oatpp::collection::ListMap<oatpp::String, std::shared_ptr<BranchRouter>> BranchMap;
protected:
std::shared_ptr<BranchMap> m_branchMap;
protected:
const std::shared_ptr<BranchRouter>& getBranch(const oatpp::base::String::PtrWrapper& name){
const std::shared_ptr<BranchRouter>& getBranch(const oatpp::String& name){
auto entry = m_branchMap->find(name);
if(entry == nullptr){
auto branch = BranchRouter::createShared();
@ -63,14 +63,14 @@ public:
return std::shared_ptr<HttpRouter>(new HttpRouter());
}
void addSubscriber(const oatpp::base::String::PtrWrapper& method,
const oatpp::base::String::PtrWrapper& urlPattern,
void addSubscriber(const oatpp::String& method,
const oatpp::String& urlPattern,
const std::shared_ptr<Subscriber>& subscriber) {
getBranch(method)->addSubscriber(urlPattern, subscriber);
}
BranchRouter::Route getRoute(const oatpp::base::String::PtrWrapper& method,
const oatpp::base::String::PtrWrapper& url){
BranchRouter::Route getRoute(const oatpp::String& method,
const oatpp::String& url){
const std::shared_ptr<BranchRouter>& branch = m_branchMap->get(method, nullptr);
if(branch){
return branch->getRoute(url);

6
web/server/api/ApiController.hpp
View File

@ -57,7 +57,7 @@ public:
public:
typedef oatpp::data::mapping::ObjectMapper ObjectMapper;
typedef oatpp::data::mapping::type::StringPtrWrapper String;
typedef oatpp::data::mapping::type::String String;
typedef oatpp::data::mapping::type::Int32::PtrWrapper Int32;
typedef oatpp::data::mapping::type::Int64::PtrWrapper Int64;
typedef oatpp::data::mapping::type::Float32::PtrWrapper Float32;
@ -175,7 +175,7 @@ public:
return m_endpointInfo[endpointName];
}
std::shared_ptr<OutgoingResponse> handleError(const Status& status, const base::String::PtrWrapper& message) {
std::shared_ptr<OutgoingResponse> handleError(const Status& status, const oatpp::String& message) {
return m_errorHandler->handleError(status, message);
}
@ -193,7 +193,7 @@ public:
// Helper methods
std::shared_ptr<OutgoingResponse> createResponse(const Status& status,
const oatpp::base::String::PtrWrapper& str) const {
const oatpp::String& str) const {
return OutgoingResponseFactory::createShared(status, str);
}

2
web/server/api/Endpoint.cpp
View File

@ -28,7 +28,7 @@
namespace oatpp { namespace web { namespace server { namespace api {
oatpp::base::PtrWrapper<oatpp::base::String> Endpoint::Info::toString() {
oatpp::String Endpoint::Info::toString() {
auto stream = oatpp::data::stream::ChunkedBuffer::createShared();
stream << "\nEndpoint\n";

8
web/server/api/Endpoint.hpp
View File

@ -71,9 +71,9 @@ public:
return std::shared_ptr<Info>(new Info());
}
base::String::PtrWrapper name;
base::String::PtrWrapper path;
base::String::PtrWrapper method;
oatpp::String name;
oatpp::String path;
oatpp::String method;
Param body;
@ -83,7 +83,7 @@ public:
std::list<Param> returnTypes;
oatpp::base::PtrWrapper<oatpp::base::String> toString();
oatpp::String toString();
};
public:

8
web/server/api/macro/zzz_macro_define_ApiController_.hpp
View File

@ -85,13 +85,13 @@ if(!__param_validation_check_##NAME){ \
auto __param_str_val_##NAME = __request->getHeader(OATPP_MACRO_FIRSTARG PARAM_LIST); \
if(__param_str_val_##NAME.isNull()){ \
return ApiController::handleError(Status::CODE_400, \
oatpp::base::String::createShared("Missing HEADER parameter '") + OATPP_MACRO_FIRSTARG PARAM_LIST + "'"); \
oatpp::String("Missing HEADER parameter '") + OATPP_MACRO_FIRSTARG PARAM_LIST + "'"); \
} \
bool __param_validation_check_##NAME; \
TYPE NAME = TYPE::Class::parseFromString(__param_str_val_##NAME, __param_validation_check_##NAME); \
if(!__param_validation_check_##NAME){ \
return ApiController::handleError(Status::CODE_400, \
oatpp::base::String::createShared("Invalid HEADER parameter '") + \
oatpp::String("Invalid HEADER parameter '") + \
OATPP_MACRO_FIRSTARG PARAM_LIST + \
"'. Expected type is '" #TYPE "'"); \
}
@ -139,13 +139,13 @@ if(!__param_validation_check_##NAME){ \
auto __param_str_val_##NAME = __request->getPathVariable(OATPP_MACRO_FIRSTARG PARAM_LIST); \
if(__param_str_val_##NAME.isNull()){ \
return ApiController::handleError(Status::CODE_400, \
oatpp::base::String::createShared("Missing PATH parameter '") + OATPP_MACRO_FIRSTARG PARAM_LIST + "'"); \
oatpp::String("Missing PATH parameter '") + OATPP_MACRO_FIRSTARG PARAM_LIST + "'"); \
} \
bool __param_validation_check_##NAME; \
TYPE NAME = TYPE::Class::parseFromString(__param_str_val_##NAME, __param_validation_check_##NAME); \
if(!__param_validation_check_##NAME){ \
return ApiController::handleError(Status::CODE_400, \
oatpp::base::String::createShared("Invalid PATH parameter '") + \
oatpp::String("Invalid PATH parameter '") + \
OATPP_MACRO_FIRSTARG PARAM_LIST + \
"'. Expected type is '" #TYPE "'"); \
}

2
web/server/handler/ErrorHandler.cpp
View File

@ -30,7 +30,7 @@
namespace oatpp { namespace web { namespace server { namespace handler {
std::shared_ptr<protocol::http::outgoing::Response>
DefaultErrorHandler::handleError(const protocol::http::Status& status, const base::String::PtrWrapper& message) {
DefaultErrorHandler::handleError(const protocol::http::Status& status, const oatpp::String& message) {
auto stream = oatpp::data::stream::ChunkedBuffer::createShared();
stream << "server=" << protocol::http::Header::Value::SERVER << "\n";

4
web/server/handler/ErrorHandler.hpp
View File

@ -35,7 +35,7 @@ public:
virtual
std::shared_ptr<protocol::http::outgoing::Response>
handleError(const protocol::http::Status& status, const base::String::PtrWrapper& message) = 0;
handleError(const protocol::http::Status& status, const oatpp::String& message) = 0;
};
@ -50,7 +50,7 @@ public:
}
std::shared_ptr<protocol::http::outgoing::Response>
handleError(const protocol::http::Status& status, const base::String::PtrWrapper& message) override;
handleError(const protocol::http::Status& status, const oatpp::String& message) override;
};

30
web/url/mapping/Pattern.cpp
View File

@ -50,7 +50,7 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_int32 size){
if(a == '/'){
if(i - lastPos > 0){
auto part = Part::createShared(Part::FUNCTION_CONST, base::String::createShared(&data[lastPos], i - lastPos, true));
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String(&data[lastPos], i - lastPos, true));
result->m_parts->pushBack(part);
}
@ -59,10 +59,10 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_int32 size){
} else if(a == '*'){
lastPos = i + 1;
if(size > lastPos){
auto part = Part::createShared(Part::FUNCTION_ANY_END, base::String::createShared(&data[lastPos], size - lastPos, true));
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String(&data[lastPos], size - lastPos, true));
result->m_parts->pushBack(part);
}else{
auto part = Part::createShared(Part::FUNCTION_ANY_END, base::String::createShared(0));
auto part = Part::createShared(Part::FUNCTION_ANY_END, oatpp::String(0));
result->m_parts->pushBack(part);
}
return result;
@ -75,10 +75,10 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_int32 size){
}
if(i > lastPos){
auto part = Part::createShared(Part::FUNCTION_VAR, base::String::createShared(&data[lastPos], i - lastPos, true));
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String(&data[lastPos], i - lastPos, true));
result->m_parts->pushBack(part);
}else{
auto part = Part::createShared(Part::FUNCTION_VAR, base::String::createShared(0));
auto part = Part::createShared(Part::FUNCTION_VAR, oatpp::String(0));
result->m_parts->pushBack(part);
}
@ -91,7 +91,7 @@ std::shared_ptr<Pattern> Pattern::parse(p_char8 data, v_int32 size){
}
if(i - lastPos > 0){
auto part = Part::createShared(Part::FUNCTION_CONST, base::String::createShared(&data[lastPos], i - lastPos, true));
auto part = Part::createShared(Part::FUNCTION_CONST, oatpp::String(&data[lastPos], i - lastPos, true));
result->m_parts->pushBack(part);
}
@ -102,7 +102,7 @@ std::shared_ptr<Pattern> Pattern::parse(const char* data){
return parse((p_char8) data, (v_int32) std::strlen(data));
}
std::shared_ptr<Pattern> Pattern::parse(const base::String::PtrWrapper& data){
std::shared_ptr<Pattern> Pattern::parse(const oatpp::String& data){
return parse(data->getData(), data->getSize());
}
@ -134,7 +134,7 @@ std::shared_ptr<Pattern::MatchMap> Pattern::match(p_char8 url, v_int32 size){
}
auto vars = MatchMap::Variables::createShared();
std::shared_ptr<base::String> tail;
oatpp::String tail;
auto curr = m_parts->getFirstNode();
@ -151,7 +151,7 @@ std::shared_ptr<Pattern::MatchMap> Pattern::match(p_char8 url, v_int32 size){
if(caret.canContinue() && !caret.isAtChar('/')){
if(caret.isAtChar('?') && (curr == nullptr || curr->getData()->function == Part::FUNCTION_ANY_END)) {
tail = base::String::createShared(caret.getCurrData(), size - caret.getPosition(), true);
tail = oatpp::String(caret.getCurrData(), size - caret.getPosition(), true);
return MatchMap::createShared(vars, tail);
}
return nullptr;
@ -159,7 +159,7 @@ std::shared_ptr<Pattern::MatchMap> Pattern::match(p_char8 url, v_int32 size){
}else if(part->function == Part::FUNCTION_ANY_END){
if(size > caret.getPosition()){
tail = base::String::createShared(caret.getCurrData(), size - caret.getPosition(), true);
tail = oatpp::String(caret.getCurrData(), size - caret.getPosition(), true);
}
return MatchMap::createShared(vars, tail);
}else if(part->function == Part::FUNCTION_VAR){
@ -172,14 +172,14 @@ std::shared_ptr<Pattern::MatchMap> Pattern::match(p_char8 url, v_int32 size){
v_char8 a = findSysChar(caret);
if(a == '?') {
if(curr == nullptr || curr->getData()->function == Part::FUNCTION_ANY_END) {
vars->put(base::String::createShared(part->text.get(), true), label.toString());
tail = base::String::createShared(caret.getCurrData(), size - caret.getPosition(), true);
vars->put(oatpp::String(part->text.get(), true), label.toString());
tail = oatpp::String(caret.getCurrData(), size - caret.getPosition(), true);
return MatchMap::createShared(vars, tail);
}
caret.findChar('/');
}
vars->put(base::String::createShared(part->text.get(), true), label.toString());
vars->put(oatpp::String(part->text.get(), true), label.toString());
}
@ -198,11 +198,11 @@ std::shared_ptr<Pattern::MatchMap> Pattern::match(const char* url){
return match((p_char8) url, (v_int32) std::strlen(url));
}
std::shared_ptr<Pattern::MatchMap> Pattern::match(const base::String::PtrWrapper& url){
std::shared_ptr<Pattern::MatchMap> Pattern::match(const oatpp::String& url){
return match(url->getData(), url->getSize());
}
std::shared_ptr<oatpp::base::String> Pattern::toString() {
oatpp::String Pattern::toString() {
auto stream = oatpp::data::stream::ChunkedBuffer::createShared();
auto curr = m_parts->getFirstNode();
while (curr != nullptr) {

22
web/url/mapping/Pattern.hpp
View File

@ -37,25 +37,25 @@ public:
class MatchMap : public base::Controllable{
public:
typedef oatpp::collection::ListMap<base::String::PtrWrapper, base::String::PtrWrapper> Variables;
typedef oatpp::collection::ListMap<oatpp::String, oatpp::String> Variables;
protected:
MatchMap(const std::shared_ptr<Variables>& vars, const std::shared_ptr<base::String>& urlTail)
MatchMap(const std::shared_ptr<Variables>& vars, const oatpp::String& urlTail)
: variables(vars)
, tail(urlTail)
{}
public:
static std::shared_ptr<MatchMap> createShared(const std::shared_ptr<Variables>& vars,
const std::shared_ptr<base::String>& tail){
const oatpp::String& tail){
return std::shared_ptr<MatchMap>(new MatchMap(vars, tail));
}
const Variables::Entry* getVariable(const base::String::PtrWrapper& key){
const Variables::Entry* getVariable(const oatpp::String& key){
return variables->find(key);
}
const std::shared_ptr<Variables> variables;
const base::String::PtrWrapper tail;
const oatpp::String tail;
};
@ -63,7 +63,7 @@ private:
class Part : public base::Controllable{
protected:
Part(const char* pFunction, const std::shared_ptr<base::String>& pText)
Part(const char* pFunction, const oatpp::String& pText)
: function(pFunction)
, text(pText)
{}
@ -73,12 +73,12 @@ private:
static const char* FUNCTION_VAR;
static const char* FUNCTION_ANY_END;
static std::shared_ptr<Part> createShared(const char* function, const std::shared_ptr<base::String>& text){
static std::shared_ptr<Part> createShared(const char* function, const oatpp::String& text){
return std::shared_ptr<Part>(new Part(function, text));
}
const char* function;
const std::shared_ptr<base::String> text;
const oatpp::String text;
};
@ -98,13 +98,13 @@ public:
static std::shared_ptr<Pattern> parse(p_char8 data, v_int32 size);
static std::shared_ptr<Pattern> parse(const char* data);
static std::shared_ptr<Pattern> parse(const base::String::PtrWrapper& data);
static std::shared_ptr<Pattern> parse(const oatpp::String& data);
std::shared_ptr<MatchMap> match(p_char8 url, v_int32 size);
std::shared_ptr<MatchMap> match(const char* url);
std::shared_ptr<MatchMap> match(const base::String::PtrWrapper& url);
std::shared_ptr<MatchMap> match(const oatpp::String& url);
std::shared_ptr<oatpp::base::String> toString();
oatpp::String toString();
};

6
web/url/mapping/Router.hpp
View File

@ -30,7 +30,7 @@
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/String.hpp"
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/PtrWrapper.hpp"
#include "oatpp/core/base/Controllable.hpp"
@ -108,14 +108,14 @@ public:
return std::shared_ptr<Router>(new Router());
}
void addSubscriber(const base::String::PtrWrapper& urlPattern,
void addSubscriber(const oatpp::String& urlPattern,
const std::shared_ptr<UrlSubscriber>& subscriber){
auto pattern = Pattern::parse(urlPattern);
auto pair = Pair::createShared(pattern, subscriber);
m_subscribers->pushBack(pair);
}
Route getRoute(const base::String::PtrWrapper& url){
Route getRoute(const oatpp::String& url){
auto curr = m_subscribers->getFirstNode();
while(curr != nullptr) {
const std::shared_ptr<Pair>& pair = curr->getData();