/********************************************************************

  Declaration:  
  Call: 
  Input:
  Returns:
  	  
*********************************************************************/ 
void CommPort::SetByteSize(const DataBits nDataBits)
{
  getState();// GetCommState(m_hCom, &m_dcb);
	m_dcb.ByteSize = nDataBits;
  setState();// SetCommState(m_hCom, &m_dcb); 
}

bool Creep::isDead()
{
    return FlagUtil::isFlagSet(getState(), SET_TO_REMOVE) || FlagUtil::isFlagSet(getState(), DEAD) || FlagUtil::isFlagSet(getState(), DEPLOYING) || FlagUtil::isFlagSet(getState(), GOAL_REACHED);
}

void Animation::logic(){
    if (getState().position < frames.size()){
        if (frames[getState().position]->time != -1){
            getState().ticks += 1;
            if (getState().ticks >= frames[getState().position]->time){
                getState().ticks = 0;
                getState().virtual_ticks = 0;
                if (getState().position < frames.size() - 1){
                    getState().position += 1;
                } else {
		    if (!playOnce){
			getState().position = loopPosition;
                        getState().looped = true;
		    }
                }
            }
        } else {
            getState().virtual_ticks += 1;
        }
    }
}

int eDVBFrontendStatus::getBER() const
{
	if (!frontend || getState() == iDVBFrontend_ENUMS::stateTuning) return 0;
	return frontend->readFrontendData(iFrontendInformation_ENUMS::bitErrorRate);
}

    Gen()
    {
        getState().copy(State);

        pure_init();
    }

ompl::control::ProductGraph::State *ompl::control::ProductGraph::getState(const State *parent,
                                                                          const base::State *cs) const
{
    return getState(parent, decomp_->locateRegion(cs));
}

_string CWebUser::getName() const
{
	_string ret = getState(STATE_NAME);
	return ret.empty() ? guestName : ret;
}

int ProxyConn::processResp()
{
    HttpExtConnector *pHEC = getConnector();
    if (!pHEC)
    {
        errno = ECONNRESET;
        return LS_FAIL;
    }
    int len = 0;
    int ret = 0;
    int &respState = pHEC->getRespState();
    if (!(respState & 0xff))
    {
        char *p = HttpResourceManager::getGlobalBuf();
        const char *pBuf = p;
        if (m_iSsl)
            len = m_ssl.read(p, 1460);
        else
            len = ExtConn::read(p, 1460);

        if (len > 0)
        {
            int copy = len;
            if (m_iRespHeaderRecv + copy > 4095)
                copy = 4095 - m_iRespHeaderRecv;
            //memmove( &m_achRespBuf[ m_iRespHeaderRecv ], pBuf, copy );
            m_iRespHeaderRecv += copy;
            m_iRespRecv += len;
            LS_DBG_L(this, "Read Response %d bytes", len);
            //debug code
            //::write( 1, pBuf, len );

            ret = pHEC->parseHeader(pBuf, len, 1);
            switch (ret)
            {
            case -2:
                LS_WARN(this, "Invalid Http response header, retry!");
                //debug code
                //::write( 1, pBuf, len );
                errno = ECONNRESET;
            case -1:
                return LS_FAIL;
            }
        }
        else
            return len;
        if (respState & 0xff)
        {
            //debug code
            //::write(1, HttpResourceManager::getGlobalBuf(),
            //        pBuf - HttpResourceManager::getGlobalBuf() );
            HttpReq *pReq = pHEC->getHttpSession()->getReq();
            if (pReq->noRespBody())
            {
                incReqProcessed();
                if (len > 0)
                    abort();
                else if (respState & HEC_RESP_CONN_CLOSE)
                    setState(CLOSING);
                else if (getState() == ABORT)
                    setState(PROCESSING);

                setInProcess(0);
                pHEC->endResponse(0, 0);
                return 0;
            }

            m_iRespBodySize = pHEC->getHttpSession()->getResp()->getContentLen();
            LS_DBG_L(this, "Response body size of proxy reply is %d",
                     m_iRespBodySize);
            if (m_iRespBodySize == LSI_RSP_BODY_SIZE_CHUNKED)
                setupChunkIS();
            else if (!(respState & HEC_RESP_CONT_LEN))
                m_iRespBodySize = INT_MAX;

            m_pBufBegin = pBuf;
            m_pBufEnd = pBuf + len;
            LS_DBG_M(this, "Process Response body %d bytes", len);
            return readRespBody();
        }
    }
    else
        return readRespBody();
    return 0;
}

