if(!_userModes.contains(ircuser) && ircuser) {
_userModes[ircuser] = QString();
ircuser->joinChannel(name());
+ connect(ircuser, SIGNAL(destroyed()), this, SLOT(ircUserDestroyed()));
// no emit here since the join is propagated by IrcUser
}
}
// INIT SET USER MODES
QVariantMap IrcChannel::initUserModes() const {
QVariantMap usermodes;
- QHashIterator<IrcUser *, QString> iter(_userModes);
- while(iter.hasNext()) {
- iter.next();
+ QHash<IrcUser *, QString>::const_iterator iter = _userModes.constBegin();
+ while(iter != _userModes.constEnd()) {
usermodes[iter.key()->nick()] = iter.value();
+ iter++;
}
return usermodes;
}
void IrcChannel::ircUserDestroyed() {
IrcUser *ircUser = static_cast<IrcUser *>(sender());
Q_ASSERT(ircUser);
- part(ircUser);
+ _userModes.remove(ircUser);
}
void IrcChannel::setInitialized() {
int qt_metacall(QMetaObject::Call _c, int _id, void **_a);
void attachSignal(int methodId, const QByteArray &func);
+
+ int sigCount() const;
private:
SignalProxy* proxy;
return _id;
}
+int SignalRelay::sigCount() const {
+ // only for debuging purpose
+ return sigNames.count();
+}
+
void SignalRelay::attachSignal(int methodId, const QByteArray &func) {
// we ride without safetybelts here... all checking for valid method etc pp has to be done by the caller
// all connected methodIds are offset by the standard methodCount of QObject
// ====================
SignalProxy::SignalProxy(QObject* parent)
: QObject(parent),
- _proxyMode(Client),
- _maxClients(-1)
+ _proxyMode(Client)
{
}
SignalProxy::SignalProxy(ProxyMode mode, QObject* parent)
: QObject(parent),
- _proxyMode(mode),
- _maxClients(-1)
+ _proxyMode(mode)
{
}
SignalProxy::SignalProxy(ProxyMode mode, QIODevice* device, QObject* parent)
: QObject(parent),
- _proxyMode(mode),
- _maxClients(-1)
+ _proxyMode(mode)
{
addPeer(device);
}
return _proxyMode;
}
-bool SignalProxy::maxPeersReached() {
- if(_peerByteCount.empty())
- return false;
- if(proxyMode() != Server)
- return true;
- if(_maxClients == -1)
- return false;
-
- return (_maxClients <= _peerByteCount.count());
-}
-
bool SignalProxy::addPeer(QIODevice* iodev) {
if(!iodev)
return false;
if(_peerByteCount.contains(iodev))
return true;
- if(maxPeersReached()) {
- qWarning("SignalProxy: max peer count reached");
+ if(proxyMode() == Client && !_peerByteCount.isEmpty()) {
+ qWarning("SignalProxy: only one peer allowed in client mode!");
return false;
}
void SignalProxy::detachSender() {
// this is a slot so we can bypass the QueuedConnection
+ // and if someone is forcing direct connection in a multithreaded environment he's just nuts...
_detachSignals(sender());
_detachSlots(sender());
}
Q_ARG(QObject*, sender));
}
-void SignalProxy::_detachSignals(QObject* sender) {
- if(!_relayHash.contains(sender))
- return;
- _relayHash.take(sender)->deleteLater();
-}
-
void SignalProxy::detachSlots(QObject* receiver) {
QMetaObject::invokeMethod(this, "_detachSlots",
Qt::QueuedConnection,
Q_ARG(QObject*, receiver));
}
+void SignalProxy::_detachSignals(QObject* sender) {
+ if(!_relayHash.contains(sender))
+ return;
+ _relayHash.take(sender)->deleteLater();
+}
+
void SignalProxy::_detachSlots(QObject* receiver) {
SlotHash::iterator slotIter = _attachedSlots.begin();
while(slotIter != _attachedSlots.end()) {
}
}
-
void SignalProxy::call(const char* signal, QVariant p1, QVariant p2, QVariant p3, QVariant p4, QVariant p5, QVariant p6, QVariant p7, QVariant p8, QVariant p9) {
QByteArray func = QMetaObject::normalizedSignature(signal);
QVariantList params;
}
void SignalProxy::dataAvailable() {
+ // yet again. it's a private slot. no need for checks.
QIODevice* ioDev = qobject_cast<QIODevice* >(sender());
- Q_ASSERT(ioDev);
- if(!_peerByteCount.contains(ioDev)) {
- qWarning() << "SignalProxy: Unrecognized client object connected to dataAvailable";
- return;
- } else {
- QVariant var;
- while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
- receivePeerSignal(var);
- }
+ QVariant var;
+ while(readDataFromDevice(ioDev, _peerByteCount[ioDev], var))
+ receivePeerSignal(var);
}
void SignalProxy::writeDataToDevice(QIODevice *dev, const QVariant &item) {
blockSize = 0;
return true;
}
+
+void SignalProxy::dumpProxyStats() {
+ QString mode;
+ if(proxyMode() == Server)
+ mode = "Server";
+ else
+ mode = "Client";
+
+ int sigCount = 0;
+ foreach(SignalRelay *relay, _relayHash.values())
+ sigCount += relay->sigCount();
+
+ qDebug() << this;
+ qDebug() << " Proxy Mode:" << mode;
+ qDebug() << "attached sending Objects:" << _relayHash.count();
+ qDebug() << " Number of Signals:" << sigCount;
+ qDebug() << " attached Slots:" << _attachedSlots.count();
+ qDebug() << "number of Classes cached:" << _classInfo.count();
+}
getBufferInfoQuery = new QSqlQuery(logDb);
getBufferInfoQuery->prepare("SELECT bufferid FROM buffer "
"JOIN network ON buffer.networkid = network.networkid "
- "WHERE network.networkname = :networkname AND buffer.userid = :userid AND buffer.buffername = :buffername ");
+ "WHERE network.networkname = :networkname AND buffer.userid = :userid AND lower(buffer.buffername) = lower(:buffername)");
logMessageQuery = new QSqlQuery(logDb);
logMessageQuery->prepare("INSERT INTO backlog (time, bufferid, type, flags, senderid, message) "
"type INTEGER NOT NULL,"
"flags INTEGER NOT NULL,"
"senderid INTEGER NOT NULL,"
- "message TEXT NOT NULL)");
+ "message TEXT)");
logDb.exec("CREATE TABLE coreinfo ("
"updateid INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,"
BufferInfo SqliteStorage::getBufferInfo(UserId user, const QString &network, const QString &buffer) {
BufferInfo bufferid;
+ // TODO: get rid of this hackaround
uint networkId = getNetworkId(user, network);
getBufferInfoQuery->bindValue(":networkname", network);
getBufferInfoQuery->bindValue(":userid", user);
if(!getBufferInfoQuery->first()) {
createBuffer(user, network, buffer);
+ // TODO: get rid of this hackaround
+ networkId = getNetworkId(user, network);
getBufferInfoQuery->exec();
if(getBufferInfoQuery->first()) {
bufferid = BufferInfo(getBufferInfoQuery->value(0).toUInt(), networkId, 0, network, buffer);