void SamplerApollo::unregisterNodeHelper(void* ptr)
{
ASSERT(ptr);
WTF::RefPtr<BaseSamplerNode> node(getSamplerNodeFor(ptr));
if(node.get())
unregisterNode(node.release());
}
void ContextPrivate::clear( void )
{
for( QUuid ID : mNodeHash.keys() )
{
unregisterNode( ID );
}
// disconnect all pins
for( QUuid PID : mConnectIO.keys() )
{
disconnectPin( PID );
}
for( QSharedPointer<fugio::NodeInterface> N : mNodeHash.values() )
{
if( NodePrivate *NP = qobject_cast<NodePrivate *>( N->qobject() ) )
{
NP->clear();
}
}
emit clearContext();
QMutexLocker MutLck( &mUpdatePinMapMutex );
mUpdatedNodeList.clear();
mFinishedNodeList.clear();
mInitDeferNodeList.clear();
mUpdatePinMap.clear();
mNodeHash.clear();
mPinHash.clear();
mConnectIO.clear();
mConnectOI.clear();
mMetaInfoMap.clear();
}
Net_Node::~Net_Node() {
unregisterNode(this);
intern->publicOwner = NULL;
intern = NULL;
}
void Net_Control::Net_processInput() {
for(NetControlIntern::Packages::iterator i = intern->packetsReceived.begin(); i != intern->packetsReceived.end(); ++i) {
switch(i->type) {
case NetControlIntern::DataPackage::GPT_Direct:
Net_cbDataReceived(i->connID, i->data);
break;
case NetControlIntern::DataPackage::GPT_ConnectRequest: {
if(!intern->isServer) {
warnings << "Net_processInput: got GPT_ConnectRequest as client" << endl;
break;
}
CServerConnection* cl = serverConnFromNetConnID(i->connID);
if(cl == NULL) {
errors << "Net_processInput GPT_ConnectRequest: didn't found connection for id " << i->connID << endl;
break;
}
if(cl->gusLoggedIn()) {
warnings << "Net_processInput GPT_ConnectRequest: client " << i->connID << " was already logged in" << endl;
break;
}
// in olxSend, when we handle this package, we set gusLoggedIn() = true
NetControlIntern::DataPackage& p = intern->pushPackageToSend();
p.connID = i->connID;
p.sendMode = eNet_ReliableOrdered;
p.repRules = Net_REPRULE_NONE;
p.type = NetControlIntern::DataPackage::GPT_ConnectResult;
p.data.addInt(i->connID, 32); // we tell client about its connection ID
tellClientAboutAllNodes(this->intern, i->connID);
Net_cbConnectionSpawned(i->connID);
break;
}
case NetControlIntern::DataPackage::GPT_ConnectResult: {
if(intern->isServer) {
warnings << "Net_processInput: got GPT_ConnectResult as server" << endl;
break;
}
intern->myConnIdOnServer = i->data.getInt(32);
Net_cbConnectResult(eNet_ConnAccepted);
break;
}
case NetControlIntern::DataPackage::GPT_NodeInit: {
if(intern->isServer) {
warnings << "Net_processInput: got GPT_NodeInit as server" << endl;
break;
}
Net_ClassID classId = i->data.getInt(32);
Net_ConnID ownerConnId = i->data.getInt(32);
NetControlIntern::Class* nodeClass = intern->getClass(classId);
if(nodeClass == NULL) {
warnings << "NodeInit for node " << i->nodeId << " with class " << classId << " failed because that class is unknown" << endl;
break;
}
intern->cbNodeRequest_Dynamic = true;
intern->cbNodeRequest_nodeId = i->nodeId;
bool announce = nodeClass->flags & Net_CLASSFLAG_ANNOUNCEDATA;
eNet_NodeRole role = (ownerConnId == intern->myConnIdOnServer) ? eNet_RoleOwner : eNet_RoleProxy;
Net_cbNodeRequest_Dynamic(i->connID, classId, announce ? &i->data : NULL, role, i->nodeId);
if(intern->cbNodeRequest_Dynamic) { // we didnt created the node - otherwise this would be false
errors << "Net_cbNodeRequest_Dynamic callback didnt created the node " << i->nodeId << " with class " << classId << endl;
intern->cbNodeRequest_Dynamic = false; // reset anyway
break;
}
Net_Node* node = intern->getNode(i->nodeId);
if(node == NULL) {
errors << "NodeInit: node " << i->nodeId << " not found after dynamic creation" << endl;
break;
}
node->intern->ownerConn = ownerConnId;
node->intern->role = role;
if(node->intern->classId != classId)
warnings << "NodeInit requested a node of class " << classId << " but a node of class " << node->intern->classId << " was created" << endl;
break;
}
case NetControlIntern::DataPackage::GPT_NodeRemove: {
if(intern->isServer) {
warnings << "Net_processInput: got GPT_NodeRemove as server" << endl;
break;
}
Net_Node* node = intern->getNode(i->nodeId);
if(node == NULL) {
warnings << "NodeRemove: node " << i->nodeId << " not found" << endl;
break;
}
// we are proxy or owner -> in any case, always push this event
node->intern->incomingEvents.push_back( NetNodeIntern::Event::NodeRemoved(i->connID) );
unregisterNode(node);
break;
}
case NetControlIntern::DataPackage::GPT_NodeUpdate: {
Net_Node* node = intern->getNode(i->nodeId);
if(node == NULL) {
warnings << "NodeUpdate: node " << i->nodeId << " not found" << endl;
break;
}
if(intern->isServer) {
if(node->intern->ownerConn != i->connID) {
warnings << "Net_processInput: got GPT_NodeUpdate as server from proxy" << endl;
break;
}
}
doNodeUpdate(node, i->data, i->connID);
break;
}
case NetControlIntern::DataPackage::GPT_NodeEvent: {
Net_Node* node = intern->getNode(i->nodeId);
if(node == NULL) {
warnings << "NodeEvent: node " << i->nodeId << " not found" << endl;
break;
}
if(intern->isServer) {
if(node->intern->ownerConn != i->connID) {
warnings << "NodeEvent: got event for node " << i->nodeId << " from non-owner " << i->connID << ", owner is " << node->intern->ownerConn << endl;
break;
}
}
node->intern->incomingEvents.push_back( NetNodeIntern::Event::User(i->data, i->connID) );
break;
}
case NetControlIntern::DataPackage::GPT_UniqueNodeEvent: {
Net_ClassID classId = readEliasGammaNr(i->data);
NetControlIntern::Class* c = intern->getClass(classId);
if(c == NULL) {
warnings << "UniqueNodeEvent: class " << classId << " not found" << endl;
break;
}
Net_Node* node = intern->getLocalNode(classId);
if(node == NULL) {
warnings << "UniqueNodeEvent: unique node of class " << c->name << " not found" << endl;
break;
}
node->intern->incomingEvents.push_back( NetNodeIntern::Event::User(i->data, i->connID) );
break;
}
default:
warnings << "invalid Gusanos data package type" << endl;
}
}
intern->packetsReceived.clear();
}
