自学教程：C++ BROADCAST函数代码示例

isc_result_tisc_rwlock_unlock(isc_rwlock_t *rwl, isc_rwlocktype_t type) {	REQUIRE(VALID_RWLOCK(rwl));	LOCK(&rwl->lock);	REQUIRE(rwl->type == type);	UNUSED(type);#ifdef ISC_RWLOCK_TRACE	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,				  ISC_MSG_PREUNLOCK, "preunlock"), rwl, type);#endif	INSIST(rwl->active > 0);	rwl->active--;	if (rwl->active == 0) {		if (rwl->original != isc_rwlocktype_none) {			rwl->type = rwl->original;			rwl->original = isc_rwlocktype_none;		}		if (rwl->type == isc_rwlocktype_read) {			rwl->granted = 0;			if (rwl->writers_waiting > 0) {				rwl->type = isc_rwlocktype_write;				SIGNAL(&rwl->writeable);			} else if (rwl->readers_waiting > 0) {				/* Does this case ever happen? */				BROADCAST(&rwl->readable);			}		} else {			if (rwl->readers_waiting > 0) {				if (rwl->writers_waiting > 0 &&				    rwl->granted < rwl->write_quota) {					SIGNAL(&rwl->writeable);				} else {					rwl->granted = 0;					rwl->type = isc_rwlocktype_read;					BROADCAST(&rwl->readable);				}			} else if (rwl->writers_waiting > 0) {				rwl->granted = 0;				SIGNAL(&rwl->writeable);			} else {				rwl->granted = 0;			}		}	}	INSIST(rwl->original == isc_rwlocktype_none);#ifdef ISC_RWLOCK_TRACE	print_lock(isc_msgcat_get(isc_msgcat, ISC_MSGSET_RWLOCK,				  ISC_MSG_POSTUNLOCK, "postunlock"),		   rwl, type);#endif	UNLOCK(&rwl->lock);	return (ISC_R_SUCCESS);}

void PointerNode::manipulate (int b){    // Immediately when the user presses the manipulate button, we check to see    // if we are pointing at a new node. ie, we make sure the user is NOT    // pointing at a dragger anymore, and    if (b && spinApp::Instance().getContext()->isServer())    {        if (1) //!getDraggerFromIntersections())        {            GroupNode *lastNode = dynamic_cast<GroupNode*>(lastManipulated->s_thing);            GroupNode *newNode = dynamic_cast<GroupNode*>(getNodeFromIntersections(0));            if (newNode && (newNode!=lastNode))            {                dragger_ = NULL;                if (lastNode) lastNode->setManipulator("NULL");                newNode->setManipulator(lastManipulatorType_.c_str());                lastManipulated = newNode->getNodeSymbol();            }        }    }    // then we just set the 'doManipulation' flag, which will    doManipulation = (bool) b;    BROADCAST(this, "si", "manipulate", this->getManipulate());}

void DSPNode::setRadius (float newvalue){    _radius = newvalue;    if (_radius < 0) _radius = 0;    if (_radius > 0) this->setLength(_radius/AS_DEBUG_SCALE);    BROADCAST(this, "sf", "setRadius", getRadius());}

void PointerNode::setManipulator(const char *manipulatorType){    if (spinApp::Instance().getContext()->isServer())    {        GroupNode *lastNode = dynamic_cast<GroupNode*>(lastManipulated->s_thing);        // see if there is an intersection with a GroupNode, and if so, tell        // that node to enable the manipulator        GroupNode *n = dynamic_cast<GroupNode*>(getNodeFromIntersections(0));        if (n)        {            // if we're targetting a new node, make sure that the last            // manipulated node's dragger gets turned off:            if ((lastNode) && (n != lastNode))                lastNode->setManipulator("NULL");            n->setManipulator(manipulatorType);            lastManipulated = n->getNodeSymbol();        }        // if there was no intersection, load the manipulator on the last object        // that was manipulated        else if (lastNode)        {            lastNode->setManipulator(manipulatorType);        }        lastManipulatorType_ = std::string(manipulatorType);    }    else    {        BROADCAST(this, "ss", "setManipulator", manipulatorType);    }}

static voidtask_finished(isc_task_t *task) {	isc_taskmgr_t *manager = task->manager;	REQUIRE(EMPTY(task->events));	REQUIRE(EMPTY(task->on_shutdown));	REQUIRE(task->references == 0);	REQUIRE(task->state == task_state_done);	XTRACE("task_finished");	LOCK(&manager->lock);	UNLINK(manager->tasks, task, link);#ifdef ISC_PLATFORM_USETHREADS	if (FINISHED(manager)) {		/*		 * All tasks have completed and the		 * task manager is exiting.  Wake up		 * any idle worker threads so they		 * can exit.		 */		BROADCAST(&manager->work_available);	}#endif /* ISC_PLATFORM_USETHREADS */	UNLOCK(&manager->lock);	DESTROYLOCK(&task->lock);	task->magic = 0;	isc_mem_put(manager->mctx, task, sizeof(*task));}

void DSPNode::setRolloff (const char *newvalue){    // We store just the id instead of the whole table. If we want, we can always get the table    // from the database (eg, for drawing).    _rolloff = newvalue;    drawDirectivity();    BROADCAST(this, "ss", "setRolloff", _rolloff.c_str());}

void Listener::setType (const char* t){	// only do this if the type has changed:	if (type == std::string(t)) return;	type = std::string(t);	    BROADCAST(this, "ss", "setType", getType());}

// *****************************************************************************void GridNode::setSize (int s){	if (this->_size != s)	{		this->_size = s;		drawGrid();		BROADCAST(this, "si", "setSize", (int) this->_size);	}}

void ShapeNode::setBillboard (billboardType t){	if (t == billboard) return;	else billboard = t;	drawShape();	BROADCAST(this, "si", "setBillboard", (int) billboard);}

void ShapeNode::setStateSetFromFile(const char* filename){	osg::ref_ptr<ReferencedStateSet> ss = sceneManager->createStateSet(filename);	if (ss.valid())	{		if (ss->id == stateset) return; // we're already using that stateset		stateset = ss->id;		updateStateSet();		BROADCAST(this, "ss", "setStateSet", getStateSet());	}}

ISC_TASKFUNC_SCOPE voidisc__taskmgr_resume(isc_taskmgr_t *manager0) {	isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;	LOCK(&manager->lock);	if (manager->pause_requested) {		manager->pause_requested = ISC_FALSE;		BROADCAST(&manager->work_available);	}	UNLOCK(&manager->lock);}

// ===================================================================void ShapeNode::setTextureFromFile (const char* s){	string path = getRelativePath(string(s));		// don't do anything if the current texture is already loaded:	if (path==texturePath) return;	else texturePath=path;		//drawTexture();	BROADCAST(this, "ss", "setTextureFromFile", texturePath.c_str());}

void GeometryNode::setSingleSided (int singleSided){    singleSided_ = singleSided;        osg::StateSet *ss = geode_->getOrCreateStateSet();    if (singleSided_)        ss->setMode( GL_CULL_FACE, osg::StateAttribute::ON );    else        ss->setMode( GL_CULL_FACE, osg::StateAttribute::OFF );	BROADCAST(this, "si", "setSingleSided", getSingleSided());}

voidisc_task_endexclusive(isc_task_t *task) {#ifdef ISC_PLATFORM_USETHREADS	isc_taskmgr_t *manager = task->manager;	REQUIRE(task->state == task_state_running);	LOCK(&manager->lock);	REQUIRE(manager->exclusive_requested);	manager->exclusive_requested = ISC_FALSE;	BROADCAST(&manager->work_available);	UNLOCK(&manager->lock);#else	UNUSED(task);#endif}

// *****************************************************************************void DSPNode::connect(DSPNode *snk){	// check if this connection already exists:	if (!this->getConnection(snk))	{		SoundConnection *conn = new SoundConnection(this->sceneManager, this, snk);		// add to the connection lists for each node:		this->connectTO.push_back(conn);		conn->sink->connectFROM.push_back(conn);	}		BROADCAST(this, "ss", "connect", snk->id->s_name);}

/* NOTE: icmp dont drop @ipkb */void icmp_send(unsigned char type, unsigned char code,		unsigned int data, struct pkbuf *pkb_in){	struct pkbuf *pkb;	struct ip *iphdr = pkb2ip(pkb_in);	struct icmp *icmphdr;	int paylen = _ntohs(iphdr->ip_len);	/* icmp payload length */	if (paylen < iphlen(iphdr) + 8)		return;	/*	 * RFC 1812 Section 4.3.2.7 for sanity check	 * An ICMP error message MUST NOT be sent as the result of receiving:	 * 1. A packet sent as a Link Layer broadcast or multicast	 * 2. A packet destined to an IP broadcast or IP multicast address	 *[3] A packet whose source address has a network prefix of zero or is an	 *      invalid source address (as defined in Section [5.3.7])	 * 4. Any fragment of a datagram other then the first fragment (i.e., a	 *      packet for which the fragment offset in the IP header is nonzero).	 * 5. An ICMP error message	 */	if (pkb_in->pk_type != PKT_LOCALHOST)		return;	if (MULTICAST(iphdr->ip_dst) || BROADCAST(iphdr->ip_dst))		return;	if (iphdr->ip_fragoff & _htons(IP_FRAG_OFF))		return;	if (icmp_type_error(type) && iphdr->ip_pro == IP_P_ICMP) {		icmphdr = ip2icmp(iphdr);		if (icmphdr->icmp_type > ICMP_T_MAXNUM || icmp_error(icmphdr))			return;	}	/* build icmp packet and send */	/* ip packet size must be smaller than 576 bytes */	if (IP_HRD_SZ + ICMP_HRD_SZ + paylen > 576)		paylen = 576 - IP_HRD_SZ - ICMP_HRD_SZ;	pkb = alloc_pkb(ETH_HRD_SZ + IP_HRD_SZ + ICMP_HRD_SZ + paylen);	icmphdr = (struct icmp *)(pkb2ip(pkb)->ip_data);	icmphdr->icmp_type = type;	icmphdr->icmp_code = code;	icmphdr->icmp_cksum = 0;	icmphdr->icmp_undata = data;	memcpy(icmphdr->icmp_data, (unsigned char *)iphdr, paylen);	icmphdr->icmp_cksum =		icmp_chksum((unsigned short *)icmphdr, ICMP_HRD_SZ + paylen);	icmpdbg("to "IPFMT"(payload %d) [type %d code %d]/n",		ipfmt(iphdr->ip_src), paylen, type, code);	ip_send_info(pkb, 0, IP_HRD_SZ + ICMP_HRD_SZ + paylen,						0, IP_P_ICMP, iphdr->ip_src);}

void ShapeNode::setLighting (int i){	if (lightingEnabled==(bool)i) return;	lightingEnabled = (bool)i;	if (shapeGeode.valid() && !stateset->s_thing)	{		osg::StateSet *ss = shapeGeode->getOrCreateStateSet();		if (lightingEnabled) ss->setMode( GL_LIGHTING, osg::StateAttribute::ON );		else ss->setMode( GL_LIGHTING, osg::StateAttribute::OFF );	}	BROADCAST(this, "si", "setLighting", getLighting());}

void DSPNode::setIntensity (float newvalue){    currentSoundIntensity = newvalue;    float r = currentSoundIntensity / 0.896909;    if (r > 1.0) r=1.0;    float g = (1.0 - currentSoundIntensity) / 0.103091;    if (g > 1.0) g=1.0;    currentSoundColor = osg::Vec3(r, g, 0.0);    updateVUmeter();    updateLaser();    BROADCAST(this, "sf", "setIntensity", currentSoundIntensity);}

ISC_TASKFUNC_SCOPE voidisc__task_endexclusive(isc_task_t *task0) {#ifdef USE_WORKER_THREADS	isc__task_t *task = (isc__task_t *)task0;	isc__taskmgr_t *manager = task->manager;	REQUIRE(task->state == task_state_running);	LOCK(&manager->lock);	REQUIRE(manager->exclusive_requested);	manager->exclusive_requested = ISC_FALSE;	BROADCAST(&manager->work_available);	UNLOCK(&manager->lock);#else	UNUSED(task0);#endif}

// *****************************************************************************void ReferencedStateSet::debug(){	lo_arg **args;	int argc;	char *argTypes;	std::cout << "****************************************" << std::endl;	std::cout << "************* STATE DEBUG: *************" << std::endl;	std::cout << "/nReferencedStateSet: " << id->s_name << ", type: " << classType << std::endl;		std::cout << "   Shared by:";	for (unsigned i = 0; i < getNumParents(); i++)		std::cout << " " << getParent(i)->getName();	std::cout << std::endl;	//osg::ref_ptr<ReferencedStateSet> test = this;	//std::cout << "ref_count=" << test->getReferenceCount() << std::endl;			vector<lo_message> nodeState = this->getState();	vector<lo_message>::iterator nodeStateIterator;	for (nodeStateIterator = nodeState.begin(); nodeStateIterator != nodeState.end(); ++nodeStateIterator)	{	    argTypes = lo_message_get_types(*nodeStateIterator);	    argc = lo_message_get_argc(*nodeStateIterator);	    args = lo_message_get_argv(*nodeStateIterator);	    std::cout << "  ";	    for (int i = 0; i < argc; i++) {		    std::cout << " ";	    	if (lo_is_numerical_type((lo_type)argTypes[i]))	    	{	    		std::cout << (float) lo_hires_val( (lo_type)argTypes[i], args[i] );	    	} else if (strlen((char*) args[i])) {	    		std::cout << (char*) args[i];	    	} else {	    		std::cout << "NULL";	    	}	    }	    std::cout << std::endl;	}		BROADCAST(this, "s", "debug");}

voidisc_rwlock_downgrade(isc_rwlock_t *rwl) {	isc_int32_t prev_readers;	REQUIRE(VALID_RWLOCK(rwl));	/* Become an active reader. */	prev_readers = isc_atomic_xadd(&rwl->cnt_and_flag, READER_INCR);	/* We must have been a writer. */	INSIST((prev_readers & WRITER_ACTIVE) != 0);	/* Complete write */	(void)isc_atomic_xadd(&rwl->cnt_and_flag, -WRITER_ACTIVE);	(void)isc_atomic_xadd(&rwl->write_completions, 1);	/* Resume other readers */	LOCK(&rwl->lock);	if (rwl->readers_waiting > 0)		BROADCAST(&rwl->readable);	UNLOCK(&rwl->lock);}