Connector* ObjController::addConnector(ObjectsHolder* holder,
BaseObjectComponent* objComp,
ObjectComponent* audioOutComp,
ValueTree source,
int index,
bool undoable)
{
if(undoable)
{
AddAudioConnectionAction* action = new AddAudioConnectionAction(
this, objComp, source, audioOutComp, holder);
owner.getUndoManager().perform(action, "Add new audio connection");
return connections[action->indexAdded];
}
else
{
Connector* conn = new Connector(*this, objComp, audioOutComp);
ValueTree sources = conn->getTargetObject()->getData().getChildWithName(Ids::sources);
if(! sources.getChildWithProperty(Ids::value, source[Ids::value]).isValid())
sources.addChild(source, -1, nullptr);
connections.insert(index, conn);
holder->addAndMakeVisible(conn);
conn->update();
conn->toBack();
return conn;
}
return nullptr;
}
Connector *CircuitICNDocument::createConnector( const QString &startNodeId, const QString &endNodeId, QPointList *pointList )
{
ECNode *startNode = getEcNodeWithID(startNodeId);
ECNode *endNode = getEcNodeWithID(endNodeId);
if ( !startNode || !endNode ) {
kDebug() << "Either/both the connector start node and end node could not be found" << endl;
return 0L;
}
if ( !canConnect( startNode, endNode ) ) return 0l;
Connector *connector = endNode->createConnector(startNode);
if (!connector) {
kError() << k_funcinfo << "End node did not create the connector" << endl;
return 0l;
}
startNode->addConnector(connector);
flushDeleteList(); // Delete any connectors that might have been removed by the nodes
// Set the route to the manual created one if the user created such a route
if(pointList) connector->setRoutePoints(*pointList,true);
// FIXME WTF is going on here? Redundant/meaningless code?
// ConnectorList connectorList;
// connectorList.append(connector);
setModified(true);
requestRerouteInvalidatedConnectors();
return connector;
}
void test_Connector::isNotType() {
Connector connector = Connector();
Connector same = Connector();
Connector different(N_50_OHM_CONNECTOR, MALE_GENDER);
QVERIFY(connector.isNotType(same) == false);
QVERIFY(connector.isNotType(different));
}
void JunctionFlowNode::drawShape ( QPainter &p )
{
const int _x = ( int ) x();
const int _y = ( int ) y();
if ( !m_inFlowConnList.isEmpty() )
{
const FlowConnectorList::iterator end = m_inFlowConnList.end();
for ( FlowConnectorList::iterator it = m_inFlowConnList.begin(); it != end; ++ it )
{
Connector * connector = *it;
if ( !connector )
continue;
// Work out the direction of the connector
const QPointList points = connector->connectorPoints ( false );
const int count = points.size();
if ( count < 2 )
continue;
QPoint end_0 = points[count-1];
QPoint end_1 = points[count-2];
Q3PointArray pa;
if ( end_0.x() < end_1.x() )
{
pa = arrowPoints ( 180 );
pa.translate ( 4, 0 );
}
else if ( end_0.x() > end_1.x() )
{
pa = arrowPoints ( 0 );
pa.translate ( -4, 0 );
}
else if ( end_0.y() < end_1.y() )
{
pa = arrowPoints ( 270 );
pa.translate ( 0, 4 );
}
else if ( end_0.y() > end_1.y() )
{
pa = arrowPoints ( 90 );
pa.translate ( 0, -4 );
}
else continue;
pa.translate ( _x, _y );
p.setPen ( connector->isSelected() ? m_selectedColor : Qt::black );
p.drawPolygon ( pa );
}
return;
}
if ( m_dir == 0 ) p.drawLine ( _x, _y, _x-8, _y );
else if ( m_dir == 90 ) p.drawLine ( _x, _y, _x, _y-8 );
else if ( m_dir == 180 ) p.drawLine ( _x, _y, _x+8, _y );
else if ( m_dir == 270 ) p.drawLine ( _x, _y, _x, _y+8 );
}
static Connector extractConnector(DOMDocument * domDocument, DOMTreeWalker * domTreeWalker) {
Connector connector;
DOMNode * node = domTreeWalker->getCurrentNode();
while (node) {
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "SrcAddress") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
PortAddress portAddress = extractPortAddress(domDocument, d);
connector.setSrcAddress(portAddress);
d->release();
delete nodeFilter;
}
if (XMLString::compareString(XMLString::transcode(node->getNodeName()), "DstAddress") == 0) {
XMLNodeFilter * nodeFilter = new XMLNodeFilter();
DOMTreeWalker * d = domDocument->createTreeWalker(node, DOMNodeFilter::SHOW_ALL, nodeFilter, true);
PortAddress portAddress = extractPortAddress(domDocument, d);
connector.setDstAddress(portAddress);
d->release();
delete nodeFilter;
}
node = domTreeWalker->nextNode();
}
return connector;
}
error *objectConnect(QObject_ *object, const char *signal, int signalLen, QQmlEngine_ *engine, void *func, int argsLen)
{
QObject *qobject = reinterpret_cast<QObject *>(object);
QQmlEngine *qengine = reinterpret_cast<QQmlEngine *>(engine);
QByteArray qsignal(signal, signalLen);
const QMetaObject *meta = qobject->metaObject();
// Walk backwards so descendants have priority.
for (int i = meta->methodCount()-1; i >= 0; i--) {
QMetaMethod method = meta->method(i);
if (method.methodType() == QMetaMethod::Signal) {
QByteArray name = method.name();
if (name.length() == signalLen && qstrncmp(name.constData(), signal, signalLen) == 0) {
if (method.parameterCount() < argsLen) {
// TODO Might continue looking to see if a different signal has the same name and enough arguments.
return errorf("signal \"%s\" has too few parameters for provided function", name.constData());
}
Connector *connector = Connector::New(qobject, method, qengine, func, argsLen);
const QMetaObject *connmeta = connector->metaObject();
QObject::connect(qobject, method, connector, connmeta->method(connmeta->methodOffset()));
return 0;
}
}
}
// Cannot use constData here as the byte array is not null-terminated.
return errorf("object does not expose a \"%s\" signal", qsignal.data());
}
USING_NAMESPACE
int main()
{
Stream stream;
Connector connector;
if( connector.connect(stream, InterAddress(6000, "127.0.0.1"), TimeValue(1)) )
{
char ip[20]; int32 port;
stream.getLocalAddress(ip, port);
printf("local addr:[%s][%d]\n", ip, port);
char buf[100] = "hello world!";
if( SOCKET_ERROR != stream.send(buf, strlen(buf)) )
printf("send successed!\n");
char recvbuf[100];
memset(recvbuf, 0, sizeof(recvbuf));
if (SOCKET_ERROR != stream.recv(recvbuf, 100))
printf("recv: %s", recvbuf);
}
else
{
printf("Connector failed!!");
}
getchar();
return 0;
}
void Select::Execute()
{
Input *pIn = pManager->GetInput();
Output *pOut = pManager->GetOutput();
Statement *SelectedStatement;
Connector* SelectedConnector;
int Type;
SelectedStatement = pManager->GetStatement(this->Position, Type);
SelectedConnector = pManager->GetConnector(this->Position);
if (SelectedStatement != NULL || SelectedConnector != NULL)
{
if (SelectedStatement)
{
SelectedStatement->SetSelected(!SelectedStatement->IsSelected());
pManager->UpdateSelectedStatements(SelectedStatement);
}
else
{
SelectedConnector->SetSelected(!SelectedConnector->IsSelected());
pManager->UpdateSelectedConnectors(SelectedConnector);
}
}
if (pManager->GetSelectedStatements().size() == 1)
pManager->GetOutput()->PrintMessage(pManager->GetSelectedStatements().front()->GetComment());
else
pManager->GetOutput()->PrintMessage("");
pManager->UpdateInterface();
}
void Run()
{
Connector* pConnector = (Connector*)GetArg();
while (IsRunnable())
{
if (TRUE == InterlockedCompareExchange((LONG*)& pConnector->_IsConnected, TRUE, TRUE))
{
Wait(pConnector->_ProcessTime);
}
else
{
Logger::Log("%s Connector Try Connect\n", GetName());
int rc = pConnector->DoConnect();
if (0 != rc)
{
Logger::Log("%s Connector Connect Fail :%d\n", GetName(), rc);
Wait(pConnector->_RetryTime);
}
else
{
Logger::Log("%s Connector Connect Success\n", GetName());
}
}
}
}
void TCPServer::run()
{
_run = true;
HANDLE hCompletion = this->_iocp;
SYSTEM_INFO info;
GetSystemInfo(&info);
_dispatcherCount = info.dwNumberOfProcessors * 2;
_dispatcher = new HANDLE[_dispatcherCount];
for (int i = 0; i < _dispatcherCount; i++)
{
_dispatcher[i] = ::CreateThread(NULL, 0, DispatchThread, (LPVOID)this, 0, 0);
}
//----------------------
// Accept the connection.
while (_run)
{
SOCKADDR_IN saRemote;
int nRemoteLen = sizeof(saRemote);
SOCKET client = accept(this->_server, (sockaddr *)&saRemote, &nRemoteLen);
if (client == INVALID_SOCKET)
{
printError(L"accept socket");
continue;
}
Connector *pPerHandle = new Connector(saRemote, nRemoteLen, client);
::CreateIoCompletionPort((HANDLE)client, hCompletion, (ULONG_PTR)pPerHandle, 0);
pPerHandle->postRead();
}
// No longer need server socket
closesocket(this->_server);
}
int
enable_CA()
{
Channel *chan;
Connector *conp;
if( processFlag == 0 )
processFlag = epicsMutexCreate();
epicsMutexLock( processFlag);
startupFlag = 0;
for( chan=reProcessList; chan; chan = chan->next_proc)
{
chan->reprocess = 0;
/*
* update the data values
*/
for( conp=chan->first_connector; conp ; conp=conp->next_chan)
{
if( conp->newState)
(*conp->newState)(conp);
DEBUGP printf("Calling function %p\n", conp->update);
if( conp->update)
conp->update(conp);
}
}
epicsMutexUnlock(processFlag);
return 0;
}
int Server_Connection::open(void *acceptor_or_connector)
{
typedef Connector<Server_Connection, ACE_SOCK_CONNECTOR> Connector;
Connector *connector = static_cast<Connector*>(acceptor_or_connector);
m_holder = connector->holder();
return Connection::open(acceptor_or_connector);
}
/*!
* \brief Performs a connector type comparison with \c other
*
* Returns true if \c this and \c other are the same
* connector type. For user-defined connector types, the
* string representing the type are compared.
*
* \note User-defined types are case-sensitive.
*
* \param other Connector to compare
* \return Result of connector type comparison
* \sa isNotType()
*/
bool Connector::isType(const Connector &other) const {
if (isNotCustomType())
return(type() == other.type());
else if (other.isNotCustomType())
return(false);
else
return(customType() == other.customType());
}
Sender *
Invocation_Thread::create_connection (void)
{
int result = 0;
// Connector for creating new connections.
Connector connector (this->thread_manager_,
this->reactor_,
this->nested_upcalls_);
// <server_handle> is a global variable. It will be used later by
// the Close_Socket_Thread.
result =
connector.connect (client_handle,
server_handle,
this->run_receiver_thread_);
ACE_TEST_ASSERT (result == 0);
ACE_UNUSED_ARG (result);
// Create a new sender.
Sender *sender =
new Sender (client_handle,
this->connection_cache_);
// Register it with the cache.
this->connection_cache_.add_connection (sender);
//
// There might be a race condition here. The sender has been added
// to the cache and is potentially available to other threads
// accessing the cache. Therefore, the other thread may use this
// sender and potentially close the sender before it even gets
// registered with the Reactor.
//
// This is resolved by marking the connection as busy when it is
// first added to the cache. And only once the thread creating the
// connection is done with it, it is marked a available in the
// cache.
//
// This order of registration is important.
//
// Register the handle with the Reactor.
result =
this->reactor_.register_handler (client_handle,
sender,
ACE_Event_Handler::READ_MASK);
#if 0
ACE_TEST_ASSERT (result == 0);
ACE_UNUSED_ARG (result);
#else
if (result != 0)
ACE_ERROR ((LM_ERROR, ACE_TEXT ("(%t) create_connection h %d, %p\n"),
client_handle,
ACE_TEXT ("register_handler")));
#endif
return sender;
}
void kdrive::connector::raiseError(Connector& connector, const Exception& exception)
{
const int errorCode = exception.code() ? exception.code() : ConnectorErrorCodes::ConnectorError;
connector.setLastErrorCode(errorCode);
connector.setLastErrorMessage(exception.displayText());
connector.routeEvent(ConnectorEvents::Error);
exception.rethrow();
}
bool CircuitICNDocument::joinConnectors( ECNode *node )
{
// We don't want to destroy the node if it has a parent
if ( node->parentItem() ) return false;
node->removeNullConnectors();
// an electronic node can be removed if it has exactly 2 connectors connected to it
int conCount = node->getAllConnectors().count();
if ( conCount != 2 ) return false;
Connector *con1, *con2;
ECNode *startNode = NULL;
ECNode *endNode = NULL;
QPointList conPoints;
con1 = node->connectorList().at(0).data();
con2 = node->connectorList().at(1).data();
if ( con1 == con2 ) return false;
// we don't know on which end of the connectors is our node, so we must check both ends
// HACK // TODO // dynamic_cast used, because Connector doesn't know about ECNode, only Node
if( con1->startNode() == node )
startNode = dynamic_cast<ECNode*> ( con1->endNode() );
else startNode = dynamic_cast<ECNode*> ( con1->startNode() );
if( con2->startNode() == node )
endNode = dynamic_cast<ECNode*> ( con2->endNode() );
else endNode = dynamic_cast<ECNode*> ( con2->startNode() );
conPoints = con1->connectorPoints(false) + con2->connectorPoints(false);
if( !startNode || !endNode ) return false;
Connector *newCon = endNode->createConnector(startNode);
if(!newCon) return false;
startNode->addConnector(newCon);
newCon->setRoutePoints( conPoints, con1->usesManualPoints() || con2->usesManualPoints() );
// Avoid flicker: update draw lists now
con1->updateConnectorPoints(false);
con2->updateConnectorPoints(false);
newCon->updateDrawList();
node->removeNode();
con1->removeConnector();
con2->removeConnector();
return true;
}
void ConnectorFactoryTest::dispose_removes_points()
{
Connector *connector = new Connector(Point(42, 57));
RelativePosition pp(Point(0, 0));
connector->addPoint(&pp);
ConnectorFactory::dispose(connector);
CPPUNIT_ASSERT(&connector->getPosition() != pp.getAnchor());
}
void main_connect()
{
ACE_INET_Addr addr(PORT_NO, "192.168.0.56");
Connector myconnector;
My_Svc_Handler *my_svc_handler = new My_Svc_Handler;
myconnector.connect(my_svc_handler, addr);
while(1)
Reactor::instance()->handle_events();
return;
}
void TF_2Port::Evaluate (Path* path) {
Transfer();
for (int i = 0; i < Outputs(); ++i) {
if (ChangedOutput(i)) {
StateVar* output = GetOutput(i);
Connector* conn = GetBinding(output);
conn->Transmit(path);
}
}
}
void CanvasView::flowThreChanged(int iSpeed, int iIndex)
{
QList<CanvasItem *> canvas_items = canvas()->items();
for (int i = 0; i < canvas_items.size(); ++i)
{
Connector *conn = dynamic_cast<Connector *>(canvas_items.at(i));
if (conn)
{
conn->setFlowThreshold(iSpeed, iIndex);
}
}
}
static string format_connector(Connector& c)
{
string str;
str = sformat("Connector %u (%u) %s",
c.idx(), c.id(), c.fullname().c_str());
if (c.connected())
str += " (connected)";
return str;
}
int main()
{
signal(SIGPIPE, SIG_IGN);
signal(SIGINT, sigExit);
signal(SIGTERM, sigExit);
signal(SIGUSR1, sigSend);
PfAuth* auth = PfAuth::singleton();
auth->initialize("./pfauth.ini");
Connector* conn = auth->createConn();
int i = 0;
uint64_t last_send = 0;
uint64_t now = 0;
int ret;
while( !g_stop )
{
AuthMsg msg;
msg.user_id = "31504325";
msg.user_name = "zhy770129";
msg.time = "1260247189";
msg.flag = "be6fe47bdda836b8cebb27e869e67f7c";
msg.game_id = 707;
msg.cmd_id = 0x10003801;
SysTimeValue::getTickCount(&now);
if ( now - last_send > 400 && g_send )
{
SysTimeValue::getTickCount(&last_send);
ret = conn->sendRequest(msg, i);
if (ret == 1)
{
printf("[request sent] seq = %d\n", i);
++i;
}
}
AuthMsg msg1;
uint32_t seq = 0;
ret = conn->recvResponse(msg1, &seq);
if (ret == 1)
{
printf("[response received] seq=%d, retcode=%d, state=%d\n", seq, msg1.retcode, msg1.state);
}
usleep(10);
}// end of while.
auth->releaseConn(conn);
auth->release();
return 0;
}
// 刪除Connector
void ERModel::deleteConnection( Component* delComponent )
{
Connector* delConnector = static_cast<Connector*>(delComponent);
Component* sourceNode = searchComponent(delConnector->getSourceNodeID());
Component* destinationNode = searchComponent(delConnector->getDestinationNodeID());
sourceNode->deleteConnectedComponent(delConnector->getDestinationNodeID());
destinationNode->deleteConnectedComponent(delConnector->getSourceNodeID());
deleteTableSet(delComponent->getID(), _components, PARAMETER_COMPONENTSTABLE);
deleteTableSet(delComponent->getID(), _connections, PARAMETER_CONNECTIONSTABLE);
}
void connect_back(const layer::ptr &l_back, Connector connector) {
for (size_t i = 0; i < m_neuron.size(); ++i) {
const neuron::ptr &n_front = m_neuron[i];
for (size_t j = 0; j < l_back->neuron_count(); ++j) {
neuron::ptr n_back = l_back->get_neuron(j);
if (connector.valid_connection(j, i))
m_connection.push_back(connection::ptr(
new connection(n_front->create_link(n_back,
connector.weight(),
connector.constant()), n_front)));
}
}
}
void DiagramScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)
{
if (line != 0 && myMode == InsertLine)
{
QList<QGraphicsItem *> startItems = items(line->line().p1());
if (startItems.count() && startItems.first() == line)
startItems.removeFirst();
QList<QGraphicsItem *> endItems = items(line->line().p2());
if (endItems.count() && endItems.first() == line)
endItems.removeFirst();
removeItem(line);
delete line;
if (startItems.count() > 0 && endItems.count() > 0 &&
startItems.first()->type() == Connector::Type &&
endItems.first()->type() == Connector::Type &&
startItems.first() != endItems.first())
{
Connector *startItem =
qgraphicsitem_cast<Connector *>(startItems.first());
Connector *endItem =
qgraphicsitem_cast<Connector *>(endItems.first());
QDomNode arrowXml = createArrowXml(startItem,endItem);
Arrow *arrow = new Arrow(startItem, endItem,arrowXml);
arrowList.append(arrow);
arrow->setColor(myLineColor);
startItem->addArrow(arrow);
endItem->addArrow(arrow);
arrow->setZValue(-1000.0);
addItem(arrow);
arrow->updatePosition();
}
}
line = 0;
QGraphicsScene::mouseReleaseEvent(mouseEvent);
if(myMode == MoveItem)
{
DiagramItem* item =(DiagramItem*)itemAt(mouseEvent->scenePos());
if(item == 0)
return;
if(item->type() == DiagramItem::Type)
{
item->updatePoz();
((DiagramWindow*)parent())->updateXml();
}
}
}
void FPNode::setVisible( bool yes )
{
if ( isVisible() == yes ) return;
KtlQCanvasPolygon::setVisible(yes);
const FlowConnectorList::iterator inputEnd = m_inFlowConnList.end();
for ( FlowConnectorList::iterator it = m_inFlowConnList.begin(); it != inputEnd; ++it )
{
Connector *connector = *it;
if ( connector )
{
if ( isVisible() )
connector->setVisible ( true );
else
{
Node *node = connector->startNode();
connector->setVisible ( node && node->isVisible() );
}
}
}
Connector *connector = m_outputConnector;
if ( connector )
{
if ( isVisible() )
connector->setVisible ( true );
else
{
Node *node = connector->endNode();
connector->setVisible ( node && node->isVisible() );
}
}
}
void DetailedView::extshape_Clicked(ExtensionShape *cs)
{
if(cs->node_type == 2){
for(int i=0;i<cs->linkedClass->subclasses.size();i++){
OwlClass * tmp = cs->linkedClass->subclasses[i];
if(!dclasses.contains(tmp)){
this->addShapeWithExt(tmp);
Connector * c = new Connector();
c->initWithConnection(tmp->shape,cs->linkedClass->shape);
c->setDirected(true);
c->setRoutingType(Connector::orthogonal);
m_canvas->addItem(c);
dclasses.append(tmp);
dedges.append(c);
tmp->classesconnectors<<c;
cs->linkedClass->classesconnectors<<c;
subexts.removeAll(cs);
}
}
}
if(cs->node_type ==1){
for(int i=0;i<cs->linkedClass->superclasses.size();i++){
OwlClass * tmp = cs->linkedClass->superclasses[i];
if(!dclasses.contains(tmp)){
this->addShapeWithExt(tmp);
Connector * c = new Connector();
c->initWithConnection(cs->linkedClass->shape,tmp->shape);
c->setDirected(true);
c->setRoutingType(Connector::orthogonal);
m_canvas->addItem(c);
dclasses.append(tmp);
dedges.append(c);
tmp->classesconnectors<<c;
cs->linkedClass->classesconnectors<<c;
superexts.removeAll(cs);
}
}
}
m_canvas->removeItem(cs->edge);
m_canvas->removeItem(cs);
dedges.removeAll(cs->edge);
cs->linkedClass->classesconnectors.removeAll(cs->edge);
delete cs->edge;
delete cs;
this->m_canvas->fully_restart_graph_layout();
}
Connector* V4L1_ConnectorManager::findByIndex(const ListType& l, int index)
{
// Find a Connector by its unique index.
Connector *res = 0;
// iterate the list
for(ListType::const_iterator it = l.begin(); it != l.end(); it++) {
res = *it;
if(res->getIndex() == index)
return res;
}
return 0;
}
bool FPNode::isConnected( Node *node, NodeList *checkedNodes )
{
if ( this == node )
return true;
bool firstNode = !checkedNodes;
if (firstNode)
checkedNodes = new NodeList();
else if ( checkedNodes->contains(this) )
return false;
checkedNodes->append(this);
const FlowConnectorList::const_iterator inputEnd = m_inFlowConnList.end();
for ( FlowConnectorList::const_iterator it = m_inFlowConnList.begin(); it != inputEnd; ++it )
{
Connector *connector = *it;
if (connector) {
Node *startNode = connector->startNode();
if ( startNode && startNode->isConnected( node, checkedNodes ) ) {
if (firstNode) {
delete checkedNodes;
}
return true;
}
}
}
Connector *connector = m_outputConnector;
if ( connector )
{
Node *endNode = connector->endNode();
if ( endNode && endNode->isConnected ( node, checkedNodes ) )
{
if ( firstNode )
{
delete checkedNodes;
}
return true;
}
}
if (firstNode) {
delete checkedNodes;
}
return false;
}
static void connect(uv_tcp_t* handle, const Address& address, void* data,
Callback cb) {
Connector* connector = new Connector(address, data, cb);
int rc = 0;
#if UV_VERSION_MAJOR == 0
if (address.family() == AF_INET) {
rc = uv_tcp_connect(&connector->req_, handle, *address.addr_in(),
on_connect);
} else {
rc = uv_tcp_connect6(&connector->req_, handle, *address.addr_in6(),
on_connect);
}
#else
rc = uv_tcp_connect(&connector->req_, handle, address.addr(),
on_connect);
#endif
if (rc != 0) {
connector->status_ = -1;
connector->cb_(connector);
delete connector;
}
}
