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

Merge pull request #50 from oatpp/refactor_controllable

Browse Source 
refactor Controllable, refactor Config directives
This commit is contained in:
Leonid Stryzhevskyi 2019-03-08 01:35:13 +04:00 committed by GitHub
commit 606e055072
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
61 changed files with 278 additions and 272 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/CMakeLists.txt
View File

@ -22,8 +22,8 @@ add_library(oatpp
oatpp/core/base/CommandLineArguments.cpp
oatpp/core/base/CommandLineArguments.hpp
oatpp/core/base/Config.hpp
oatpp/core/base/Controllable.cpp
oatpp/core/base/Controllable.hpp
oatpp/core/base/Countable.cpp
oatpp/core/base/Countable.hpp
oatpp/core/base/Environment.cpp
oatpp/core/base/Environment.hpp
oatpp/core/base/StrBuffer.cpp

8
src/oatpp/codegen/codegen_define_DTO_.hpp
View File

@ -74,11 +74,11 @@ public: \
#define OATPP_MACRO_DTO_FIELD_0(TYPE, NAME, LIST) \
\
oatpp::data::mapping::type::Type::Property* Z__CLASS_FIELD_##NAME = \
Z__CLASS_GET_FIELD_##NAME(static_cast<oatpp::base::Controllable*>(this), \
Z__CLASS_GET_FIELD_##NAME(static_cast<oatpp::base::Countable*>(this), \
(oatpp::data::mapping::type::AbstractObjectWrapper*)(&NAME)); \
\
static oatpp::data::mapping::type::Type::Property* \
Z__CLASS_GET_FIELD_##NAME(oatpp::base::Controllable* _this, \
Z__CLASS_GET_FIELD_##NAME(oatpp::base::Countable* _this, \
oatpp::data::mapping::type::AbstractObjectWrapper* _reg) { \
static oatpp::data::mapping::type::Type::Property* field = \
new oatpp::data::mapping::type::Type::Property(Z__CLASS_GET_FIELDS_MAP(), \
@ -93,11 +93,11 @@ TYPE NAME
#define OATPP_MACRO_DTO_FIELD_1(TYPE, NAME, LIST) \
\
oatpp::data::mapping::type::Type::Property* Z__CLASS_FIELD_##NAME = \
Z__CLASS_GET_FIELD_##NAME(static_cast<oatpp::base::Controllable*>(this), \
Z__CLASS_GET_FIELD_##NAME(static_cast<oatpp::base::Countable*>(this), \
(oatpp::data::mapping::type::AbstractObjectWrapper*)(&NAME)); \
\
static oatpp::data::mapping::type::Type::Property* \
Z__CLASS_GET_FIELD_##NAME(oatpp::base::Controllable* _this, \
Z__CLASS_GET_FIELD_##NAME(oatpp::base::Countable* _this, \
oatpp::data::mapping::type::AbstractObjectWrapper* _reg) { \
static oatpp::data::mapping::type::Type::Property* field = \
new oatpp::data::mapping::type::Type::Property(Z__CLASS_GET_FIELDS_MAP(), \

55
src/oatpp/core/async/Executor.cpp
View File

@ -25,7 +25,14 @@
#include "Executor.hpp"
namespace oatpp { namespace async {
const v_int32 Executor::THREAD_NUM_DEFAULT = OATPP_ASYNC_EXECUTOR_THREAD_NUM_DEFAULT;
Executor::SubmissionProcessor::SubmissionProcessor()
: m_atom(false)
, m_isRunning(true)
{}
void Executor::SubmissionProcessor::consumeTasks() {
oatpp::concurrency::SpinLock lock(m_atom);
auto curr = m_pendingTasks.getFirstNode();
@ -62,5 +69,51 @@ void Executor::SubmissionProcessor::run(){
}
}
void Executor::SubmissionProcessor::stop() {
m_isRunning = false;
}
void Executor::SubmissionProcessor::addTaskSubmission(const std::shared_ptr<TaskSubmission>& task){
oatpp::concurrency::SpinLock lock(m_atom);
m_pendingTasks.pushBack(task);
m_taskCondition.notify_one();
}
Executor::Executor(v_int32 threadsCount)
: m_threadsCount(threadsCount)
, m_threads(new std::shared_ptr<oatpp::concurrency::Thread>[m_threadsCount])
, m_processors(new std::shared_ptr<SubmissionProcessor>[m_threadsCount])
{
for(v_int32 i = 0; i < m_threadsCount; i ++) {
auto processor = std::make_shared<SubmissionProcessor>();
m_processors[i] = processor;
m_threads[i] = oatpp::concurrency::Thread::createShared(processor);
}
}
Executor::~Executor() {
delete [] m_processors;
delete [] m_threads;
}
void Executor::join() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_threads[i]->join();
}
}
void Executor::detach() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_threads[i]->detach();
}
}
void Executor::stop() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_processors[i]->stop();
}
}
}}

56
src/oatpp/core/async/Executor.hpp
View File

