LGram16
e067522598
Game client codebase including: - CharacterActionControl: Character and creature management - GlobalScript: Network, items, skills, quests, utilities - RYLClient: Main client application with GUI and event handlers - Engine: 3D rendering engine (RYLGL) - MemoryManager: Custom memory allocation - Library: Third-party dependencies (DirectX, boost, etc.) - Tools: Development utilities 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
120 lines
3.1 KiB
C++
120 lines
3.1 KiB
C++
// Copyright (C) 2000, 2001 Stephen Cleary
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
//
|
|
// See http://www.boost.org for updates, documentation, and revision history.
|
|
|
|
#ifndef BOOST_SINGLETON_POOL_HPP
|
|
#define BOOST_SINGLETON_POOL_HPP
|
|
|
|
#include <boost/pool/poolfwd.hpp>
|
|
|
|
// boost::pool
|
|
#include <boost/pool/pool.hpp>
|
|
// boost::details::pool::singleton_default
|
|
#include <boost/pool/detail/singleton.hpp>
|
|
// boost::details::pool::guard
|
|
#include <boost/pool/detail/guard.hpp>
|
|
|
|
namespace boost {
|
|
|
|
//
|
|
// The singleton_pool class allows other pool interfaces for types of the same
|
|
// size to share the same pool
|
|
//
|
|
template <typename Tag, unsigned RequestedSize,
|
|
typename UserAllocator,
|
|
typename Mutex,
|
|
unsigned NextSize>
|
|
struct singleton_pool
|
|
{
|
|
public:
|
|
typedef Tag tag;
|
|
typedef Mutex mutex;
|
|
typedef UserAllocator user_allocator;
|
|
typedef typename pool<UserAllocator>::size_type size_type;
|
|
typedef typename pool<UserAllocator>::difference_type difference_type;
|
|
|
|
BOOST_STATIC_CONSTANT(unsigned, requested_size = RequestedSize);
|
|
BOOST_STATIC_CONSTANT(unsigned, next_size = NextSize);
|
|
|
|
private:
|
|
struct pool_type: Mutex
|
|
{
|
|
pool<UserAllocator> p;
|
|
pool_type():p(RequestedSize, NextSize) { }
|
|
};
|
|
|
|
typedef details::pool::singleton_default<pool_type> singleton;
|
|
|
|
singleton_pool();
|
|
|
|
public:
|
|
static void * malloc()
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.malloc();
|
|
}
|
|
static void * ordered_malloc()
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.ordered_malloc();
|
|
}
|
|
static void * ordered_malloc(const size_type n)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.ordered_malloc(n);
|
|
}
|
|
static bool is_from(void * const ptr)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.is_from(ptr);
|
|
}
|
|
static void free(void * const ptr)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
p.p.free(ptr);
|
|
}
|
|
static void ordered_free(void * const ptr)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
p.p.ordered_free(ptr);
|
|
}
|
|
static void free(void * const ptr, const size_type n)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
p.p.free(ptr, n);
|
|
}
|
|
static void ordered_free(void * const ptr, const size_type n)
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
p.p.ordered_free(ptr, n);
|
|
}
|
|
static bool release_memory()
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.release_memory();
|
|
}
|
|
static bool purge_memory()
|
|
{
|
|
pool_type & p = singleton::instance();
|
|
details::pool::guard<Mutex> g(p);
|
|
return p.p.purge_memory();
|
|
}
|
|
};
|
|
|
|
} // namespace boost
|
|
|
|
#endif
|