533 lines
17 KiB
C++
Executable File
533 lines
17 KiB
C++
Executable File
/*
|
|
PIP - Platform Independent Primitives
|
|
Object, base class of some PIP classes, provide EVENT -> EVENT_HANDLER mechanism
|
|
Copyright (C) 2017 Ivan Pelipenko peri4ko@yandex.ru
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "piobject.h"
|
|
#include "pifile.h"
|
|
#include "pisysteminfo.h"
|
|
|
|
|
|
/** \class PIObject
|
|
* \brief This is base class for any classes which use events -> handlers mechanism.
|
|
* \details
|
|
* \section PIObject_sec0 Events and Event handlers
|
|
* %PIObject provide notification mechanism similar Qt but implemented
|
|
* on language capabilities without any special preprocessors or compilers.
|
|
* Any class inherits PIObject should use macro \a PIOBJECT() immediate
|
|
* after declaration to proper compile.
|
|
*
|
|
* Event is a some abstract event that can be raised at any time.
|
|
* Event is a function but declared with special macro \a EVENT().
|
|
* To raise event simply execute event function.
|
|
*
|
|
* Event handler is a function but declared with special macro
|
|
* \a EVENT_HANDLER(). You can use event handlers as ordinary functions.
|
|
*
|
|
* Main goal of this mechanism is perform abstract connections between
|
|
* various objects. This functionality provide macro \a CONNECT() which
|
|
* connect some event of first object to some event handler or event of
|
|
* second object. Each event can be connected any times to any event handlers.
|
|
*
|
|
* \image html events_handlers.png
|
|
*
|
|
* Example: \snippet piobject.cpp main
|
|
* Result:
|
|
\code{.cpp}
|
|
handler B: 2 , 0.5
|
|
handler A: event to handler
|
|
handler A: event to event
|
|
\endcode
|
|
*/
|
|
|
|
|
|
|
|
PIString PIObject::__EHFunc::arguments() const {
|
|
return types.join(",");
|
|
}
|
|
|
|
|
|
PIString PIObject::__EHFunc::fullFormat() const {
|
|
PIString ret = type_ret + " " + scope + "::" + func_name +"(";
|
|
for (int i = 0; i < types.size_s(); ++i) {
|
|
if (i > 0) ret += ", ";
|
|
ret += types[i] + " " + names[i];
|
|
}
|
|
ret += ")";
|
|
return ret;
|
|
}
|
|
|
|
|
|
PIObject::PIObject(const PIString & name): _signature_(__PIOBJECT_SIGNATURE__), emitter_(0), thread_safe_(false), proc_event_queue(false) {
|
|
piMonitor.objects++;
|
|
//__PIVariantInitBuiltin__();
|
|
setName(name);
|
|
setDebug(true);
|
|
objects() << this;
|
|
//piCout << "new" << this;
|
|
}
|
|
|
|
|
|
PIObject::~PIObject() {
|
|
//piCout << "delete" << this;
|
|
piMonitor.objects--;
|
|
objects().removeAll(this);
|
|
piDisconnect(this);
|
|
}
|
|
|
|
|
|
void PIObject::piConnect(const PIString & src, const PIString & sig, void * dest, void * ev_h) {
|
|
PIObject * o = findByName(src);
|
|
if (o == 0) {
|
|
piCout << "[PIObject] Can`t find object with name \"" << src << "\"!";
|
|
return;
|
|
}
|
|
PIMutexLocker _ml(o->mutex_connect);
|
|
PIMutexLocker _mld(((PIObject*)dest)->mutex_connect, ((PIObject*)dest) != o);
|
|
o->connections << Connection(ev_h, 0, sig, (PIObject*)dest, dest);
|
|
((PIObject*)dest)->connectors << o;
|
|
}
|
|
|
|
|
|
void PIObject::piConnect(PIObject * src, const PIString & sig, const PIString & dest, void * ev_h) {
|
|
PIObject * o = findByName(dest);
|
|
if (o == 0) {
|
|
piCout << "[PIObject] Can`t find object with name \"" << dest << "\"!";
|
|
return;
|
|
}
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
PIMutexLocker _mld(o->mutex_connect, src != o);
|
|
src->connections << Connection(ev_h, 0, sig, o, o);
|
|
((PIObject*)o)->connectors << src;
|
|
}
|
|
|
|
|
|
void PIObject::piConnect(const PIString & src, const PIString & sig, const PIString & dest, void * ev_h) {
|
|
PIObject * s = findByName(src);
|
|
if (s == 0) {
|
|
piCout << "[PIObject] Can`t find object with name \"" << src << "\"!";
|
|
return;
|
|
}
|
|
PIObject * d = findByName(dest);
|
|
if (d == 0) {
|
|
piCout << "[PIObject] Can`t find object with name \"" << dest << "\"!";
|
|
return;
|
|
}
|
|
PIMutexLocker _ml(s->mutex_connect);
|
|
PIMutexLocker _mld(d->mutex_connect, s != d);
|
|
s->connections << Connection(ev_h, 0, sig, d, d);
|
|
d->connectors << s;
|
|
}
|
|
|
|
/*
|
|
PIStringList PIObject::events() {
|
|
PIStringList l;
|
|
for (PIMap<NamedFunction, PIString>::const_iterator i = signals_.begin(); i != signals_.end(); i++)
|
|
l << (*i).first;
|
|
return l;
|
|
}
|
|
*/
|
|
|
|
PIStringList PIObject::scopeList() const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
return __meta_data()[className()].scope_list;
|
|
}
|
|
|
|
|
|
PIStringList PIObject::methodsEH() const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
PIStringList ret;
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
piForeachC (__EHPair & eh, ehd.eh_func)
|
|
ret << eh.second.fullFormat();
|
|
return ret;
|
|
}
|
|
|
|
|
|
bool PIObject::isMethodEHContains(const PIString & name) const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
piForeachC (__EHPair & eh, ehd.eh_func)
|
|
if (eh.second.func_name == name)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
|
|
PIString PIObject::methodEHArguments(const PIString & name) const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
piForeachC (__EHPair & eh, ehd.eh_func)
|
|
if (eh.second.func_name == name)
|
|
return eh.second.arguments();
|
|
return PIString();
|
|
}
|
|
|
|
|
|
PIString PIObject::methodEHFullFormat(const PIString & name) const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
piForeachC (__EHPair & eh, ehd.eh_func)
|
|
if (eh.second.func_name == name)
|
|
return eh.second.fullFormat();
|
|
return PIString();
|
|
}
|
|
|
|
|
|
PIString PIObject::methodEHFromAddr(const void * addr) const {
|
|
return methodEH(addr).func_name;
|
|
}
|
|
|
|
|
|
PIVector<PIObject::__EHFunc> PIObject::findEH(const PIString & name) const {
|
|
PIVector<__EHFunc> ret;
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
piForeachC (__EHPair & eh, ehd.eh_func)
|
|
if (eh.second.func_name == name)
|
|
ret << eh.second;
|
|
return ret;
|
|
}
|
|
|
|
|
|
PIObject::__EHFunc PIObject::methodEH(const void * addr) const {
|
|
PIMutexLocker ml(__meta_mutex());
|
|
return __meta_data()[className()].eh_func.value(addr);
|
|
}
|
|
|
|
|
|
void PIObject::piConnect(PIObject * src, const PIString & sig, PIObject * dest_o, void * dest, void * ev_h, void * e_h, int args, const char * loc) {
|
|
//piCout << "piConnect ...";
|
|
//piCout << "piConnect" << src << (void*)(dest) << sig;
|
|
//piCout << "piConnect" << src->className() << "->" << ((PIObject*)dest)->className();
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
PIMutexLocker _mld(dest_o->mutex_connect, src != dest_o);
|
|
|
|
src->connections << Connection(ev_h, e_h, sig, dest_o, dest, args);
|
|
//piCout << "piConnect" << ((PIObject*)dest) << sig << ((PIObject*)dest)->connectors.size_s() << "...";
|
|
//piCout << "addConnector" << dest_o << src;
|
|
dest_o->connectors << src;
|
|
//piCout << "piConnect" << ((PIObject*)dest) << sig << ((PIObject*)dest)->connectors.size_s();
|
|
//piCout << "piConnect ok";
|
|
}
|
|
|
|
|
|
bool PIObject::piConnectU(PIObject * src, const PIString & ename, PIObject * dest_o, void * dest, const PIString & hname, const char * loc, PIObject * performer) {
|
|
if (src == 0 || dest_o == 0 || dest == 0) return false;
|
|
if (!src->isPIObject()) {
|
|
piCout << "[piConnectU] \"" << ename << "\" -> \"" << hname << "\" error: source object is not PIObject! (" << loc << ")";
|
|
return false;
|
|
}
|
|
if (!dest_o->isPIObject()) {
|
|
piCout << "[piConnectU] \"" << ename << "\" -> \"" << hname << "\" error: destination object is not PIObject! (" << loc << ")";
|
|
return false;
|
|
}
|
|
PIMutexLocker ml(__meta_mutex());
|
|
PIMutexLocker mls(src->mutex_connect);
|
|
PIMutexLocker mld(dest_o->mutex_connect, src != dest_o);
|
|
PIVector<__EHFunc> m_src = src->findEH(ename), m_dest = dest_o->findEH(hname);
|
|
if (m_src.isEmpty()) {
|
|
piCout << "[piConnectU] Error: can`t find event \"" << ename << "\" in class \"" << src->className() << "\"! (" << loc << ")";
|
|
return false;
|
|
}
|
|
if (m_dest.isEmpty()) {
|
|
piCout << "[piConnectU] Error: can`t find handler \"" << hname << "\" in class \"" << dest_o->className() << "\"! (" << loc << ")";
|
|
return false;
|
|
}
|
|
void * addr_src(0), * addr_dest(0);
|
|
int args(0);
|
|
bool que = (performer != 0);
|
|
piForeachC (__EHFunc & fs, m_src) {
|
|
if (addr_src != 0) break;
|
|
piForeachC (__EHFunc & fd, m_dest) {
|
|
if (addr_src != 0) break;
|
|
if (fs.arguments().startsWith(fd.arguments()) || fd.arguments().isEmpty()) {
|
|
addr_src = fs.addr;
|
|
addr_dest = que ? fd.addrV : fd.addr;
|
|
args = fd.names.size_s();
|
|
}
|
|
}
|
|
}
|
|
if (addr_src == 0) {
|
|
piCout << "[piConnectU] Error: can`t find suitable pair of event \"" << ename << "\" in class \"" << src->className()
|
|
<< "\" and handler \"" << hname << "\" in class \"" << dest_o->className() << "\"! (" << loc << ")";
|
|
return false;
|
|
}
|
|
//piCout << "connect" << ename << "->" << hname << "with" << args << "args";
|
|
src->connections << PIObject::Connection(addr_dest, addr_src, ename, dest_o, dest, args, performer);
|
|
if (que) performer->proc_event_queue = true;
|
|
dest_o->connectors << src;
|
|
return true;
|
|
}
|
|
|
|
|
|
void PIObject::piDisconnect(PIObject * src, const PIString & sig, PIObject * dest, void * ev_h) {
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
PIMutexLocker _mld(dest->mutex_connect, src != dest);
|
|
for (int i = 0; i < src->connections.size_s(); ++i) {
|
|
Connection & cc(src->connections[i]);
|
|
if (cc.event == sig && cc.dest_o == dest && cc.slot == ev_h) {
|
|
src->connections.remove(i);
|
|
i--;
|
|
}
|
|
}
|
|
dest->updateConnectors();
|
|
}
|
|
|
|
|
|
void PIObject::piDisconnect(PIObject * src, const PIString & sig, PIObject * dest) {
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
PIMutexLocker _mld(dest->mutex_connect, src != dest);
|
|
for (int i = 0; i < src->connections.size_s(); ++i) {
|
|
Connection & cc(src->connections[i]);
|
|
if (cc.event == sig && cc.dest_o == dest) {
|
|
src->connections.remove(i);
|
|
i--;
|
|
}
|
|
}
|
|
dest->updateConnectors();
|
|
}
|
|
|
|
|
|
void PIObject::piDisconnect(PIObject * src, const PIString & sig) {
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
for (int i = 0; i < src->connections.size_s(); ++i) {
|
|
Connection & cc(src->connections[i]);
|
|
if (cc.event == sig) {
|
|
PIObject * dest = cc.dest_o;
|
|
src->connections.remove(i);
|
|
i--;
|
|
#ifndef ANDROID
|
|
PIMutexLocker _mld(dest->mutex_connect, src != dest);
|
|
#endif
|
|
dest->updateConnectors();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void PIObject::piDisconnect(PIObject * src) {
|
|
src->deleted();
|
|
PIMutexLocker _ml(src->mutex_connect);
|
|
PIVector<PIObject * > cv = src->connectors.toVector();
|
|
piForeach (PIObject * o, cv) {
|
|
if (o == src) continue;
|
|
#ifndef ANDROID
|
|
PIMutexLocker _mld(o->mutex_connect, src != o);
|
|
#endif
|
|
PIVector<Connection> & oc(o->connections);
|
|
for (int i = 0; i < oc.size_s(); ++i) {
|
|
//piCout << " check" << (void*)(oc[i].dest_o) << "==" << (void*)(src);
|
|
if (oc[i].dest_o == src) {
|
|
oc.remove(i);
|
|
--i;
|
|
}
|
|
}
|
|
}
|
|
piForeachC (PIObject::Connection & c, src->connections)
|
|
c.dest_o->connectors.remove(src);
|
|
src->connections.clear();
|
|
}
|
|
|
|
|
|
void PIObject::updateConnectors() {
|
|
//piCout << "*** updateConnectors" << this;
|
|
connectors.clear();
|
|
piForeach (PIObject * o, objects()) {
|
|
if (o == this) continue;
|
|
PIVector<Connection> & oc(o->connections);
|
|
piForeach (Connection & c, oc)
|
|
if (c.dest == this)
|
|
connectors << o;
|
|
}
|
|
}
|
|
|
|
|
|
void PIObject::postQueuedEvent(const PIObject::QueuedEvent & e) {
|
|
mutex_queue.lock();
|
|
events_queue << e;
|
|
mutex_queue.unlock();
|
|
}
|
|
|
|
|
|
PIMutex & PIObject::__meta_mutex() {
|
|
static PIMutex ret;
|
|
return ret;
|
|
}
|
|
|
|
|
|
PIMap<PIString, PIObject::__MetaData> & PIObject::__meta_data() {
|
|
static PIMap<PIString, PIObject::__MetaData> ret;
|
|
return ret;
|
|
}
|
|
|
|
|
|
void PIObject::callQueuedEvents() {
|
|
mutex_queue.lock();
|
|
PIVector<QueuedEvent> qe = events_queue;
|
|
events_queue.clear();
|
|
mutex_queue.unlock();
|
|
piForeachC (QueuedEvent & e, qe) {
|
|
if (e.dest_o->thread_safe_) e.dest_o->mutex_.lock();
|
|
e.dest_o->emitter_ = e.src;
|
|
switch (e.values.size_s()) {
|
|
case 0: ((void(*)(void *))e.slot)(e.dest); break;
|
|
case 1: ((void(*)(void * , const PIVariant & ))e.slot)(e.dest, e.values[0]); break;
|
|
case 2: ((void(*)(void * , const PIVariant & , const PIVariant & ))e.slot)(e.dest, e.values[0], e.values[1]); break;
|
|
case 3: ((void(*)(void * , const PIVariant & , const PIVariant & , const PIVariant & ))e.slot)(e.dest, e.values[0], e.values[1], e.values[2]); break;
|
|
case 4: ((void(*)(void * , const PIVariant & , const PIVariant & , const PIVariant & , const PIVariant & ))e.slot)(e.dest, e.values[0], e.values[1], e.values[2], e.values[3]); break;
|
|
default: break;
|
|
}
|
|
e.dest_o->emitter_ = 0;
|
|
if (e.dest_o->thread_safe_) e.dest_o->mutex_.unlock();
|
|
}
|
|
}
|
|
|
|
|
|
PIVector<PIObject * > & PIObject::objects() {
|
|
static PIVector<PIObject * > ret;
|
|
return ret;
|
|
}
|
|
|
|
|
|
PIString PIObject::simplifyType(const char * a) {
|
|
PIString ret = PIStringAscii(a).trim();
|
|
int white = -1;
|
|
for (int i = 0; i < ret.size_s(); ++i) {
|
|
bool iw = ret[i] == ' ' || ret[i] == '\t' || ret[i] == '\r' || ret[i] == '\n';
|
|
//piCout << i << iw << white;
|
|
if (white < 0) {
|
|
if (iw) {
|
|
white = i;
|
|
continue;
|
|
}
|
|
} else {
|
|
if (!iw) {
|
|
ret.replace(white, i - white, " ");
|
|
i = white;
|
|
white = -1;
|
|
//piCout << i;
|
|
}
|
|
}
|
|
}
|
|
ret.replaceAll(" &", "&");
|
|
ret.replaceAll(" *", "*");
|
|
if (ret.startsWith("const ") && ret.endsWith("&"))
|
|
ret.cutLeft(6).cutRight(1).trim();
|
|
return ret;
|
|
}
|
|
|
|
|
|
bool PIObject::execute(const PIString & method) {
|
|
if (method.isEmpty()) return false;
|
|
PIVector<__EHFunc> ml = findEH(method);
|
|
piForeachC (__EHFunc & m, ml) {
|
|
if (!m.names.isEmpty()) continue;
|
|
((void(*)(void*))m.addr)(this);
|
|
return true;
|
|
}
|
|
piCoutObj << "Error: can`t find event or handler \"" << (method + "()") << "\" to execute!";
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PIObject::isPIObject(const PIObject * o) {
|
|
if (!o) return false;
|
|
return o->_signature_ == __PIOBJECT_SIGNATURE__;
|
|
}
|
|
|
|
|
|
|
|
|
|
void PIObject::dump(const PIString & line_prefix) const {
|
|
//printf("dump %s \"%s\"\n", className(), name().data());
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << "class " << className() << " (" << (const void*)this << ", \"" << name() << "\") {";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " properties {";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " count: " << properties_.size_s();
|
|
//printf("dump %d properties\n", properties_.size());
|
|
piForeachC (Property p, properties_)
|
|
if (p.first != "name")
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " " << p.first << ": " << p.second;
|
|
//printf("dump %d properties ok\n", properties_.size());
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " }";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " methodsEH {";
|
|
__MetaData & ehd(__meta_data()[className()]);
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " count: " << ehd.eh_func.size_s();
|
|
//printf("dump %d methods\n", ehd.eh_func.size());
|
|
piForeachC (__EHPair & eh, ehd.eh_func) {
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " " << eh.second.fullFormat();
|
|
}
|
|
//printf("dump %d methods ok\n", ehd.eh_func.size());
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " }";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " connections {";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " count: " << connections.size_s();
|
|
//printf("dump %d connections\n",connections.size());
|
|
piForeachC (Connection & c, connections) {
|
|
PIObject * dst = c.dest_o;
|
|
__EHFunc hf = dst->methodEH(c.slot);
|
|
__EHFunc ef = methodEH(c.signal);
|
|
if (hf.func_name.isEmpty()) hf.func_name = "[BROKEN]";
|
|
else hf.func_name += "(" + hf.arguments() + ")";
|
|
PIString src(c.event);
|
|
if (!ef.func_name.isEmpty())
|
|
src = ef.func_name + "(" + ef.arguments() + ")";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " " << src << " -> " << dst->className() << " (" << c.dest << ", \"" << dst->name() << "\")::" << hf.func_name;
|
|
}
|
|
//printf("dump %d connections ok\n",connections.size());
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << " }";
|
|
PICout(PICoutManipulators::AddNewLine) << line_prefix << "}";
|
|
}
|
|
|
|
|
|
|
|
|
|
void dumpApplication() {
|
|
//printf("dump application ...\n");
|
|
PIDateTime cd = PIDateTime::current();
|
|
PISystemInfo * pi = PISystemInfo::instance();
|
|
PICout(PICoutManipulators::AddNewLine) << "application {";
|
|
PICout(PICoutManipulators::AddNewLine) << " PIP version: " << PIPVersion();
|
|
PICout(PICoutManipulators::AddNewLine) << " processors: " << pi->processorsCount;
|
|
PICout(PICoutManipulators::AddNewLine) << " hostname: \"" << pi->hostname << "\"";
|
|
PICout(PICoutManipulators::AddNewLine) << " user: \"" << pi->user << "\"";
|
|
PICout(PICoutManipulators::AddNewLine) << " exec command: \"" << pi->execCommand << "\"";
|
|
PICout(PICoutManipulators::AddNewLine) << " started: " << pi->execDateTime.toString();
|
|
PICout(PICoutManipulators::AddNewLine) << " uptime, s: " << (cd.toSystemTime() - pi->execDateTime.toSystemTime()).toSeconds();
|
|
PICout(PICoutManipulators::AddNewLine) << " PIObjects {";
|
|
PICout(PICoutManipulators::AddNewLine) << " count: " << PIObject::objects().size_s();
|
|
piForeachC (PIObject * o, PIObject::objects())
|
|
o->dump(" ");
|
|
PICout(PICoutManipulators::AddNewLine) << " }";
|
|
PICout(PICoutManipulators::AddNewLine) << "}";
|
|
//printf("dump application done\n");
|
|
}
|
|
|
|
|
|
bool dumpApplicationToFile(const PIString & path) {
|
|
PIFile f(path + "_tmp");
|
|
f.setName("__S__DumpFile");
|
|
f.clear();
|
|
if (!f.open(PIIODevice::WriteOnly)) return false;
|
|
bool ba = PICout::isBufferActive();
|
|
PICout::setBufferActive(true, true);
|
|
dumpApplication();
|
|
f << PICout::buffer();
|
|
f.close();
|
|
PICout::setBufferActive(ba, true);
|
|
PIFile::rename(path + "_tmp", path);
|
|
return true;
|
|
}
|