Map::~Map()
{
// Notify everyone that server is going down
if(!(pTemplate->mapflag & MAP_INSTANCED))
std::for_each(Players.begin(), Players.end(), boost::bind(&Player::OnServerShutdown, _1));
// Cleanup entities
std::for_each(Creatures.begin(), Creatures.end(), Deleter());
std::for_each(GameObjects.begin(), GameObjects.end(), Deleter());
std::for_each(Spells.begin(), Spells.end(), Deleter());
delete pMapScript;
sLog.Write("Map %u destroyed.", MapID);
}
void Own( UniquePtr *source )
{
ASSUME( (_ptr != source->_ptr) || (_ptr == 0) );
Deleter( (X *)_ptr );
_ptr = source->_ptr;
source->_ptr = 0;
}
std::shared_ptr<Component>
get_ptr_postproc_helper(naming::address const& addr,
naming::id_type const& id)
{
if (get_locality() != addr.locality_)
{
HPX_THROW_EXCEPTION(bad_parameter,
"hpx::get_ptr_postproc<Component, Deleter>",
"the given component id does not belong to a local object");
return std::shared_ptr<Component>();
}
if (!traits::component_type_is_compatible<Component>::call(addr))
{
HPX_THROW_EXCEPTION(bad_component_type,
"hpx::get_ptr_postproc<Component, Deleter>",
"requested component type does not match the given component id");
return std::shared_ptr<Component>();
}
Component* p = get_lva<Component>::call(addr.address_);
std::shared_ptr<Component> ptr(p, Deleter(id));
ptr->pin(); // the shared_ptr pins the component
return ptr;
}
void EuropaCapture::publish(double time, double timestamp, GraphicsWindow&
window) {
#ifdef HAVE_MOOS_MESSAGES
CompressedImageMsg msg;
CompressedImageMsg::CompressedImage img;
PNMImage screenshot;
window.get_screenshot(screenshot);
stream.str("");
screenshot.write(stream, "capture.bmp");
img.format = CompressedImageMsg::IF_BMP;
img.size = stream.tellp();
img.buffer.reset((unsigned char*)stream.str().data(), Deleter());
img.timestamp = mClient->getTime(timestamp);
img.frameNumber = frameNumber;
img.cameraId = 0;
msg.timestamp = mClient->getTime(timestamp);
msg.compressedImages.push_back(img);
MOOSPublisher::publish(mMsgName, msg.toString());
#endif
++frameNumber;
}
UniquePtr &operator = ( UniquePtr &&source )
{
ASSUME( this != &source );
Deleter( (X *)_ptr );
_ptr = source._ptr;
source._ptr = 0;
return *this;
}
void testSmartPointer() {
char *mem = (char*)malloc(4);
{
SmartPointer Deleter(mem);
// destructor called here
}
*mem = 0; // expected-warning{{Use of memory after it is freed}}
}
//==============================================================================
Error GlPipelineHandle::commonConstructor(
GlCommandBufferHandle& commands,
const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd)
{
class Command: public GlCommand
{
public:
GlPipelineHandle m_ppline;
Array<GlShaderHandle, 6> m_progs;
U8 m_progsCount;
Command(GlPipelineHandle& ppline,
const GlShaderHandle* progsBegin, const GlShaderHandle* progsEnd)
: m_ppline(ppline)
{
m_progsCount = 0;
const GlShaderHandle* prog = progsBegin;
do
{
m_progs[m_progsCount++] = *prog;
} while(++prog != progsEnd);
}
Error operator()(GlCommandBuffer* cmdb)
{
Error err = m_ppline._get().create(
&m_progs[0], &m_progs[0] + m_progsCount,
cmdb->getGlobalAllocator());
GlHandleState oldState = m_ppline._setState(
err ? GlHandleState::ERROR : GlHandleState::CREATED);
ANKI_ASSERT(oldState == GlHandleState::TO_BE_CREATED);
(void)oldState;
return err;
}
};
using Alloc = GlAllocator<GlPipeline>;
using DeleteCommand = GlDeleteObjectCommand<GlPipeline, Alloc>;
using Deleter =
GlHandleDeferredDeleter<GlPipeline, Alloc, DeleteCommand>;
Error err = _createAdvanced(
&commands._get().getQueue().getDevice(),
commands._get().getGlobalAllocator(),
Deleter());
if(!err)
{
_setState(GlHandleState::TO_BE_CREATED);
commands._pushBackNewCommand<Command>(*this, progsBegin, progsEnd);
}
return err;
}
void testSubclassSmartPointer() {
char *mem = (char*)malloc(4);
{
Subclass Deleter(mem);
// Remove dead bindings...
doSomething();
// destructor called here
}
*mem = 0; // expected-warning{{Use of memory after it is freed}}
}
void testMultipleInheritance2() {
char *mem = (char*)malloc(4);
{
MultipleInheritance Deleter(0, mem);
// Remove dead bindings...
doSomething();
// destructor called here
}
*mem = 0; // expected-warning{{Use of memory after it is freed}}
}
void testMultipleInheritance3() {
char *mem = (char*)malloc(4);
{
MultipleInheritance Deleter(mem, mem);
// Remove dead bindings...
doSomething();
// destructor called here
// expected-warning@27 {{Attempt to free released memory}}
}
}
ObjectMgr::~ObjectMgr()
{
std::for_each(CreatureTemplates.begin(), CreatureTemplates.end(), MapDeleter());
std::for_each(GameObjectTemplates.begin(), GameObjectTemplates.end(), MapDeleter());
std::for_each(ItemTemplates.begin(), ItemTemplates.end(), MapDeleter());
std::for_each(QuestTemplates.begin(), QuestTemplates.end(), MapDeleter());
std::for_each(SpellTemplates.begin(), SpellTemplates.end(), MapDeleter());
std::for_each(MapTemplates.begin(), MapTemplates.end(), MapDeleter());
std::for_each(Players.begin(), Players.end(), Deleter());
}
int main()
{
{
A* p = new A[3];
assert(A::count == 3);
std::unique_ptr<A[], const Deleter&> s(p, Deleter());
assert(s.get() == p);
assert(s.get_deleter().state() == 5);
}
assert(A::count == 0);
}
fcppt::shared_ptr<
Type,
Deleter
>::shared_ptr(
Other *const _ptr
)
:
impl_(
_ptr,
Deleter()
)
{
}
/* Constructs an envp array from a hash table.
* The returned array occupies a single contiguous block of memory
* such that it can be released by a single call to free(3).
* The last element of the returned array is set to NULL for compatibility
* with posix_spawn() */
std::unique_ptr<char*, ChildProcess::Deleter>
ChildProcess::Environment::asEnviron(size_t* env_size) const {
size_t len = (1 + map_.size()) * sizeof(char*);
// Make a pass through to compute the required memory size
for (const auto& it : map_) {
const auto& key = it.first;
const auto& val = it.second;
// key=value\0
len += key.size() + 1 + val.size() + 1;
}
auto envp = (char**)malloc(len);
if (!envp) {
throw std::bad_alloc();
}
auto result = std::unique_ptr<char*, Deleter>(envp, Deleter());
// Now populate
auto buf = (char*)(envp + map_.size() + 1);
size_t i = 0;
for (const auto& it : map_) {
const auto& key = it.first;
const auto& val = it.second;
envp[i++] = buf;
// key=value\0
memcpy(buf, key.data(), key.size());
buf += key.size();
memcpy(buf, "=", 1);
buf++;
memcpy(buf, val.data(), val.size());
buf += val.size();
*buf = 0;
buf++;
}
envp[map_.size()] = nullptr;
if (env_size) {
*env_size = len;
}
return result;
}
fcppt::shared_ptr<
Type,
Deleter
>::shared_ptr(
Other *const _ptr,
Alloc const &_alloc
)
:
impl_(
_ptr,
Deleter(),
_alloc
)
{
}
void clear()
{
/* Delete values if a deleter is defined */
if (Deleter != nullptr) {
while (_next_free_slot > 0) {
--_next_free_slot;
const size_t block_index = _next_free_slot / block_size;
const size_t value_index = _next_free_slot % block_size;
Deleter(_blocks[block_index][value_index]);
}
} else {
_next_free_slot = 0;
}
/* Delete value blocks */
for (auto block : _blocks) {
delete [] block;
}
_blocks.clear();
return;
}
//==============================================================================
GlBufferHandle::GlBufferHandle(GlCommandBufferHandle& commands,
GLenum target, PtrSize size, GLenum flags)
{
ANKI_ASSERT(!isCreated());
using Alloc = GlGlobalHeapAllocator<GlBuffer>;
using DeleteCommand =
GlDeleteObjectCommand<GlBuffer, GlGlobalHeapAllocator<U8>>;
using Deleter = GlHandleDeferredDeleter<GlBuffer, Alloc, DeleteCommand>;
*static_cast<Base::Base*>(this) = Base::Base(
&commands._getQueue().getDevice(),
commands._getQueue().getDevice()._getAllocator(),
Deleter());
_setState(GlHandleState::TO_BE_CREATED);
// Fire the command
commands._pushBackNewCommand<GlBufferCreateCommand>(
*this, target, size, flags);
}
~Sheduler() {
std::for_each(m_preprocess.begin(), m_preprocess.end(), Deleter());
std::for_each(m_process.begin(), m_process.end(), Deleter());
std::for_each(m_postprocess.begin(), m_postprocess.end(), Deleter());
};
SourceReader::SourceReader()
: m_file(unique_ptr<istream, Deleter>(&cin, Deleter(false)))
{
LOG_SHORT(LINFO, ("Reading OSM data from stdin"));
}
SourceReader::SourceReader(istringstream & stream)
: m_file(unique_ptr<istream, Deleter>(&stream, Deleter(false)))
{
LOG_SHORT(LINFO, ("Reading OSM data from memory"));
}
SourceReader::SourceReader(string const & filename)
{
m_file = unique_ptr<istream, Deleter>(new ifstream(filename), Deleter());
CHECK(static_cast<ifstream *>(m_file.get())->is_open() , ("Can't open file:", filename));
LOG_SHORT(LINFO, ("Reading OSM data from", filename));
}
CommandProcessor::~CommandProcessor()
{
std::for_each(commandList.begin(),
commandList.end(),
Deleter());
}
void clear()
{
std::for_each(this->states + 0, this->states + this->len, Deleter());
this->len = 0;
}
~UniquePtr()
{
Deleter( (X *)_ptr ); // this dummy C-cast will eliminate a syntax confusion between creating a local variable _ptr and calling a constructor with the argument _ptr
}
World::~World()
{
std::for_each(Maps.begin(), Maps.end(), Deleter());
delete pAIFactory;
delete pWorldAcceptor;
}
//!Constructs a scoped_ptr, storing a copy of p(which can be 0) and d.
//!Does not throw.
explicit scoped_ptr(const pointer &p = 0, const Deleter &d = Deleter())
: Deleter(d), m_ptr(p) // throws if pointer/Deleter copy ctor throws
{}
void Release()
{
Deleter( (X *)_ptr );
_ptr = 0;
}
int main() {
// expected-error@+1 {{call to deleted constructor of 'std::unique_ptr<int, const Deleter &>}}
std::unique_ptr<int, const Deleter&> s((int*)nullptr, Deleter());
}
void InitBuffer(size_t count)
{
m_offset = 0;
m_size = count;
m_data.reset(new char[m_size], Deleter());
}
~multi_handle()
{
Deleter()(N, ids.data());
}