c_WaitableWaitHandle* c_GenMapWaitHandle::getChild() {
  assert(getState() == STATE_BLOCKED);
  return static_cast<c_WaitableWaitHandle*>(
      m_deps->iter_value(m_iterPos)->m_data.pobj);
}

void loop(){
    api.getMyZRState(me);
    game.getItemLoc(target, 0);
    
    state = getState(target, me);
    
    switch (state) {
        case SPS:
            switch (game.getNumSPSHeld()) {
                case 3:
                    game.dropSPS();
                    origin[0] = 0.5f;
                    origin[1] = 0.0f;
                    origin[2] = 0.0f;
                    break;
                case 2:
                    api.setPositionTarget(origin);
                    if (distance(origin, me) <= .05) {
                        game.dropSPS();
                        
                        origin[0] = 0.0f;
                        origin[1] = 0.68f;
                        origin[2] = 0.0f;
                    }
                    
                    
                    break;
                case 1:
                    api.setPositionTarget(origin);
                    if (distance(origin, me) <= .05) game.dropSPS();
                    
                    break;
            }
            
            break;
        case GET_ITEM:
            //Find vector between bot and item
            mathVecSubtract(holder, target, me, 3);
            
            //magnitude of previous vector
            mag = mathVecMagnitude(holder, 3);
            
            //Face towards the item
            api.setAttitudeTarget(holder);
            
            //DEBUG(("Dist: %f", distance(target, me)));
            DEBUG(("Dist: %f", mag));
            
            //Scale down the vector so the endpoint is .170 units away from the item
            //scaleVect(holder, mag, 0.170f);
            //adjustGoal(holder, 0.170f);
            adjustGoal(target, 0.170f);
            
            //If in proximity
            /*if (mag <= .17 && mag >= .15) {
                DEBUG(("Stay"));
                api.setPositionTarget(me);
                game.dockItem();
            }*/
            if (distance(target, me) <= .17 && distance(target, me) >= .15) {
                DEBUG(("Stay"));
                DEBUG(("Close: %f", mag));
                api.setPositionTarget(me);
                game.dockItem();
            }
            //else if (mag <= .2 && mag > .17) {
                //api.setPositionTarget(target);
            //}
            else {
                //Full speed ahead
                //api.setVelocityTarget(holder);
                moveTo(holder);
            }
            
            break;
        case STAY:
            DEBUG(("Staying"));
            api.setPositionTarget(me);
            break;
        case FIND_ASSEMBLY:
            DEBUG(("Find Assembly"));
            
            //if (isFound) {
                if (game.getZone(myZone)) {
                    DEBUG(("%f, %f, %f, %f", myZone[0], myZone[1], myZone[2], myZone[3]));
                }
                
                mathVecSubtract(holder, me, myZone, 3);
                //isFound = false;
            //}
            
            //move to and point to the estimated zone
            api.setPositionTarget(myZone);
            scaleVect(holder, 1.0f, -1.0f);
            api.setAttitudeTarget(holder);
            
            if (mathVecMagnitude(holder, 3) <= .17) {
                DEBUG(("Gottem"));
                api.setPositionTarget(me);
                game.dropItem();
//.........这里部分代码省略.........

void BooleanPropertyComponent::buttonClicked (Button*)
{
    setState (! getState());
}

void BooleanPropertyComponent::refresh()
{
    button.setToggleState (getState(), false);
    button.setButtonText (button.getToggleState() ? onText : offText);
}

void cube::shiftCube( char direction, bool orientation )
{
	/*
	 * shifts the contents of the cube in the given direction. out-of-bound locations
	 * will be ignored and set to 'off'
	 */
	cube *tmpCube = new cube;
	tmpCube->allOff();
	signed short int modifier;
	if(orientation == 1)
	{
		modifier = 1;
	}
	else
	{
		 modifier = -1;
	}
	byte t_x, t_y, t_z;
	for(byte i_x = 1; i_x <= 4; i_x++ )
	{
		for(byte i_y = 1; i_y <= 4; i_y++ )
		{
			for(byte i_z = 1; i_z <= 4; i_z++ )
			{
				if( getState( i_x, i_y, i_z ) == 1 )
				{
					switch(direction)
					{
					case 'x':
						t_x = i_x + modifier;
						if( t_x <= 0 || t_x > 4 ){
							continue;
						}
						t_y = i_y;
						t_z = i_z;
						break;
					case 'y':
						t_x = i_x;
						t_y = i_y + modifier;
						if( t_y <= 0 || t_y > 4 ){
							continue;
						}
						t_z = i_z;
						break;
					case 'z':
						t_x = i_x;
						t_y = i_y;
						t_z = i_z + modifier;
						if( t_z <= 0 || t_z > 4 ){
							continue;
						}
						break;
					default:
						continue;
						break;
					}
					tmpCube->setState( t_x, t_y, t_z, 1 );
				}
			}
		}
	}
	importData( tmpCube->_cube_state );
	delete tmpCube;
}

void ompl::control::ProductGraph::buildGraph(State *start, const std::function<void(State *)> &initialize)
{
    graph_.clear();
    solutionStates_.clear();
    std::queue<State *> q;
    std::unordered_set<State *> processed;
    std::vector<int> regNeighbors;
    VertexIndexMap index = get(boost::vertex_index, graph_);

    GraphType::vertex_descriptor next = boost::add_vertex(graph_);
    startState_ = start;
    graph_[boost::vertex(next, graph_)] = startState_;
    stateToIndex_[startState_] = index[next];
    q.push(startState_);
    processed.insert(startState_);

    OMPL_INFORM("Building graph from start state (%u,%u,%u) with index %d", startState_->decompRegion,
                startState_->cosafeState, startState_->safeState, stateToIndex_[startState_]);

    while (!q.empty())
    {
        State *current = q.front();
        // Initialize each state using the supplied state initializer function
        initialize(current);
        q.pop();

        if (safety_->isAccepting(current->safeState) && cosafety_->isAccepting(current->cosafeState))
        {
            solutionStates_.push_back(current);
        }

        GraphType::vertex_descriptor v = boost::vertex(stateToIndex_[current], graph_);

        // enqueue each neighbor of current
        decomp_->getNeighbors(current->decompRegion, regNeighbors);
        for (const auto &r : regNeighbors)
        {
            State *nextState = getState(current, r);
            if (!nextState->isValid())
                continue;
            // if this state is newly discovered,
            // then we can dynamically allocate a copy of it
            // and add the new pointer to the graph.
            // either way, we need the pointer
            if (processed.find(nextState) == processed.end())
            {
                const GraphType::vertex_descriptor next = boost::add_vertex(graph_);
                stateToIndex_[nextState] = index[next];
                graph_[boost::vertex(next, graph_)] = nextState;
                q.push(nextState);
                processed.insert(nextState);
            }

            // whether or not the neighbor is newly discovered,
            // we still need to add the edge to the graph
            GraphType::edge_descriptor edge;
            bool ignore;
            boost::tie(edge, ignore) = boost::add_edge(v, boost::vertex(stateToIndex_[nextState], graph_), graph_);
            // graph_[edge].src = index[v];
            // graph_[edge].dest = stateToIndex_[nextState];
        }
        regNeighbors.clear();
    }
    if (solutionStates_.empty())
    {
        OMPL_ERROR("No solution path found in product graph.");
    }

    OMPL_INFORM("Number of decomposition regions: %u", decomp_->getNumRegions());
    OMPL_INFORM("Number of cosafety automaton states: %u", cosafety_->numStates());
    OMPL_INFORM("Number of safety automaton states: %u", safety_->numStates());
    OMPL_INFORM("Number of high-level states in abstraction graph: %u", boost::num_vertices(graph_));
}

void EspNewIncomingConnectionStream::actOnReceive(IpcConnection *connection)
{
  // check for OS errors
  if (getState() == ERROR_STATE)
  {
    ex_assert(FALSE,"Error while receiving first message from client");
  }

  // check for protocol errors
  bool willPassTheAssertion = 
             (getType() == IPC_MSG_SQLESP_DATA_REQUEST OR
              getType() == IPC_MSG_SQLESP_CANCEL_REQUEST) AND
              getVersion() == CurrEspRequestMessageVersion AND
              moreObjects();
  if (!willPassTheAssertion)
  {
    char *doCatchBugCRx = getenv("ESP_BUGCATCHER_CR_NONUMBER");
    if (!doCatchBugCRx ||
        *doCatchBugCRx != '0')
    {
      connection->dumpAndStopOtherEnd(true, false);
      environment_->getControlConnection()->
        castToGuaReceiveControlConnection()->
        getConnection()->dumpAndStopOtherEnd(true, false);
    }
  }

  ex_assert((getType() == IPC_MSG_SQLESP_DATA_REQUEST OR
             getType() == IPC_MSG_SQLESP_CANCEL_REQUEST) AND
	    getVersion() == CurrEspRequestMessageVersion AND
	    moreObjects(),
	    "Invalid first message from client");

  // take a look at the type of the first object in the message
  IpcMessageObjType nextObjType = getNextObjType();
  switch (nextObjType)
  {
    case ESP_OPEN_HDR:
    case ESP_LATE_CANCEL_HDR:
      {
        ExFragKey key;
        Lng32 remoteInstNum;
        NABoolean isParallelExtract = false; 

        // peek at the message header to see for whom it is
        if (nextObjType == ESP_OPEN_HDR)
        {
          ExEspOpenReqHeader reqHdr((NAMemory *) NULL);
	   
	  *this >> reqHdr;
	  key = reqHdr.key_;
	  remoteInstNum = reqHdr.myInstanceNum_;
	  if (reqHdr.getOpenType() == ExEspOpenReqHeader::PARALLEL_EXTRACT) 
          {
            isParallelExtract = true;
	  }
	}
        else
	{
          // note that the late cancel request may or may not
	  // arrive as the first request (only in the former case
	  // will we reach here)
	  ExEspLateCancelReqHeader reqHdr((NAMemory *) NULL);
	   
	  *this >> reqHdr;
	  key = reqHdr.key_;
	  remoteInstNum = reqHdr.myInstanceNum_;
	}

        if (!isParallelExtract) 
        {
          ExFragInstanceHandle handle =
	    espFragInstanceDir_->findHandle(key);

	  if (handle != NullFragInstanceHandle)
	  {
            // the send bottom node # myInstanceNum of this downloaded fragment
            // is the true recipient of this open request
            ex_split_bottom_tcb * receivingTcb =
              espFragInstanceDir_->getTopTcb(handle);
            ex_send_bottom_tcb *receivingSendTcb =
              receivingTcb->getSendNode(remoteInstNum);

            // Check the connection for a co-located client, and if so,
            // tell the split bottom, because it may prefer this send 
            // bottom when using skew buster uniform distribution.
            if (espFragInstanceDir_->
                  getEnvironment()->
                  getMyOwnProcessId(IPC_DOM_GUA_PHANDLE).match(
                    connection->getOtherEnd().getNodeName(),
                    connection->getOtherEnd().getCpuNum()))
              receivingTcb->setLocalSendBottom(remoteInstNum);

            // Portability note for the code above: we pass IPC_DOM_GUA_PHANDLE
            // for IpcEnvironment::getMyOwnProcessId, even though that method
            // can be called with the default param (IpcNetworkDomain 
            // IPC_DOM_INVALID).  In fact it would  probably be better 
            // to call the object without specifying the IpcNetworkDomain so
            // that it can decide for itself what domain it is using.
            // But there is a problem with the Windows implementation
//.........这里部分代码省略.........

void Client::manage(Boolean mapped)
{
    Boolean shouldHide, reshape;
    XWMHints *hints;
    Display *d = display();
    long mSize;
    int state;

    XSelectInput(d, m_window, ColormapChangeMask | EnterWindowMask |
		 PropertyChangeMask | FocusChangeMask);

    m_iconName = getProperty(XA_WM_ICON_NAME);
    m_name = getProperty(XA_WM_NAME);
    setLabel();

    getColormaps();
    getProtocols();
    getTransient();

    hints = XGetWMHints(d, m_window);

    if (!getState(&state)) {
	state = hints ? hints->initial_state : NormalState;
    }

    shouldHide = (state == IconicState);
    if (hints) XFree(hints);

    if (XGetWMNormalHints(d, m_window, &m_sizeHints, &mSize) == 0 ||
	m_sizeHints.flags == 0) {
	m_sizeHints.flags = PSize;
    }

    m_fixedSize = False;
//    if ((m_sizeHints.flags & (USSize | PSize))) m_fixedSize = True;
    if ((m_sizeHints.flags & (PMinSize | PMaxSize)) == (PMinSize | PMaxSize) &&
	(m_sizeHints.min_width  == m_sizeHints.max_width &&
	 m_sizeHints.min_height == m_sizeHints.max_height)) m_fixedSize = True;

    reshape = !mapped;

    if (m_fixedSize) {
	if ((m_sizeHints.flags & USPosition)) reshape = False;
	if ((m_sizeHints.flags & PPosition) && shouldHide) reshape = False;
	if ((m_transient != None)) reshape = False;
    }

    if ((m_sizeHints.flags & PBaseSize)) {
	m_minWidth  = m_sizeHints.base_width;
	m_minHeight = m_sizeHints.base_height;
    } else if ((m_sizeHints.flags & PMinSize)) {
	m_minWidth  = m_sizeHints.min_width;
	m_minHeight = m_sizeHints.min_height;
    } else {
	m_minWidth = m_minHeight = 50;
    }

    // act

    gravitate(False);

    // zeros are iffy, should be calling some Manager method
    int dw = DisplayWidth(display(), 0), dh = DisplayHeight(display(), 0);

    if (m_w < m_minWidth) {
	m_w = m_minWidth; m_fixedSize = False; reshape = True;
    }
    if (m_h < m_minHeight) {
	m_h = m_minHeight; m_fixedSize = False; reshape = True;
    }

    if (m_w > dw - 8) m_w = dw - 8;
    if (m_h > dh - 8) m_h = dh - 8;

    if (m_x > dw - m_border->xIndent()) {
	m_x = dw - m_border->xIndent();
    }

    if (m_y > dh - m_border->yIndent()) {
	m_y = dh - m_border->yIndent();
    }

    if (m_x < m_border->xIndent()) m_x = m_border->xIndent();
    if (m_y < m_border->yIndent()) m_y = m_border->yIndent();
    
    m_border->configure(m_x, m_y, m_w, m_h, 0L, Above);

    if (mapped) m_reparenting = True;
    if (reshape && !m_fixedSize) XResizeWindow(d, m_window, m_w, m_h);
    XSetWindowBorderWidth(d, m_window, 0);

    m_border->reparent();

    // (support for shaped windows absent)

    XAddToSaveSet(d, m_window);
    m_managed = True;

    if (shouldHide) hide();
    else {
//.........这里部分代码省略.........

string CWebUser::getUserId() const
{
	return _to_utf8(getState(STATE_ID));
}

// Save current info to BusinessInfo.txt
void BusinessInfo::saveBusinessInfo()
{
	string delimiter = ",";

	fstream outfile;
	outfile.open("BusinessInfo.txt", ios::out);
	outfile << getName() << delimiter << getAddress() << delimiter << getCity() << delimiter << getState() << delimiter << getZipCode() << delimiter << getSalesTax() << delimiter;
	outfile.close();
}

/*******************************************************
		设置当前状态
********************************************************/
void CAutoDownload::setState(AUTODOWN_STATE state)
{
	CAutoDownload::AUTODOWN_IMPL* pImpl = getImpl();

	if(pImpl->m_hCallbackWnd && pImpl->m_state != state)
	{
		pImpl->m_state = state;
		::SendMessage(pImpl->m_hCallbackWnd, CAutoDownload::AM_STATUSUPDATE, pImpl->m_nOwnerID, getState());
	}
	else
	{
		pImpl->m_state = state;
	}
}

int eDVBFrontendStatus::getSignalPower() const
{
	if (!frontend || getState() == iDVBFrontend_ENUMS::stateTuning) return 0;
	return frontend->readFrontendData(iFrontendInformation_ENUMS::signalPower);
}