@ -96,26 +96,17 @@ private:
std::mutex m_taskMutex;
std::condition_variable m_taskCondition;
public:
SubmissionProcessor()
: m_atom(false)
, m_isRunning(true)
{}
SubmissionProcessor();
public:
void run() override;
void stop() {
m_isRunning = false;
}
void addTaskSubmission(const std::shared_ptr<TaskSubmission>& task){
oatpp::concurrency::SpinLock lock(m_atom);
m_pendingTasks.pushBack(task);
m_taskCondition.notify_one();
}
void stop();
void addTaskSubmission(const std::shared_ptr<TaskSubmission>& task);
};
public:
static const v_int32 THREAD_NUM_DEFAULT;
private:
v_int32 m_threadsCount;
std::shared_ptr<oatpp::concurrency::Thread>* m_threads;
@ -123,40 +114,15 @@ private:
std::atomic<v_word32> m_balancer;
public:
Executor(v_int32 threadsCount = OATPP_ASYNC_EXECUTOR_THREAD_NUM_DEFAULT)
: m_threadsCount(threadsCount)
, m_threads(new std::shared_ptr<oatpp::concurrency::Thread>[m_threadsCount])
, m_processors(new std::shared_ptr<SubmissionProcessor>[m_threadsCount])
{
for(v_int32 i = 0; i < m_threadsCount; i ++) {
auto processor = std::make_shared<SubmissionProcessor>();
m_processors[i] = processor;
m_threads[i] = oatpp::concurrency::Thread::createShared(processor);
}
}
Executor(v_int32 threadsCount = THREAD_NUM_DEFAULT);
~Executor() {
delete [] m_processors;
delete [] m_threads;
}
~Executor();
void join() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_threads[i]->join();
}
}
void join();
void detach() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_threads[i]->detach();
}
}
void detach();
void stop() {
for(v_int32 i = 0; i < m_threadsCount; i ++) {
m_processors[i]->stop();
}
}
void stop();
template<typename CoroutineType, typename ... Args>
void execute(Args... params) {

2
src/oatpp/core/base/Config.hpp
View File

@ -31,7 +31,7 @@
#define oatpp_base_Config_hpp
/**
* If NOT DISABLED, counting of all object of class oatpp::base::Controllable is enabled
* If NOT DISABLED, counting of all object of class oatpp::base::Countable is enabled
* for debug purposes and detection of memory leaks.
* Disable object counting for Release builds using '-D OATPP_DISABLE_ENV_OBJECT_COUNTERS' flag for better performance
*/

9
src/oatpp/core/base/Controllable.cpp → src/oatpp/core/base/Countable.cpp
View File

@ -22,20 +22,17 @@
*
***************************************************************************/
#include "Controllable.hpp"
#include "Controllable.hpp"
#include "Countable.hpp"
namespace oatpp { namespace base{
const char* Controllable::TAG = "Controllable";
Controllable::Controllable() {
Countable::Countable() {
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
Environment::incObjects();
#endif
}
Controllable::~Controllable(){
Countable::~Countable(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
Environment::decObjects();
#endif

24
src/oatpp/core/base/Controllable.hpp → src/oatpp/core/base/Countable.hpp
View File

@ -22,32 +22,20 @@
*
***************************************************************************/
#ifndef oatpp_base_Controllable
#define oatpp_base_Controllable
#ifndef oatpp_base_Countable
#define oatpp_base_Countable
#include <memory>
#include "./Environment.hpp"
namespace oatpp { namespace base{
class Controllable : public std::enable_shared_from_this<Controllable> {
private:
static const char* TAG;
class Countable {
public:
template<class T>
std::shared_ptr<T> getSharedPtr() {
return std::static_pointer_cast<T>(shared_from_this());
}
public:
Controllable();
virtual ~Controllable();
static std::shared_ptr<Controllable> createShared(){
return std::make_shared<Controllable>();
}
Countable();
virtual ~Countable();
};
}}
#endif /* oatpp_base_Controllable */
#endif /* oatpp_base_Countable */

28
src/oatpp/core/base/Environment.cpp
View File

@ -31,22 +31,20 @@ namespace oatpp { namespace base {
Logger* Environment::m_logger = nullptr;
std::unordered_map<std::string, std::unordered_map<std::string, void*>> Environment::m_components;
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
v_atomicCounter Environment::m_objectsCount(0);
v_atomicCounter Environment::m_objectsCreated(0);
thread_local v_counter Environment::m_threadLocalObjectsCount = 0;
thread_local v_counter Environment::m_threadLocalObjectsCreated = 0;
#endif
void Environment::init(){
checkTypes();
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
m_objectsCount = 0;
m_objectsCreated = 0;
m_threadLocalObjectsCount = 0;
m_threadLocalObjectsCreated = 0;
#endif
if(m_components.size() > 0) {
throw std::runtime_error("[oatpp::base::Environment]: Invalid state. Components were created before call to Environment::init()");
}
@ -82,51 +80,31 @@ void Environment::checkTypes(){
}
void Environment::incObjects(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
m_objectsCount ++;
m_objectsCreated ++;
m_threadLocalObjectsCount ++;
m_threadLocalObjectsCreated ++;
#endif
}
void Environment::decObjects(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
m_objectsCount --;
m_threadLocalObjectsCount --;
#endif
}
v_counter Environment::getObjectsCount(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
return m_objectsCount;
#else
return 0;
#endif
}
v_counter Environment::getObjectsCreated(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
return m_objectsCreated;
#else
return 0;
#endif
}
v_counter Environment::getThreadLocalObjectsCount(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
return m_threadLocalObjectsCount;
#else
return 0;
#endif
}
v_counter Environment::getThreadLocalObjectsCreated(){
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
return m_threadLocalObjectsCreated;
#else
return 0;
#endif
}
void Environment::setLogger(Logger* logger){

4
src/oatpp/core/base/Environment.hpp
View File

@ -78,16 +78,12 @@ public:
virtual void log(v_int32 priority, const std::string& tag, const std::string& message) = 0;
};
//#define OATPP_DISABLE_ENV_OBJECT_COUNTERS
class Environment{
private:
#ifndef OATPP_DISABLE_ENV_OBJECT_COUNTERS
static v_atomicCounter m_objectsCount;
static v_atomicCounter m_objectsCreated;
static thread_local v_counter m_threadLocalObjectsCount;
static thread_local v_counter m_threadLocalObjectsCreated;
#endif
private:
static Logger* m_logger;
static void checkTypes();

4
src/oatpp/core/base/StrBuffer.hpp
View File

@ -26,13 +26,13 @@
#define oatpp_base_StrBuffer_hpp
#include "memory/ObjectPool.hpp"
#include "./Controllable.hpp"
#include "./Countable.hpp"
#include <cstring> // c
namespace oatpp { namespace base {
class StrBuffer : public oatpp::base::Controllable {
class StrBuffer : public oatpp::base::Countable {
private:
static constexpr v_int32 SM_STRING_POOL_ENTRY_SIZE = 256;

6
src/oatpp/core/base/memory/MemoryPool.cpp
View File

@ -125,12 +125,12 @@ v_int64 MemoryPool::getSize(){
v_int32 MemoryPool::getObjectsCount(){
return m_objectsCount;
}
oatpp::concurrency::SpinLock::Atom MemoryPool::POOLS_ATOM(false);
std::unordered_map<v_int64, MemoryPool*> MemoryPool::POOLS;
std::atomic<v_int64> MemoryPool::poolIdCounter(0);
const v_int32 ThreadDistributedMemoryPool::SHARDS_COUNT_DEFAULT = OATPP_THREAD_DISTRIBUTED_MEM_POOL_SHARDS_COUNT;
ThreadDistributedMemoryPool::ThreadDistributedMemoryPool(const std::string& name, v_int32 entrySize, v_int32 chunkSize, v_int32 shardsCount)
: m_shardsCount(shardsCount)

5
src/oatpp/core/base/memory/MemoryPool.hpp
View File

@ -32,7 +32,6 @@
#include <list>
#include <unordered_map>
#include <cstring>
//#define OATPP_DISABLE_POOL_ALLOCATIONS
namespace oatpp { namespace base { namespace memory {
@ -114,9 +113,11 @@ class ThreadDistributedMemoryPool {
private:
v_int32 m_shardsCount;
MemoryPool** m_shards;
public:
static const v_int32 SHARDS_COUNT_DEFAULT;
public:
ThreadDistributedMemoryPool(const std::string& name, v_int32 entrySize, v_int32 chunkSize,
v_int32 shardsCount = OATPP_THREAD_DISTRIBUTED_MEM_POOL_SHARDS_COUNT);
v_int32 shardsCount = SHARDS_COUNT_DEFAULT);
virtual ~ThreadDistributedMemoryPool();
void* obtain();
};

6
src/oatpp/core/collection/LinkedList.hpp
View File

@ -28,13 +28,13 @@
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include "oatpp/core/base/Environment.hpp"
namespace oatpp { namespace collection {
template<class T>
class LinkedList : public base::Controllable {
class LinkedList : public base::Countable {
public:
OBJECT_POOL(LinkedList_Pool, LinkedList, 32)
SHARED_OBJECT_POOL(Shared_LinkedList_Pool, LinkedList, 32)
@ -177,7 +177,7 @@ public:
}
void insertAfterNode(const T& data, LinkedListNode* currentNode){
LinkedListNode* node = new LinkedListNode(data, currentNode->next);
LinkedListNode* node = createNode(data, currentNode->next);
currentNode->next = node;
if(currentNode == m_last){
m_last = node;

4
src/oatpp/core/collection/ListMap.hpp
View File

@ -26,12 +26,12 @@
#define oatpp_collection_ListMap_hpp
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
namespace oatpp { namespace collection {
template<class K, class V>
class ListMap : public oatpp::base::Controllable {
class ListMap : public oatpp::base::Countable {
public:
OBJECT_POOL(ListMap_Pool, ListMap, 32)
SHARED_OBJECT_POOL(Shared_ListMap_Pool, ListMap, 32)

4
src/oatpp/core/concurrency/Thread.hpp
View File

@ -28,13 +28,13 @@
#include "./Runnable.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include <thread>
namespace oatpp { namespace concurrency {
class Thread : public base::Controllable {
class Thread : public base::Countable {
public:
OBJECT_POOL(Thread_Pool, Thread, 32)
SHARED_OBJECT_POOL(Shared_Thread_Pool, Thread, 32)

4
src/oatpp/core/data/buffer/IOBuffer.hpp
View File

@ -26,12 +26,12 @@
#define oatpp_data_buffer_IOBuffer_hpp
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
namespace oatpp { namespace data{ namespace buffer {
class IOBuffer : public oatpp::base::Controllable {
class IOBuffer : public oatpp::base::Countable {
public:
OBJECT_POOL(IOBuffer_Pool, IOBuffer, 32)
SHARED_OBJECT_POOL(Shared_IOBuffer_Pool, IOBuffer, 32)

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

@ -30,7 +30,7 @@
#include "oatpp/core/collection/LinkedList.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {

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

@ -32,7 +32,7 @@
#include "./List.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
namespace oatpp { namespace data { namespace mapping { namespace type {
@ -56,7 +56,7 @@ namespace __class {
}
class Object : public oatpp::base::Controllable {
class Object : public oatpp::base::Countable {
public:
typedef oatpp::data::mapping::type::String String;
typedef oatpp::data::mapping::type::Int8 Int8;

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

@ -28,7 +28,7 @@
#include "./Type.hpp"
#include "oatpp/core/base/memory/ObjectPool.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include "oatpp/core/base/StrBuffer.hpp"
@ -126,7 +126,7 @@ String operator + (const String& b, const char* a);
String operator + (const String& a, const String& b);
template<typename ValueType, class Clazz>
class Primitive : public oatpp::base::Controllable {
class Primitive : public oatpp::base::Countable {
public:
OBJECT_POOL(Primitive_Type_Pool, Primitive, 32)
SHARED_OBJECT_POOL(Shared_Primitive_Type_Pool, Primitive, 32)
@ -214,8 +214,8 @@ public:
return Shared_Primitive_Type_Pool::allocateShared(value);
}
static std::shared_ptr<Controllable> createAbstract(const ValueType& value){
return std::static_pointer_cast<Controllable>(Shared_Primitive_Type_Pool::allocateShared(value));
static std::shared_ptr<Countable> createAbstract(const ValueType& value){
return std::static_pointer_cast<Countable>(Shared_Primitive_Type_Pool::allocateShared(value));
}
void setValue(const ValueType& value) {
@ -379,4 +379,4 @@ namespace std {
};
}
#endif /* oatpp_base_controllable_PrimitiveDataTypes_hpp */
#endif /* oatpp_base_Countable_PrimitiveDataTypes_hpp */

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

@ -25,7 +25,7 @@
#ifndef oatpp_data_type_Type_hpp
#define oatpp_data_type_Type_hpp
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include <list>
#include <unordered_map>
@ -102,8 +102,8 @@ public:
return *this;
}
inline operator PolymorphicWrapper<oatpp::base::Controllable>() const {
return PolymorphicWrapper<oatpp::base::Controllable>(this->m_ptr, valueType);
inline operator PolymorphicWrapper<oatpp::base::Countable>() const {
return PolymorphicWrapper<oatpp::base::Countable>(this->m_ptr, valueType);
}
T* operator->() const {
@ -203,7 +203,7 @@ public:
};
typedef PolymorphicWrapper<oatpp::base::Controllable> AbstractObjectWrapper;
typedef PolymorphicWrapper<oatpp::base::Countable> AbstractObjectWrapper;
class Type {
public:

2
src/oatpp/core/data/stream/ChunkedBuffer.cpp
View File

@ -267,7 +267,7 @@ oatpp::async::Action ChunkedBuffer::flushToStreamAsync(oatpp::async::AbstractCor
};
return parentCoroutine->startCoroutine<FlushCoroutine>(actionOnFinish,
getSharedPtr<ChunkedBuffer>(),
shared_from_this(),
stream);
}

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

@ -32,7 +32,7 @@
namespace oatpp { namespace data{ namespace stream {
class ChunkedBuffer : public oatpp::base::Controllable, public OutputStream {
class ChunkedBuffer : public oatpp::base::Countable, public OutputStream, public std::enable_shared_from_this<ChunkedBuffer> {
public:
static const char* ERROR_ASYNC_FAILED_TO_WRITE_ALL_DATA;
public:
@ -75,7 +75,7 @@ private:
public:
class Chunk : public oatpp::base::Controllable {
class Chunk : public oatpp::base::Countable {
public:
OBJECT_POOL(ChunkedBuffer_Chunk_Pool, Chunk, 32)
SHARED_OBJECT_POOL(Shared_ChunkedBuffer_Chunk_Pool, Chunk, 32)

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

@ -95,7 +95,7 @@ public:
typedef data::v_io_size v_size;
};
class CompoundIOStream : public oatpp::base::Controllable, public IOStream {
class CompoundIOStream : public oatpp::base::Countable, public IOStream {
public:
OBJECT_POOL(CompoundIOStream_Pool, CompoundIOStream, 32);
SHARED_OBJECT_POOL(Shared_CompoundIOStream_Pool, CompoundIOStream, 32);

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

@ -32,7 +32,7 @@
namespace oatpp { namespace data{ namespace stream {
class OutputStreamBufferedProxy : public oatpp::base::Controllable, public OutputStream {
class OutputStreamBufferedProxy : public oatpp::base::Countable, public OutputStream {
public:
OBJECT_POOL(OutputStreamBufferedProxy_Pool, OutputStreamBufferedProxy, 32)
SHARED_OBJECT_POOL(Shared_OutputStreamBufferedProxy_Pool, OutputStreamBufferedProxy, 32)
@ -83,7 +83,7 @@ public:
};
class InputStreamBufferedProxy : public oatpp::base::Controllable, public InputStream {
class InputStreamBufferedProxy : public oatpp::base::Countable, public InputStream {
public:
OBJECT_POOL(InputStreamBufferedProxy_Pool, InputStreamBufferedProxy, 32)
SHARED_OBJECT_POOL(Shared_InputStreamBufferedProxy_Pool, InputStreamBufferedProxy, 32)

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

@ -29,7 +29,7 @@
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include "oatpp/core/base/Environment.hpp"
#include <string>

2
src/oatpp/network/Connection.hpp
View File

@ -30,7 +30,7 @@
namespace oatpp { namespace network {
class Connection : public oatpp::base::Controllable, public oatpp::data::stream::IOStream {
class Connection : public oatpp::base::Countable, public oatpp::data::stream::IOStream {
public:
OBJECT_POOL(Connection_Pool, Connection, 32);
SHARED_OBJECT_POOL(Shared_Connection_Pool, Connection, 32);

2
src/oatpp/network/Url.hpp
View File

@ -36,7 +36,7 @@ namespace oatpp { namespace network {
// TODO - refactor to use oatpp::data::share::MemoryLabel
class Url : public oatpp::base::Controllable {
class Url : public oatpp::base::Countable {
public:
typedef oatpp::data::share::StringKeyLabel StringKeyLabel;
public:

2
src/oatpp/network/client/SimpleTCPConnectionProvider.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace network { namespace client {
class SimpleTCPConnectionProvider : public base::Controllable, public ClientConnectionProvider {
class SimpleTCPConnectionProvider : public base::Countable, public ClientConnectionProvider {
protected:
oatpp::String m_host;
v_word16 m_port;

4
src/oatpp/network/server/Server.hpp
View File

@ -33,14 +33,14 @@
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include "oatpp/core/base/Environment.hpp"
#include <atomic>
namespace oatpp { namespace network { namespace server {
class Server : public base::Controllable, public concurrency::Runnable{
class Server : public base::Countable, public concurrency::Runnable{
private:
void mainLoop();

2
src/oatpp/network/server/SimpleTCPConnectionProvider.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace network { namespace server {
class SimpleTCPConnectionProvider : public base::Controllable, public ServerConnectionProvider {
class SimpleTCPConnectionProvider : public base::Countable, public ServerConnectionProvider {
private:
v_word16 m_port;
bool m_nonBlocking;

2
src/oatpp/network/virtual_/Interface.hpp
View File

@ -31,7 +31,7 @@
namespace oatpp { namespace network { namespace virtual_ {
class Interface : public oatpp::base::Controllable {
class Interface : public oatpp::base::Countable {
public:
class ConnectionSubmission {

2
src/oatpp/network/virtual_/Pipe.hpp
View File

@ -37,7 +37,7 @@
namespace oatpp { namespace network { namespace virtual_ {
class Pipe : public oatpp::base::Controllable {
class Pipe : public oatpp::base::Countable {
public:
class Reader : public oatpp::data::stream::InputStream {

2
src/oatpp/network/virtual_/Socket.hpp
View File

@ -29,7 +29,7 @@
namespace oatpp { namespace network { namespace virtual_ {
class Socket : public oatpp::base::Controllable, public oatpp::data::stream::IOStream {
class Socket : public oatpp::base::Countable, public oatpp::data::stream::IOStream {
private:
std::shared_ptr<Pipe> m_pipeIn;
std::shared_ptr<Pipe> m_pipeOut;

2
src/oatpp/parser/json/mapping/Deserializer.hpp
View File

@ -59,7 +59,7 @@ private:
public:
class Config : public oatpp::base::Controllable {
class Config : public oatpp::base::Countable {
public:
Config()
{}

2
src/oatpp/parser/json/mapping/ObjectMapper.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace parser { namespace json { namespace mapping {
class ObjectMapper : public oatpp::base::Controllable, public oatpp::data::mapping::ObjectMapper {
class ObjectMapper : public oatpp::base::Countable, public oatpp::data::mapping::ObjectMapper {
private:
static Info& getMapperInfo() {
static Info info("application/json");

2
src/oatpp/parser/json/mapping/Serializer.hpp
View File

@ -57,7 +57,7 @@ public:
public:
class Config : public oatpp::base::Controllable {
class Config : public oatpp::base::Countable {
public:
Config()
{}

4
src/oatpp/web/client/ApiClient.hpp
View File

@ -42,7 +42,7 @@
#include "oatpp/core/utils/ConversionUtils.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include <string>
@ -51,7 +51,7 @@
namespace oatpp { namespace web { namespace client {
class ApiClient : public oatpp::base::Controllable {
class ApiClient : public oatpp::base::Countable {
public:
static constexpr const char* const TAG = "Client";
protected:

2
src/oatpp/web/client/HttpRequestExecutor.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace web { namespace client {
class HttpRequestExecutor : public oatpp::base::Controllable, public RequestExecutor {
class HttpRequestExecutor : public oatpp::base::Countable, public RequestExecutor {
private:
typedef oatpp::web::protocol::http::Header Header;
protected:

2
src/oatpp/web/protocol/http/incoming/Request.hpp
View File

@ -35,7 +35,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
/**
* Class http::incoming::Request AKA IncomingRequest represents client's incoming request
*/
class Request : public oatpp::base::Controllable {
class Request : public oatpp::base::Countable {
public:
OBJECT_POOL(Incoming_Request_Pool, Request, 32)
SHARED_OBJECT_POOL(Shared_Incoming_Request_Pool, Request, 32)

2
src/oatpp/web/protocol/http/incoming/Response.hpp
View File

@ -33,7 +33,7 @@ namespace oatpp { namespace web { namespace protocol { namespace http { namespac
/**
* Class http::incoming::Response AKA IncomingResponse represents server's incoming response
*/
class Response : public oatpp::base::Controllable {
class Response : public oatpp::base::Countable {
public:
OBJECT_POOL(Incoming_Response_Pool, Response, 32)
SHARED_OBJECT_POOL(Shared_Incoming_Response_Pool, Response, 32)

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

@ -58,7 +58,7 @@ void BufferBody::writeToStream(const std::shared_ptr<OutputStream>& stream) noex
async::Action BufferBody::writeToStreamAsync(oatpp::async::AbstractCoroutine* parentCoroutine,
const Action& actionOnReturn,
const std::shared_ptr<OutputStream>& stream) {
return parentCoroutine->startCoroutine<WriteToStreamCoroutine>(actionOnReturn, getSharedPtr<BufferBody>(), stream);
return parentCoroutine->startCoroutine<WriteToStreamCoroutine>(actionOnReturn, shared_from_this(), stream);
}
}}}}}

2
src/oatpp/web/protocol/http/outgoing/BufferBody.hpp
View File

@ -31,7 +31,7 @@
namespace oatpp { namespace web { namespace protocol { namespace http { namespace outgoing {
class BufferBody : public oatpp::base::Controllable, public Body {
class BufferBody : public oatpp::base::Countable, public Body, public std::enable_shared_from_this<BufferBody> {
public:
OBJECT_POOL(Http_Outgoing_BufferBody_Pool, BufferBody, 32)
SHARED_OBJECT_POOL(Shared_Http_Outgoing_BufferBody_Pool, BufferBody, 32)

2
src/oatpp/web/protocol/http/outgoing/ChunkedBufferBody.cpp
View File

@ -122,7 +122,7 @@ async::Action ChunkedBufferBody::writeToStreamAsync(oatpp::async::AbstractCorout
const Action& actionOnFinish,
const std::shared_ptr<OutputStream>& stream) {
if(m_chunked) {
return parentCoroutine->startCoroutine<WriteToStreamCoroutine>(actionOnFinish, getSharedPtr<ChunkedBufferBody>(), stream);
return parentCoroutine->startCoroutine<WriteToStreamCoroutine>(actionOnFinish, shared_from_this(), stream);
} else {
return m_buffer->flushToStreamAsync(parentCoroutine, actionOnFinish, stream);
}

2
src/oatpp/web/protocol/http/outgoing/ChunkedBufferBody.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace web { namespace protocol { namespace http { namespace outgoing {
class ChunkedBufferBody : public oatpp::base::Controllable, public Body {
class ChunkedBufferBody : public oatpp::base::Countable, public Body, public std::enable_shared_from_this<ChunkedBufferBody> {
public:
static const char* ERROR_FAILED_TO_WRITE_DATA;
public:

2
src/oatpp/web/protocol/http/outgoing/Request.cpp
View File

@ -167,7 +167,7 @@ oatpp::async::Action Request::sendAsync(oatpp::async::AbstractCoroutine* parentC
};
return parentCoroutine->startCoroutine<SendAsyncCoroutine>(actionOnFinish, getSharedPtr<Request>(), stream);
return parentCoroutine->startCoroutine<SendAsyncCoroutine>(actionOnFinish, shared_from_this(), stream);
}

2
src/oatpp/web/protocol/http/outgoing/Request.hpp
View File

@ -30,7 +30,7 @@
namespace oatpp { namespace web { namespace protocol { namespace http { namespace outgoing {
class Request : public oatpp::base::Controllable {
class Request : public oatpp::base::Countable, public std::enable_shared_from_this<Request> {
public:
typedef protocol::http::Protocol::Headers Headers;
public:

2
src/oatpp/web/protocol/http/outgoing/Response.cpp
View File

@ -158,7 +158,7 @@ oatpp::async::Action Response::sendAsync(oatpp::async::AbstractCoroutine* parent
};
return parentCoroutine->startCoroutine<SendAsyncCoroutine>(actionOnFinish, getSharedPtr<Response>(), stream);
return parentCoroutine->startCoroutine<SendAsyncCoroutine>(actionOnFinish, shared_from_this(), stream);
}

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

@ -32,7 +32,7 @@
namespace oatpp { namespace web { namespace protocol { namespace http { namespace outgoing {
class Response : public oatpp::base::Controllable {
class Response : public oatpp::base::Countable, public std::enable_shared_from_this<Response> {
public:
typedef http::Protocol::Headers Headers;
public:

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

@ -24,17 +24,47 @@
#include "./AsyncHttpConnectionHandler.hpp"
#include "oatpp/web/protocol/http/outgoing/ChunkedBufferBody.hpp"
#include "oatpp/web/protocol/http/incoming/Request.hpp"
#include "oatpp/web/protocol/http/Http.hpp"
#include "oatpp/network/Connection.hpp"
#include <errno.h>
namespace oatpp { namespace web { namespace server {
const v_int32 AsyncHttpConnectionHandler::THREAD_NUM_DEFAULT = OATPP_ASYNC_EXECUTOR_THREAD_NUM_DEFAULT;
AsyncHttpConnectionHandler::AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router,
v_int32 threadCount)
: m_executor(std::make_shared<oatpp::async::Executor>(threadCount))
, m_router(router)
, m_errorHandler(handler::DefaultErrorHandler::createShared())
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
{
m_executor->detach();
}
AsyncHttpConnectionHandler::AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router,
const std::shared_ptr<oatpp::async::Executor>& executor)
: m_executor(executor)
, m_router(router)
, m_errorHandler(handler::DefaultErrorHandler::createShared())
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
{}
std::shared_ptr<AsyncHttpConnectionHandler> AsyncHttpConnectionHandler::createShared(const std::shared_ptr<HttpRouter>& router, v_int32 threadCount){
return std::make_shared<AsyncHttpConnectionHandler>(router, threadCount);
}
std::shared_ptr<AsyncHttpConnectionHandler> AsyncHttpConnectionHandler::createShared(const std::shared_ptr<HttpRouter>& router, const std::shared_ptr<oatpp::async::Executor>& executor){
return std::make_shared<AsyncHttpConnectionHandler>(router, executor);
}
void AsyncHttpConnectionHandler::setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler){
m_errorHandler = errorHandler;
if(!m_errorHandler) {
m_errorHandler = handler::DefaultErrorHandler::createShared();
}
}
void AsyncHttpConnectionHandler::addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor) {
m_requestInterceptors.pushBack(interceptor);
}
void AsyncHttpConnectionHandler::handleConnection(const std::shared_ptr<oatpp::data::stream::IOStream>& connection){
auto ioBuffer = oatpp::data::buffer::IOBuffer::createShared();
@ -51,6 +81,10 @@ void AsyncHttpConnectionHandler::handleConnection(const std::shared_ptr<oatpp::d
inStream);
}
void AsyncHttpConnectionHandler::stop() {
m_executor->stop();
}
}}}

63
src/oatpp/web/server/AsyncHttpConnectionHandler.hpp
View File

@ -25,24 +25,23 @@
#ifndef oatpp_web_server_AsyncHttpConnectionHandler_hpp
#define oatpp_web_server_AsyncHttpConnectionHandler_hpp
#include "./HttpProcessor.hpp"
#include "./handler/ErrorHandler.hpp"
#include "./HttpRouter.hpp"
#include "oatpp/web/server/HttpProcessor.hpp"
#include "oatpp/web/server/HttpRouter.hpp"
#include "oatpp/web/server/handler/ErrorHandler.hpp"
#include "oatpp/web/server/handler/Interceptor.hpp"
#include "oatpp/web/protocol/http/incoming/SimpleBodyDecoder.hpp"
#include "oatpp/network/server/ConnectionHandler.hpp"
#include "oatpp/network/Connection.hpp"
#include "oatpp/core/data/stream/StreamBufferedProxy.hpp"
#include "oatpp/core/data/buffer/IOBuffer.hpp"
#include "oatpp/core/async/Executor.hpp"
namespace oatpp { namespace web { namespace server {
class AsyncHttpConnectionHandler : public base::Controllable, public network::server::ConnectionHandler {
class AsyncHttpConnectionHandler : public base::Countable, public network::server::ConnectionHandler {
private:
typedef oatpp::web::protocol::http::incoming::BodyDecoder BodyDecoder;
public:
static const v_int32 THREAD_NUM_DEFAULT;
private:
std::shared_ptr<oatpp::async::Executor> m_executor;
private:
@ -51,52 +50,26 @@ private:
HttpProcessor::RequestInterceptors m_requestInterceptors;
std::shared_ptr<const BodyDecoder> m_bodyDecoder; // TODO make bodyDecoder configurable here
public:
AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router,
v_int32 threadCount = OATPP_ASYNC_EXECUTOR_THREAD_NUM_DEFAULT)
: m_executor(std::make_shared<oatpp::async::Executor>(threadCount))
, m_router(router)
, m_errorHandler(handler::DefaultErrorHandler::createShared())
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
{
m_executor->detach();
}
AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router,
const std::shared_ptr<oatpp::async::Executor>& executor)
: m_executor(executor)
, m_router(router)
, m_errorHandler(handler::DefaultErrorHandler::createShared())
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
{}
AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router, v_int32 threadCount = THREAD_NUM_DEFAULT);
AsyncHttpConnectionHandler(const std::shared_ptr<HttpRouter>& router, const std::shared_ptr<oatpp::async::Executor>& executor);
public:
static std::shared_ptr<AsyncHttpConnectionHandler> createShared(const std::shared_ptr<HttpRouter>& router,
v_int32 threadCount = OATPP_ASYNC_EXECUTOR_THREAD_NUM_DEFAULT){
return std::make_shared<AsyncHttpConnectionHandler>(router, threadCount);
}
v_int32 threadCount = THREAD_NUM_DEFAULT);
static std::shared_ptr<AsyncHttpConnectionHandler> createShared(const std::shared_ptr<HttpRouter>& router,
const std::shared_ptr<oatpp::async::Executor>& executor){
return std::make_shared<AsyncHttpConnectionHandler>(router, executor);
}
const std::shared_ptr<oatpp::async::Executor>& executor);
void setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler){
m_errorHandler = errorHandler;
if(!m_errorHandler) {
m_errorHandler = handler::DefaultErrorHandler::createShared();
}
}
void setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler);
void addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor) {
m_requestInterceptors.pushBack(interceptor);
}
void addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor);
void handleConnection(const std::shared_ptr<oatpp::data::stream::IOStream>& connection) override;
void stop() override {
m_executor->stop();
}
/**
* Will call m_executor.stop()
*/
void stop() override;
};

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

@ -30,7 +30,28 @@
#include "oatpp/web/protocol/http/Http.hpp"
namespace oatpp { namespace web { namespace server {
HttpConnectionHandler::Task::Task(HttpRouter* router,
const std::shared_ptr<oatpp::data::stream::IOStream>& connection,
const std::shared_ptr<const oatpp::web::protocol::http::incoming::BodyDecoder>& bodyDecoder,
const std::shared_ptr<handler::ErrorHandler>& errorHandler,
HttpProcessor::RequestInterceptors* requestInterceptors)
: m_router(router)
, m_connection(connection)
, m_bodyDecoder(bodyDecoder)
, m_errorHandler(errorHandler)
, m_requestInterceptors(requestInterceptors)
{}
std::shared_ptr<HttpConnectionHandler::Task>
HttpConnectionHandler::Task::createShared(HttpRouter* router,
const std::shared_ptr<oatpp::data::stream::IOStream>& connection,
const std::shared_ptr<const oatpp::web::protocol::http::incoming::BodyDecoder>& bodyDecoder,
const std::shared_ptr<handler::ErrorHandler>& errorHandler,
HttpProcessor::RequestInterceptors* requestInterceptors) {
return std::make_shared<Task>(router, connection, bodyDecoder, errorHandler, requestInterceptors);
}
void HttpConnectionHandler::Task::run(){
v_int32 bufferSize = oatpp::data::buffer::IOBuffer::BUFFER_SIZE;
@ -65,6 +86,27 @@ void HttpConnectionHandler::Task::run(){
}
}
HttpConnectionHandler::HttpConnectionHandler(const std::shared_ptr<HttpRouter>& router)
: m_router(router)
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
, m_errorHandler(handler::DefaultErrorHandler::createShared())
{}
std::shared_ptr<HttpConnectionHandler> HttpConnectionHandler::createShared(const std::shared_ptr<HttpRouter>& router){
return std::make_shared<HttpConnectionHandler>(router);
}
void HttpConnectionHandler::setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler){
m_errorHandler = errorHandler;
if(!m_errorHandler) {
m_errorHandler = handler::DefaultErrorHandler::createShared();
}
}
void HttpConnectionHandler::addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor) {
m_requestInterceptors.pushBack(interceptor);
}
void HttpConnectionHandler::handleConnection(const std::shared_ptr<oatpp::data::stream::IOStream>& connection){
@ -83,4 +125,8 @@ void HttpConnectionHandler::handleConnection(const std::shared_ptr<oatpp::data::
thread.detach();
}
void HttpConnectionHandler::stop() {
// DO NOTHING
}
}}}

46
src/oatpp/web/server/HttpConnectionHandler.hpp
View File

@ -42,10 +42,10 @@
namespace oatpp { namespace web { namespace server {
class HttpConnectionHandler : public base::Controllable, public network::server::ConnectionHandler {
class HttpConnectionHandler : public base::Countable, public network::server::ConnectionHandler {
private:
class Task : public base::Controllable, public concurrency::Runnable{
class Task : public base::Countable, public concurrency::Runnable{
private:
HttpRouter* m_router;
std::shared_ptr<oatpp::data::stream::IOStream> m_connection;
@ -57,22 +57,14 @@ private:
const std::shared_ptr<oatpp::data::stream::IOStream>& connection,
const std::shared_ptr<const oatpp::web::protocol::http::incoming::BodyDecoder>& bodyDecoder,
const std::shared_ptr<handler::ErrorHandler>& errorHandler,
HttpProcessor::RequestInterceptors* requestInterceptors)
: m_router(router)
, m_connection(connection)
, m_bodyDecoder(bodyDecoder)
, m_errorHandler(errorHandler)
, m_requestInterceptors(requestInterceptors)
{}
HttpProcessor::RequestInterceptors* requestInterceptors);
public:
static std::shared_ptr<Task> createShared(HttpRouter* router,
const std::shared_ptr<oatpp::data::stream::IOStream>& connection,
const std::shared_ptr<const oatpp::web::protocol::http::incoming::BodyDecoder>& bodyDecoder,
const std::shared_ptr<handler::ErrorHandler>& errorHandler,
HttpProcessor::RequestInterceptors* requestInterceptors) {
return std::make_shared<Task>(router, connection, bodyDecoder, errorHandler, requestInterceptors);
}
HttpProcessor::RequestInterceptors* requestInterceptors);
void run() override;
@ -84,33 +76,15 @@ private:
std::shared_ptr<handler::ErrorHandler> m_errorHandler;
HttpProcessor::RequestInterceptors m_requestInterceptors;
public:
HttpConnectionHandler(const std::shared_ptr<HttpRouter>& router)
: m_router(router)
, m_bodyDecoder(std::make_shared<oatpp::web::protocol::http::incoming::SimpleBodyDecoder>())
, m_errorHandler(handler::DefaultErrorHandler::createShared())
{}
HttpConnectionHandler(const std::shared_ptr<HttpRouter>& router);
public:
static std::shared_ptr<HttpConnectionHandler> createShared(const std::shared_ptr<HttpRouter>& router){
return std::make_shared<HttpConnectionHandler>(router);
}
void setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler){
m_errorHandler = errorHandler;
if(!m_errorHandler) {
m_errorHandler = handler::DefaultErrorHandler::createShared();
}
}
void addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor) {
m_requestInterceptors.pushBack(interceptor);
}
void handleConnection(const std::shared_ptr<oatpp::data::stream::IOStream>& connection) override;
static std::shared_ptr<HttpConnectionHandler> createShared(const std::shared_ptr<HttpRouter>& router);
void stop() override {
// DO NOTHING
}
void setErrorHandler(const std::shared_ptr<handler::ErrorHandler>& errorHandler);
void addRequestInterceptor(const std::shared_ptr<handler::RequestInterceptor>& interceptor);
void handleConnection(const std::shared_ptr<oatpp::data::stream::IOStream>& connection) override;
void stop() override;
};

2
src/oatpp/web/server/HttpRouter.hpp
View File

@ -32,7 +32,7 @@
namespace oatpp { namespace web { namespace server {
class HttpRouter : public oatpp::base::Controllable {
class HttpRouter : public oatpp::base::Countable {
private:
typedef oatpp::data::share::StringKeyLabel StringKeyLabel;
public:

4
src/oatpp/web/server/api/ApiController.hpp
View File

@ -40,7 +40,7 @@
namespace oatpp { namespace web { namespace server { namespace api {
class ApiController : public oatpp::base::Controllable {
class ApiController : public oatpp::base::Countable {
protected:
typedef ApiController __ControllerType;
public:
@ -94,7 +94,7 @@ protected:
* Handler which subscribes to specific URL in Router and delegates calls endpoints
*/
template<class T>
class Handler : public oatpp::base::Controllable, public oatpp::web::url::mapping::Subscriber<std::shared_ptr<IncomingRequest>, std::shared_ptr<OutgoingResponse>> {
class Handler : public oatpp::base::Countable, public oatpp::web::url::mapping::Subscriber<std::shared_ptr<IncomingRequest>, std::shared_ptr<OutgoingResponse>> {
public:
typedef std::shared_ptr<OutgoingResponse> (T::*Method)(const std::shared_ptr<protocol::http::incoming::Request>&);
typedef Action (T::*MethodAsync)(oatpp::async::AbstractCoroutine*,

4
src/oatpp/web/server/api/Endpoint.hpp
View File

@ -39,7 +39,7 @@ namespace oatpp { namespace web { namespace server { namespace api {
* Endpoint - class which holds information about endpoint.
* It holds API documentation info, and pointer to RequestHandler
*/
class Endpoint : public oatpp::base::Controllable {
class Endpoint : public oatpp::base::Countable {
public:
typedef oatpp::web::url::mapping::Subscriber<
std::shared_ptr<protocol::http::incoming::Request>,
@ -50,7 +50,7 @@ public:
/**
* Info holds API documentation information about endpoint
*/
class Info : public oatpp::base::Controllable {
class Info : public oatpp::base::Countable {
public:
/**

2
src/oatpp/web/server/handler/ErrorHandler.hpp
View File

@ -39,7 +39,7 @@ public:
};
class DefaultErrorHandler : public oatpp::base::Controllable, public ErrorHandler {
class DefaultErrorHandler : public oatpp::base::Countable, public ErrorHandler {
public:
DefaultErrorHandler()
{}

4
src/oatpp/web/url/mapping/Pattern.hpp
View File

@ -35,7 +35,7 @@
namespace oatpp { namespace web { namespace url { namespace mapping {
class Pattern : public base::Controllable{
class Pattern : public base::Countable{
private:
typedef oatpp::data::share::StringKeyLabel StringKeyLabel;
public:
@ -72,7 +72,7 @@ public:
private:
class Part : public base::Controllable{
class Part : public base::Countable{
public:
Part(const char* pFunction, const oatpp::String& pText)
: function(pFunction)

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

@ -33,13 +33,13 @@
#include "oatpp/core/Types.hpp"
#include "oatpp/core/base/Controllable.hpp"
#include "oatpp/core/base/Countable.hpp"
#include "oatpp/core/base/Environment.hpp"
namespace oatpp { namespace web { namespace url { namespace mapping {
template<class Param, class ReturnType>
class Router : public base::Controllable{
class Router : public base::Countable{
public:
typedef Subscriber<Param, ReturnType> UrlSubscriber;
private:
@ -80,7 +80,7 @@ public:
public:
class Pair : public base::Controllable{
class Pair : public base::Countable{
public:
Pair(const std::shared_ptr<Pattern>& pPattern, const std::shared_ptr<UrlSubscriber>& pSubscriber)
: pattern(pPattern)

2
test/oatpp/core/base/RegRuleTest.cpp
View File

@ -33,7 +33,7 @@ namespace oatpp { namespace test { namespace base {
namespace {
class BaseClass : public oatpp::base::Controllable {
class BaseClass : public oatpp::base::Countable {
public:
template<class T>

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

@ -33,7 +33,7 @@ namespace oatpp { namespace test { namespace collection {
namespace {
class TestObject : public oatpp::base::Controllable {
class TestObject : public oatpp::base::Countable {
public:
SHARED_OBJECT_POOL(TestObject_Pool2, TestObject, 32)
public:

4
test/oatpp/core/base/memory/PerfTest.cpp
View File

@ -53,7 +53,7 @@ namespace {
};
class TestChild : public oatpp::base::Controllable, public TestBase {
class TestChild : public oatpp::base::Countable, public TestBase {
public:
static void* operator new(std::size_t sz) {
@ -67,7 +67,7 @@ namespace {
};
class Task : public oatpp::concurrency::Runnable, public oatpp::base::Controllable {
class Task : public oatpp::concurrency::Runnable, public oatpp::base::Countable {
private:
std::shared_ptr<TestBase> m_shared;
public: