void execute() override
{
auto* from_node = m_editor.getNodeByID(m_from);
auto* to_node = m_editor.getNodeByID(m_to);
removeConnection(from_node, m_from_pin, false);
removeConnection(to_node, m_to_pin, true);
from_node->m_outputs[m_from_pin] = to_node;
to_node->m_inputs[m_to_pin] = from_node;
}
void Server::handleNetworkMessages() {
RakNet::Packet* pPacket = nullptr;
while (true) {
CalculateDeltaTime();
for ( pPacket = m_pPeerInterface->Receive();
pPacket;
m_pPeerInterface->DeallocatePacket(pPacket), pPacket = m_pPeerInterface->Receive()) {
switch (pPacket->data[0]) {
case ID_NEW_INCOMING_CONNECTION: {
addNewConnection(pPacket->systemAddress);
std::cout << "A connection is incoming.\n";
break;
}
case ID_DISCONNECTION_NOTIFICATION:
std::cout << "A client has disconnected.\n";
removeConnection(pPacket->systemAddress);
break;
case ID_CONNECTION_LOST:
std::cout << "A client lost the connection.\n";
removeConnection(pPacket->systemAddress);
break;
case ID_CLIENT_CREATE_OBJECT:
{
RakNet::BitStream bsIn(pPacket->data, pPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
createNewObject(bsIn, pPacket->systemAddress);
break;
}
case ID_CLIENT_UPDATE_OBJECT_POSITION:
{
RakNet::BitStream bsIn(pPacket->data, pPacket->length, false);
bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
moveGameObject(bsIn, pPacket->systemAddress);
break;
}
case ID_CLIENT_UPDATE_OBJECT_VELOCITY:
{
pPacket->data[0] = ID_SERVER_VELOCITY_OBJECT_DATA;
RakNet::BitStream bsIn(pPacket->data, pPacket->length, false);
//bsIn.IgnoreBytes(sizeof(RakNet::MessageID));
m_pPeerInterface->Send(&bsIn, IMMEDIATE_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
break;
}
default:
std::cout << "Received a message with a unknown ID: " << pPacket->data[0];
break;
}
}
}
}
bool KAccelBase::setActionSlot(const QString &sAction, const QObject *pObjSlot, const char *psMethodSlot)
{
kdDebug(125) << "KAccelBase::setActionSlot( " << sAction << ", " << pObjSlot << ", " << psMethodSlot << " )\n";
KAccelAction *pAction = m_rgActions.actionPtr(sAction);
if(pAction)
{
// If there was a previous connection, remove it.
if(m_bAutoUpdate && pAction->isConnected())
{
kdDebug(125) << "\tm_pObjSlot = " << pAction->m_pObjSlot << " m_psMethodSlot = " << pAction->m_psMethodSlot << endl;
removeConnection(pAction);
}
pAction->m_pObjSlot = pObjSlot;
pAction->m_psMethodSlot = psMethodSlot;
// If we're setting a connection,
if(m_bAutoUpdate && pObjSlot && psMethodSlot)
insertConnection(pAction);
return true;
}
else
return false;
}
void DownloadManager::checkDownloads(UserConnection* aConn) {
dcassert(aConn->getDownload() == NULL);
QueueItem::Priority prio = QueueManager::getInstance()->hasDownload(aConn->getUser());
if(!startDownload(prio)) {
removeConnection(aConn);
return;
}
Download* d = QueueManager::getInstance()->getDownload(*aConn, aConn->isSet(UserConnection::FLAG_SUPPORTS_TTHL));
if(!d) {
Lock l(cs);
aConn->setState(UserConnection::STATE_IDLE);
idlers.push_back(aConn);
return;
}
aConn->setState(UserConnection::STATE_SND);
if(aConn->isSet(UserConnection::FLAG_SUPPORTS_XML_BZLIST) && d->getType() == Transfer::TYPE_FULL_LIST) {
d->setFlag(Download::FLAG_XML_BZ_LIST);
}
{
Lock l(cs);
downloads.push_back(d);
}
fire(DownloadManagerListener::Requesting(), d);
dcdebug("Requesting " I64_FMT "/" I64_FMT "\n", static_cast<long long int>(d->getStartPos()), static_cast<long long int>(d->getSize()));
aConn->send(d->getCommand(aConn->isSet(UserConnection::FLAG_SUPPORTS_ZLIB_GET)));
}
void ProcessorGraph::clearConnections()
{
for (int i = 0; i < getNumConnections(); i++)
{
const Connection* connection = getConnection(i);
if (connection->destNodeId == RESAMPLING_NODE_ID ||
connection->destNodeId == OUTPUT_NODE_ID)
{
; // leave it
}
else
{
removeConnection(i);
}
}
for (int i = 0; i < getNumNodes(); i++)
{
Node* node = getNode(i);
if (node->nodeId != OUTPUT_NODE_ID)
{
GenericProcessor* p =(GenericProcessor*) node->getProcessor();
p->resetConnections();
}
}
}
void NetInterface::disconnect(NetConnection *conn, NetConnection::TerminationReason reason, const char *reasonString)
{
if(conn->getConnectionState() == NetConnection::AwaitingChallengeResponse ||
conn->getConnectionState() == NetConnection::AwaitingConnectResponse)
{
conn->onConnectTerminated(reason, reasonString);
removePendingConnection(conn);
}
else if(conn->getConnectionState() == NetConnection::Connected)
{
conn->setConnectionState(NetConnection::Disconnected);
conn->onConnectionTerminated(reason, reasonString);
if(conn->isNetworkConnection())
{
// send a disconnect packet...
PacketStream out;
out.write(U8(Disconnect));
ConnectionParameters &theParams = conn->getConnectionParameters();
theParams.mNonce.write(&out);
theParams.mServerNonce.write(&out);
U32 encryptPos = out.getBytePosition();
out.setBytePosition(encryptPos);
out.writeString(reasonString);
if(theParams.mUsingCrypto)
{
SymmetricCipher theCipher(theParams.mSharedSecret);
out.hashAndEncrypt(NetConnection::MessageSignatureBytes, encryptPos, &theCipher);
}
out.sendto(mSocket, conn->getNetAddress());
}
removeConnection(conn);
}
}
void SimpleRecurrentNetwork::removeNeuron(int sp)
{
removeConnection(NUM_INPUTS + sp);
--numNeurons;
delete pop[sp];
pop.erase(pop.begin() + sp);
}
void QuickInterpreter::clear()
{
// printf("QuickInterpreter::clear()\n");
// Clear all connections
while (m_script_connections.size()) {
QHash<int, QSAConnection>::Iterator it = m_script_connections.begin();
// printf(" -> removing connection: %d\n", it.key());
removeConnection(it->sender, it->signal.toLatin1(), it->function_ref);
}
// clean out slots
delete m_dynamic_slots;
m_dynamic_slots = 0;
sourceIdNames.clear();
debuggerEngine()->clear();
qsKillTimers(env());
invalidateWrappers();
if(toplevel)
toplevel->clear();
QSEngine::clear();
QSEngine::init();
init();
}
bool Database::removeBase(QString filename)
{
emit toDebug(objectName(),
QString("Удаляем старую базу '%1'.").arg(filename));
removeConnection();
QFile f(filename);
if(f.exists())
{
if(f.remove())
{
emit toDebug(objectName(),
QString("База '%1' успешно удалена.").arg(filename));
return true;
}
else
{
emit toDebug(objectName(),
QString("Невозможно удалить файл '%1'. Ошибка: %2")
.arg(filename)
.arg(f.errorString()));
return false;
}
}
else
{
emit toDebug(objectName(),
QString("Невозможно удалить файл '%1'. Файл не существует.")
.arg(filename));
return true;
}
}
virtual void internalTransition(const vle::devs::Time& /*time*/)
{
if (mSended == false) {
// Ajout des connexions mod�le coupl� -> mod�le sum
const vle::vpz::ConnectionList& inputs = coupledmodel().getInputPortList();
vle::vpz::ConnectionList::const_iterator it;
/* DEBUG : affiche les connections
for (it = inputs.begin(); it != inputs.end(); ++it) {
std::cout << "model: " << getModel().getParentName() << it->first << std::endl;
}*/
for (it = inputs.begin(); it != inputs.end(); ++it) {
if (it->first.size() >= 5 and it->first.compare(0, 5, "node-") == 0) {
addInputPort("Deposition", it->first);
addConnection(coupledmodelName(), it->first, "Deposition", it->first);
mPortList.push_back(it->first);
}
}
// Pour les mod�les sans d�pendances
if (mPortList.empty()){
createModelFromClass("node-init", "node-init");
//delModel("Deposition");
removeConnection("Deposition", "update", "Unit", "in");
addConnection("node-init", "update", "Unit", "in");
}
mSended = true;
} else {
mSended = false;
}
}
void AutomatableModelViewSlots::execConnectionDialog()
{
// TODO[pg]: Display a dialog with list of controllers currently in the song
// in addition to any system MIDI controllers
AutomatableModel* m = m_amv->modelUntyped();
m->displayName();
ControllerConnectionDialog d( (QWidget*) engine::mainWindow(), m );
if( d.exec() == 1 )
{
// Actually chose something
if( d.chosenController() )
{
// Update
if( m->controllerConnection() )
{
m->controllerConnection()->setController( d.chosenController() );
}
// New
else
{
ControllerConnection* cc = new ControllerConnection( d.chosenController() );
m->setControllerConnection( cc );
//cc->setTargetName( m->displayName() );
}
}
// no controller, so delete existing connection
else
{
removeConnection();
}
}
}
void NetInterface::handleDisconnect(const Address &address, BitStream *stream)
{
NetConnection *conn = findConnection(address);
if(!conn)
return;
ConnectionParameters &theParams = conn->getConnectionParameters();
Nonce nonce, serverNonce;
char reason[256];
nonce.read(stream);
serverNonce.read(stream);
if(nonce != theParams.mNonce || serverNonce != theParams.mServerNonce)
return;
U32 decryptPos = stream->getBytePosition();
stream->setBytePosition(decryptPos);
if(theParams.mUsingCrypto)
{
SymmetricCipher theCipher(theParams.mSharedSecret);
if(!stream->decryptAndCheckHash(NetConnection::MessageSignatureBytes, decryptPos, &theCipher))
return;
}
stream->readString(reason);
conn->setConnectionState(NetConnection::Disconnected);
conn->onConnectionTerminated(NetConnection::ReasonRemoteDisconnectPacket, reason);
removeConnection(conn);
}
void ConnectionManager::removePoint(Connection *c, int point) {
c->points.erase(c->points.begin() + point);
if (c->points.size() < 2) {
removeConnection(c);
}
movePins(c->from);
movePins(c->to);
}
void NetHandler::doCloseConnection(int fd)
{
if (fd > 0)
{
FD_CLR(fd, &master);
shutdown(fd, SD_BOTH);
removeConnection(fd);
}
}
void WindowSystem::handleConnection()
{
qDebug() << "SERVER: client connected";
if (QTcpSocket *connection = m_server->nextPendingConnection()) {
connect(connection, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(handleConnectionError()));
connect(connection, SIGNAL(readyRead()), this, SLOT(handleRequest()));
connect(connection, SIGNAL(disconnected()), this, SLOT(removeConnection()));
}
}
void Network::adminStop(){
ConnMap::iterator itcurr = connections.begin();
while (itcurr != connections.end()) {
if ( itcurr->second->getType() == Connection::ADMIN ||
itcurr->second->getType() == Connection::LISTENADMIN )
removeConnection(itcurr->first);
++itcurr;
}
}
void ManaChatServer::addConnection()
{
qDebug() <<"new connect";
QTcpSocket* connection = nextPendingConnection();
connections.append(connection);
QBuffer* buffer = new QBuffer(this);
buffer->open(QIODevice::ReadWrite);
buffers.insert(connection, buffer);
connect(connection, SIGNAL(disconnected()), SLOT(removeConnection()));
connect(connection, SIGNAL(readyRead()), SLOT(receiveMessage()));
}
void OutgoingStreamTubeChannel::onContactsRetrieved(
const QUuid &uuid,
const QList<Tp::ContactPtr> &contacts)
{
if (!isValid()) {
debug() << "Invalidated OutgoingStreamTubeChannel not emitting queued connection event";
return;
}
if (!mPriv->pendingNewConnections.contains(uuid)) {
if (mPriv->pendingClosedConnections.contains(uuid)) {
// closed connection
Private::ClosedConnection conn = mPriv->pendingClosedConnections.take(uuid);
// First, do removeConnection() so connectionClosed is emitted, and anybody connected to it
// (like StreamTubeServer) has a chance to recover the source address / contact
removeConnection(conn.id, conn.error, conn.message);
// Remove stuff from our hashes
mPriv->contactsForConnections.remove(conn.id);
QHash<QPair<QHostAddress, quint16>, uint>::iterator srcAddrIter =
mPriv->connectionsForSourceAddresses.begin();
while (srcAddrIter != mPriv->connectionsForSourceAddresses.end()) {
if (srcAddrIter.value() == conn.id) {
srcAddrIter = mPriv->connectionsForSourceAddresses.erase(srcAddrIter);
} else {
++srcAddrIter;
}
}
QHash<uchar, uint>::iterator credIter = mPriv->connectionsForCredentials.begin();
while (credIter != mPriv->connectionsForCredentials.end()) {
if (credIter.value() == conn.id) {
credIter = mPriv->connectionsForCredentials.erase(credIter);
} else {
++credIter;
}
}
} else {
warning() << "No pending connections found in OSTC" << objectPath() << "for contacts"
<< contacts;
}
return;
}
// new connection
QPair<uint, QDBusVariant> connectionProperties = mPriv->pendingNewConnections.take(uuid);
// Add it to our connections hash
foreach (const Tp::ContactPtr &contact, contacts) {
mPriv->contactsForConnections.insert(connectionProperties.first, contact);
}
void DownloadManager::on(UserConnectionListener::Failed, UserConnection* aSource, const string& aError) throw() {
Download* d = aSource->getDownload();
if(d == NULL) {
removeConnection(aSource);
return;
}
fire(DownloadManagerListener::Failed(), d, aError);
string target = d->getTarget();
aSource->setDownload(NULL);
removeDownload(d, true);
if(aError.find("File Not Available") != string::npos || aError.find(" no more exists") != string::npos) { //solved DCTC
QueueManager::getInstance()->removeSource(target, aSource->getUser(), QueueItem::Source::FLAG_FILE_NOT_AVAILABLE, false);
}
removeConnection(aSource);
}
void DownloadManager::on(UserConnectionListener::Data, UserConnection* aSource, const u_int8_t* aData, size_t aLen) throw() {
Download* d = aSource->getDownload();
dcassert(d != NULL);
try {
d->addPos(d->getFile()->write(aData, aLen), aLen);
if(d->getPos() > d->getSize()) {
throw Exception(STRING(TOO_MUCH_DATA));
} else if(d->getPos() == d->getSize()) {
handleEndData(aSource);
aSource->setLineMode();
}
} catch(const RollbackException& e) {
string target = d->getTarget();
QueueManager::getInstance()->removeSource(target, aSource->getUser(), QueueItem::Source::FLAG_ROLLBACK_INCONSISTENCY);
fire(DownloadManagerListener::Failed(), d, e.getError());
d->resetPos();
aSource->setDownload(NULL);
removeDownload(d, true);
removeConnection(aSource);
return;
} catch(const FileException& e) {
fire(DownloadManagerListener::Failed(), d, e.getError());
d->resetPos();
aSource->setDownload(NULL);
removeDownload(d, true);
removeConnection(aSource);
return;
} catch(const Exception& e) {
fire(DownloadManagerListener::Failed(), d, e.getError());
// Nuke the bytes we have written, this is probably a compression error
d->resetPos();
aSource->setDownload(NULL);
removeDownload(d, true);
removeConnection(aSource);
return;
}
}
/*!
* Disconnects the connection with the specified \a clientID.
*
* Implementations should invoke this function when the connection should no longer be
* used; for instance, when the QIODevice object is destroyed or the connection has been
* closed. Code that uses the connection manager service should invoke this function to
* close a connection on demand.
*/
void QxtAbstractConnectionManager::disconnect(quint64 clientID)
{
QIODevice* device = qxt_d().clients.value(clientID, 0);
if (!device)
{
qWarning() << "QxtAbstractConnectionManager::disconnect: client ID not in use";
return;
}
qxt_d().clients.remove(clientID);
emit disconnected(device, clientID);
removeConnection(device, clientID);
}
void UploadManager::on(UserConnectionListener::Failed, UserConnection* aSource, const string& aError) throw() {
Upload* u = aSource->getUpload();
if(u) {
fire(UploadManagerListener::Failed(), u, aError);
dcdebug("UM::onFailed: Removing upload\n");
removeUpload(u);
}
removeConnection(aSource);
}
void NetHandler::doCloseConnection(int fd)
{
if (fd > 0)
{
struct epoll_event ev;
epoll_ctl(epfd, EPOLL_CTL_DEL, fd, &ev);
shutdown(fd, SHUT_RDWR);
close(fd);
LOG4CXX_DEBUG(logger_, "Connection with fd " << fd << " is really closed >_<");
removeConnection(fd);
}
}
// ---------------------------------------------------------------------------
// PosSettingsForm::~PosSettingsForm
// Destructor
// ---------------------------------------------------------------------------
PosSettingsForm::~PosSettingsForm()
{
qDebug() << "+ PosSettingsForm::PosSettingsForm()";
// Remove custom layouts
HbStyleLoader::unregisterFilePath(FILE_PATH_CSS);
//TODO Disconnect of mSettingsEngine positionTechnologyChange
removeConnection( mAdvancedSettings, SIGNAL(clicked()),
this, SLOT(onPressedAdvanced()) );
removeConnection( mGpsPosType, SIGNAL(released),
this, SLOT(onPressedGps()) );
removeConnection( mWirelessPosType, SIGNAL(released),
this, SLOT(onPressedWireless()) );
removeConnection( mBgPosType, SIGNAL(released),
this, SLOT(onPressedBackground()) );
//ToDo: removeAllConnection crashes with Kern-Exec3 error
//removeAllConnection();
qDebug() << "- PosSettingsForm::PosSettingsForm()";
}
void DownloadManager::failDownload(UserConnection* aSource, const string& reason) {
Download* d = aSource->getDownload();
if(d) {
removeDownload(d);
fire(DownloadManagerListener::Failed(), d, reason);
QueueManager::getInstance()->putDownload(d, false);
}
removeConnection(aSource);
}
void MainWindow::addConnection()
{
QTcpSocket * s;
s = server.nextPendingConnection();
stUserInfo user;
user.pTcpSocket = s;
list.append(user);
connect(s,SIGNAL(disconnected()),this,SLOT(removeConnection()));
connect(s,SIGNAL(readyRead()),this,
SLOT(recvMsg()));
ui->textEdit->append(QString("새로운 사용자입장"));
}
/**
* Disconnect a pin.
*/
void VimusGUIPin::disconnect(VimusGUIPin *pin)
{
for (int i=0; i<numConnections; i++)
{
// check if it is really connected.
if ((connections[i]->indexOnParent == pin->indexOnParent)
&& (connections[i]->parentIndex == pin->parentIndex))
{
removeConnection(i);
pin->disconnect(this);
return;
}
}
}
//! remove all connections to and from ports to a module
void PortManager::removeConnections(const int moduleID) {
typedef std::map<std::string, Port *> PortMap;
typedef std::map<int, PortMap *> ModulePortMap;
ModulePortMap::const_iterator mports = m_ports.find(moduleID);
if (mports == m_ports.end())
return;
const PortMap &portmap = *mports->second;
for(PortMap::const_iterator it = portmap.begin();
it != portmap.end();
++it) {
Port *port = it->second;
const Port::PortSet &cl = port->connections();
while (!cl.empty()) {
size_t oldsize = cl.size();
const Port *other = *cl.begin();
removeConnection(port, other);
removeConnection(other, port);
message::Disconnect d1(port->getModuleID(), port->getName(), other->getModuleID(), other->getName());
m_clusterManager->sendAll(d1);
m_clusterManager->sendUi(d1);
message::Disconnect d2(other->getModuleID(), other->getName(), port->getModuleID(), port->getName());
m_clusterManager->sendAll(d2);
m_clusterManager->sendUi(d2);
if (cl.size() == oldsize) {
std::cerr << "failed to remove all connections for module " << moduleID << ", still left: " << cl.size() << std::endl;
for (size_t i=0; i<cl.size(); ++i) {
std::cerr << " " << port->getModuleID() << ":" << port->getName() << " <--> " << other->getModuleID() << ":" << other->getName() << std::endl;
}
break;
}
}
}
}
void rc_server::addConnection()
{
QTcpSocket* connection = nextPendingConnection();
qDebug() << "<rc_server>: I have accepted a new connection request.";
connections.append(connection);
QBuffer* buffer = new QBuffer(this);
buffer->open(QIODevice::ReadWrite);
/* buffers is of <QHash> datatype, ie. with connection object used as the key.
This is a good idea to store information from different connected clients in an organized way.*/
buffers.insert(connection, buffer);
connect(connection, SIGNAL(disconnected()), SLOT(removeConnection()));
connect(connection, SIGNAL(readyRead()), SLOT(receiveMessage()));
}
void DownloadManager::on(UserConnectionListener::MaxedOut, UserConnection* aSource) throw() {
if(aSource->getState() != UserConnection::STATE_FILELENGTH && aSource->getState() != UserConnection::STATE_TREE) {
dcdebug("DM::onMaxedOut Bad state, ignoring\n");
return;
}
Download* d = aSource->getDownload();
dcassert(d != NULL);
fire(DownloadManagerListener::Failed(), d, STRING(NO_SLOTS_AVAILABLE));
aSource->setDownload(NULL);
removeDownload(d, true);
removeConnection(aSource);
}
