thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2025-06-16 07:07:13 +02:00
Code Releases Activity

Major plugin refactor and cleanup.

Browse Source 
Switched to POCO library for unified platform/library interface.
Deprecated the external module API. It was creating more problems than solving.
Removed most built-in libraries in favor of system libraries for easier maintenance.
Cleaned and secured code with help from static analyzers.
This commit is contained in:
Sandu Liviu Catalin
2021-01-30 08:51:39 +02:00
parent e0e34b4030
commit 4a6bfc086c
6219 changed files with 1209835 additions and 454916 deletions
Download Patch File Download Diff File Expand all files Collapse all files

438
vendor/POCO/Foundation/include/Poco/FunctionDelegate.h vendored Normal file
View File

@ -0,0 +1,438 @@
//
// FunctionDelegate.h
//
// Library: Foundation
// Package: Events
// Module: FunctionDelegate
//
// Implementation of the FunctionDelegate template.
//
// Copyright (c) 2006-2011, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef Foundation_FunctionDelegate_INCLUDED
#define Foundation_FunctionDelegate_INCLUDED
#include "Poco/Foundation.h"
#include "Poco/AbstractDelegate.h"
#include "Poco/Mutex.h"
namespace Poco {
template <class TArgs, bool hasSender = true, bool senderIsConst = true>
class FunctionDelegate: public AbstractDelegate<TArgs>
/// Wraps a freestanding function or static member function
/// for use as a Delegate.
{
public:
typedef void (*NotifyFunction)(const void*, TArgs&);
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<TArgs>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* sender, TArgs& arguments)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)(sender, arguments);
return true;
}
else return false;
}
bool equals(const AbstractDelegate<TArgs>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<TArgs>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
template <class TArgs>
class FunctionDelegate<TArgs, true, false>: public AbstractDelegate<TArgs>
{
public:
typedef void (*NotifyFunction)(void*, TArgs&);
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<TArgs>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* sender, TArgs& arguments)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)(const_cast<void*>(sender), arguments);
return true;
}
else return false;
}
bool equals(const AbstractDelegate<TArgs>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<TArgs>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
template <class TArgs, bool senderIsConst>
class FunctionDelegate<TArgs, false, senderIsConst>: public AbstractDelegate<TArgs>
{
public:
typedef void (*NotifyFunction)(TArgs&);
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<TArgs>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* /*sender*/, TArgs& arguments)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)(arguments);
return true;
}
else return false;
}
bool equals(const AbstractDelegate<TArgs>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<TArgs>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
template <>
class FunctionDelegate<void, true, true>: public AbstractDelegate<void>
/// Wraps a freestanding function or static member function
/// for use as a Delegate.
{
public:
typedef void (*NotifyFunction)(const void*);
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<void>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* sender)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)(sender);
return true;
}
else return false;
}
bool equals(const AbstractDelegate<void>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<void>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
template <>
class FunctionDelegate<void, true, false>: public AbstractDelegate<void>
{
public:
typedef void (*NotifyFunction)(void*);
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<void>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* sender)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)(const_cast<void*>(sender));
return true;
}
else return false;
}
bool equals(const AbstractDelegate<void>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<void>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
template <bool senderIsConst>
class FunctionDelegate<void, false, senderIsConst>: public AbstractDelegate<void>
{
public:
typedef void (*NotifyFunction)();
FunctionDelegate(NotifyFunction function):
_function(function)
{
}
FunctionDelegate(const FunctionDelegate& delegate):
AbstractDelegate<void>(delegate),
_function(delegate._function)
{
}
~FunctionDelegate()
{
}
FunctionDelegate& operator = (const FunctionDelegate& delegate)
{
if (&delegate != this)
{
this->_function = delegate._function;
}
return *this;
}
bool notify(const void* /*sender*/)
{
Mutex::ScopedLock lock(_mutex);
if (_function)
{
(*_function)();
return true;
}
else return false;
}
bool equals(const AbstractDelegate<void>& other) const
{
const FunctionDelegate* pOtherDelegate = dynamic_cast<const FunctionDelegate*>(other.unwrap());
return pOtherDelegate && _function == pOtherDelegate->_function;
}
AbstractDelegate<void>* clone() const
{
return new FunctionDelegate(*this);
}
void disable()
{
Mutex::ScopedLock lock(_mutex);
_function = 0;
}
protected:
NotifyFunction _function;
Mutex _mutex;
private:
FunctionDelegate();
};
} // namespace Poco
#endif // Foundation_FunctionDelegate_INCLUDED