C++ CState类代码示例

bool CContextControl::CloseTab(int tab)
{
	if (!m_tabs)
		return false;
	if (tab < 0)
		return false;

	size_t i = 0;
	for (i = 0; i < m_context_controls.size(); i++)
	{
		if (m_context_controls[i].tab_index == tab)
			break;
	}
	if (i == m_context_controls.size())
		return false;

	CState* pState = m_context_controls[i].pState;

	if (!pState->m_pCommandQueue->Idle())
	{
		if (wxMessageBoxEx(_("Cannot close tab while busy.\nCancel current operation and close tab?"), _T("FileZilla"), wxYES_NO | wxICON_QUESTION) != wxYES)
			return false;

		Freeze();

		pState->m_pCommandQueue->Cancel();
		pState->GetRecursiveOperationHandler()->StopRecursiveOperation();
	}
	else
		Freeze();

	pState->GetComparisonManager()->SetListings(0, 0);

	if (m_tabs->GetPageCount() == 2)
	{
		// Get rid again of tab bar
		m_tabs->Disconnect(wxEVT_COMMAND_AUINOTEBOOK_PAGE_CHANGED, wxAuiNotebookEventHandler(CContextControl::OnTabChanged), 0, this);

		int keep = tab ? 0 : 1;
		m_tabs->RemovePage(keep);

		size_t j;
		for (j = 0; j < m_context_controls.size(); j++)
		{
			if (m_context_controls[j].tab_index != keep)
				continue;

			break;
		}

		m_context_controls[j].pViewSplitter->Reparent(this);
		ReplaceWindow(m_tabs, m_context_controls[j].pViewSplitter);
		m_context_controls[j].pViewSplitter->Show();
		m_context_controls[j].tab_index = 0;

		wxAuiNotebookEx *tabs = m_tabs;
		m_tabs = 0;

		m_context_controls[i].tab_index = -1;
		m_context_controls[i].site_bookmarks.clear();

		CContextManager::Get()->SetCurrentContext(m_context_controls[j].pState);

		tabs->Destroy();
	}
	else
	{
		if (pState == CContextManager::Get()->GetCurrentContext())
		{
			int newsel = tab + 1;
			if (newsel >= (int)m_tabs->GetPageCount())
				newsel = m_tabs->GetPageCount() - 2;

			for (size_t j = 0; j < m_context_controls.size(); j++)
			{
				if (m_context_controls[j].tab_index != newsel)
					continue;
				m_tabs->SetSelection(newsel);
				CContextManager::Get()->SetCurrentContext(m_context_controls[j].pState);
			}
		}
		for (size_t j = 0; j < m_context_controls.size(); j++)
		{
			if (m_context_controls[j].tab_index > tab)
				m_context_controls[j].tab_index--;
		}
		m_context_controls[i].tab_index = -1;
		m_context_controls[i].site_bookmarks.clear();
		m_tabs->DeletePage(tab);
	}

	pState->Disconnect();

	Thaw();

	return true;
}

void CClearPrivateDataDialog::Show()
{
	if (!Load(m_pMainFrame, _T("ID_CLEARPRIVATEDATA")))
		return;

	if (ShowModal() != wxID_OK)
		return;

	wxCheckBox *pSitemanagerCheck = XRCCTRL(*this, "ID_CLEARSITEMANAGER", wxCheckBox);
	wxCheckBox *pQueueCheck = XRCCTRL(*this, "ID_CLEARQUEUE", wxCheckBox);
	if (pSitemanagerCheck->GetValue() && pQueueCheck->GetValue())
	{
		int res = wxMessageBox(_("Do you really want to delete all Site Manager entries and the transfer queue?"), _("Clear private data"), wxYES | wxNO | wxICON_QUESTION);
		if (res != wxYES)
			return;
	}
	else if (pQueueCheck->GetValue())
	{
		int res = wxMessageBox(_("Do you really want to delete the transfer queue?"), _("Clear private data"), wxYES | wxNO | wxICON_QUESTION);
		if (res != wxYES)
			return;
	}
	else if (pSitemanagerCheck->GetValue())
	{
		int res = wxMessageBox(_("Do you really want to delete all Site Manager entries?"), _("Clear private data"), wxYES | wxNO | wxICON_QUESTION);
		if (res != wxYES)
			return;
	}

	wxCheckBox *pCheck = XRCCTRL(*this, "ID_CLEARQUICKCONNECT", wxCheckBox);
	if (!pCheck)
		return;

	if (pCheck->GetValue())
	{
		CRecentServerList::Clear();
		if (m_pMainFrame->GetQuickconnectBar())
			m_pMainFrame->GetQuickconnectBar()->ClearFields();
	}

	pCheck = XRCCTRL(*this, "ID_CLEARRECONNECT", wxCheckBox);

	if (pCheck->GetValue())
	{
		bool asked = false;

		const std::vector<CState*> *states = CContextManager::Get()->GetAllStates();

		for (std::vector<CState*>::const_iterator iter = states->begin(); iter != states->end(); ++iter)
		{
			CState* pState = *iter;
			if (pState->IsRemoteConnected() || !pState->IsRemoteIdle())
			{
				if (!asked)
				{
					int res = wxMessageBox(_("Reconnect information cannot be cleared while connected to a server.\nIf you continue, your connection will be disconnected."), _("Clear private data"), wxOK | wxCANCEL);
					if (res != wxOK)
						return;
					asked = true;
				}

				pState->GetRecursiveOperationHandler()->StopRecursiveOperation();
				if (!pState->m_pCommandQueue->Cancel())
				{
					m_timer.SetOwner(this);
					m_timer.Start(250, true);
				}
				else
					pState->Disconnect();
			}
		}

		// Doesn't harm to do it now, but has to be repeated later just to be safe
		ClearReconnect();
	}

	if (pSitemanagerCheck->GetValue())
	{
		CInterProcessMutex sitemanagerMutex(MUTEX_SITEMANAGERGLOBAL, false);
		while (sitemanagerMutex.TryLock() == 0)
		{
			int res = wxMessageBox(_("The Site Manager is opened in another instance of FileZilla 3.\nPlease close it or the data cannot be deleted."), _("Clear private data"), wxOK | wxCANCEL);
			if (res != wxYES)
				return;
		}
		CInterProcessMutex mutex(MUTEX_SITEMANAGER);
		RemoveXmlFile(_T("sitemanager"));
	}

	if (pQueueCheck->GetValue())
	{
		m_pMainFrame->GetQueue()->SetActive(false);
		m_pMainFrame->GetQueue()->RemoveAll();

		CInterProcessMutex mutex(MUTEX_QUEUE);
		RemoveXmlFile(_T("queue"));
	}
}

HRESULT CDecoder::CodeReal(ISequentialInStream *anInStream,
    ISequentialOutStream *anOutStream,
    const UINT64 *, const UINT64 *anOutSize)
{
  if (anOutSize == NULL)
    return E_INVALIDARG;

  Init(anInStream, anOutStream);

  CState aState;
  aState.Init();
  bool aPeviousIsMatch = false;
  BYTE aPreviousByte = 0;
  UINT32 aRepDistances[kNumRepDistances];
  for(UINT32 i = 0 ; i < kNumRepDistances; i++)
    aRepDistances[i] = 0;

  UINT64 aNowPos64 = 0;
  UINT64 aSize = *anOutSize;
  while(aNowPos64 < aSize)
  {
    UINT64 aNext = MyMin(aNowPos64 + (1 << 18), aSize);
    while(aNowPos64 < aNext)
    {
      UINT32 aPosState = UINT32(aNowPos64) & m_PosStateMask;
      if (m_MainChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == (UINT32) kMainChoiceLiteralIndex)
      {
        // aCounts[0]++;
        aState.UpdateChar();
        if(aPeviousIsMatch)
        {
          BYTE aMatchByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1);
          aPreviousByte = m_LiteralDecoder.DecodeWithMatchByte(&m_RangeDecoder,
              UINT32(aNowPos64), aPreviousByte, aMatchByte);
          aPeviousIsMatch = false;
        }
        else
          aPreviousByte = m_LiteralDecoder.DecodeNormal(&m_RangeDecoder,
              UINT32(aNowPos64), aPreviousByte);
        m_OutWindowStream.PutOneByte(aPreviousByte);
        aNowPos64++;
      }
      else
      {
        aPeviousIsMatch = true;
        UINT32 aDistance, aLen;
        if(m_MatchChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) ==
            (UINT32) kMatchChoiceRepetitionIndex)
        {
          if(m_MatchRepChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
          {
            if(m_MatchRepShortChoiceDecoders[aState.m_Index][aPosState].Decode(&m_RangeDecoder) == 0)
            {
              aState.UpdateShortRep();
              aPreviousByte = m_OutWindowStream.GetOneByte(0 - aRepDistances[0] - 1);
              m_OutWindowStream.PutOneByte(aPreviousByte);
              aNowPos64++;
              // aCounts[3 + 4]++;
              continue;
            }
            // aCounts[3 + 0]++;
            aDistance = aRepDistances[0];
          }
          else
          {
            if(m_MatchRep1ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
            {
              aDistance = aRepDistances[1];
              aRepDistances[1] = aRepDistances[0];
              // aCounts[3 + 1]++;
            }
            else
            {
              if (m_MatchRep2ChoiceDecoders[aState.m_Index].Decode(&m_RangeDecoder) == 0)
              {
                // aCounts[3 + 2]++;
                aDistance = aRepDistances[2];
              }
              else
              {
                // aCounts[3 + 3]++;
                aDistance = aRepDistances[3];
                aRepDistances[3] = aRepDistances[2];
              }
              aRepDistances[2] = aRepDistances[1];
              aRepDistances[1] = aRepDistances[0];
            }
            aRepDistances[0] = aDistance;
          }
          aLen = m_RepMatchLenDecoder.Decode(&m_RangeDecoder, aPosState) + kMatchMinLen;
          // aCounts[aLen]++;
          aState.UpdateRep();
        }
        else
        {
          aLen = kMatchMinLen + m_LenDecoder.Decode(&m_RangeDecoder, aPosState);
          aState.UpdateMatch();
          UINT32 aPosSlot = m_PosSlotDecoder[GetLenToPosState(aLen)].Decode(&m_RangeDecoder);
          // aCounts[aPosSlot]++;
          if (aPosSlot >= (UINT32) kStartPosModelIndex)
//.........这里部分代码省略.........

CRemoteRecursiveOperation::CRemoteRecursiveOperation(CState &state)
	: CRecursiveOperation(state)
{
	state.RegisterHandler(this, STATECHANGE_REMOTE_DIR_OTHER);
	state.RegisterHandler(this, STATECHANGE_REMOTE_LINKNOTDIR);
}

void CSingleStateFeatureCalculator::getModifiedState(CStateCollection *stateCol, CState *featState)
{
	CState *state = stateCol->getState(originalState);
	CStateProperties *properties = state->getStateProperties();
	double contState = state->getContinuousState(dimension);
	double width = properties->getMaxValue(dimension) - properties->getMinValue(dimension);


	if (contState < partitions[0] && properties->getPeriodicity(dimension))
	{
		contState += width;
	}

	unsigned int activeFeature = 0;
	unsigned int featureNum = 0, realfeatureNum = 0;

	int featureIndex = 0;

	double part = partitions[activeFeature];

	while (activeFeature < numFeatures && part < contState)
	{
		activeFeature++;

		if (activeFeature < numFeatures)
		{
			part = partitions[activeFeature];
		}

		if (part < partitions[0])
		{
			assert(properties->getPeriodicity(dimension));
			part += width;
		}
	}

	
	if (activeFeature == numFeatures && !properties->getPeriodicity(dimension))
	{
		featureNum ++;
	}

	DebugPrint('l', "Single State Features: [");	
	for (; realfeatureNum < this->numActiveFeatures; realfeatureNum++, featureNum ++)
	{
		if (featureNum % 2 == 0)
		{
			featureIndex = activeFeature + featureNum / 2;
		}
		else
		{
			featureIndex = activeFeature - (featureNum / 2 + 1);
		}

		if (state->getStateProperties()->getPeriodicity(dimension))
		{
			featureIndex = featureIndex % numFeatures;
		}
		
		if (featureIndex >= 0 && featureIndex < (signed int) numFeatures)
		{
			featState->setDiscreteState(realfeatureNum, featureIndex);
			
			double stateDiff = state->getSingleStateDifference(dimension, partitions[featureIndex]);
			
			double diffNextPart = 1.0;	
					
			if (!state->getStateProperties()->getPeriodicity(dimension))
			{
				if (featureIndex == 0 && stateDiff <= 0)
				{
					stateDiff = 0;
				}
				else
				{
					if (featureIndex == (signed int) (numFeatures - 1) && stateDiff > 0)
					{
						stateDiff = 0;
					}
					else
					{
						if (stateDiff <= 0)
						{
							diffNextPart = partitions[featureIndex] - partitions[featureIndex - 1];
						}
						else
						{
							diffNextPart = partitions[featureIndex + 1] - partitions[featureIndex];
						}
					}
				}

			}
			else
			{

				if (stateDiff <= 0)
				{
					diffNextPart = partitions[featureIndex] - partitions[(numPartitions + featureIndex - 1) % numPartitions];
				}
//.........这里部分代码省略.........

void CLinearMultiFeatureCalculator::getModifiedState(CStateCollection *stateCol, CState *featState)
{
	assert(equals(featState->getStateProperties()));

	memset(actualPartition, 0, sizeof(unsigned int) * numDim);
	unsigned int j = 0;
	CState *state = stateCol->getState(originalState);

/*	printf("State : ");
	for (int i = 0; i < 4; i ++)
	{
		printf("%f ", state->getNormalizedContinuousState(i));
	}
	printf("\n");*/

	getSingleActiveFeature(state, singleStateFeatures);
	unsigned int i;
	int feature = 0;

	//offset to add to the actual feature
	int featureAdd = 0;

	getFeaturePosition(getActiveFeature(state), activePosition);
//	printf("[");
//	for (i = 0; i < numDim; i ++)
//	{
//		printf("%f ", state->getNormalizedContinuousState(dimensions[i])); 
//	}
//	printf("]");
//	activePosition->saveASCII(stdout);
//	printf("\n");

	for (i = 0; i < numDim; i ++)
	{
		int singleFeatureOffset = 0;
		if (areaSize[i] % 2 == 0)
		{
			//double x1 = state->getNormalizedContinuousState(dimensions[i]);
			//double x2 = activePosition->element(i);
			if (state->getNormalizedContinuousState(dimensions[i]) < activePosition->element(i))
			{
				singleFeatureOffset ++;
			}
			singleFeatureOffset += (areaSize[i] - 1) / 2;
		}
		else
		{
			singleFeatureOffset += areaSize[i] / 2;
		}
		singleStateFeatures[i] -= singleFeatureOffset;
		activePosition->element(i) = activePosition->element(i) - singleFeatureOffset * 1.0 / partitions[i] * gridScale[i];
	}

	unsigned int featureIndex = 0;


	for (i = 0; i < areaNumPart; i++)
	{
		feature = 0;
		/*for (j = 0; j < numDim; j++)
		{
			int dist = (actualPartition[j] - areaSize[j]);
			featurePosition->setElement(j,  (activePosition->element(j) + 1.0 / partitions[j] * dist));

			featureAdd = (singleStateFeatures[j] + (actualPartition[j] - areaSize[j]));
			if (state->getStateProperties()->getPeriodicity(j))
			{
				featurePosition->setElement(j, featurePosition->element(j) - floor(featurePosition->element(j)));
				featureAdd = featureAdd - (int) floor((double) featureAdd / (double) partitions[j]) * partitions[j];
			}

			feature = feature + featureAdd * dimensionSize[j];
		} */
		/*for (j = 0; j < numDim; j++)
		{
			int dist = (actualPartition[j] - 1);
			featurePosition->setElement(j,  (activePosition->element(j) + 1.0 / partitions[j] * dist));

			featureAdd = (singleStateFeatures[j] + (actualPartition[j] - 1));
			if (state->getStateProperties()->getPeriodicity(j))
			{
				featurePosition->setElement(j, featurePosition->element(j) - floor(featurePosition->element(j)));
				featureAdd = featureAdd - (int) floor((double) featureAdd / (double) partitions[j]) * partitions[j];
			}
			
			feature = feature + featureAdd * dimensionSize[j];
		} 
		for (i = 0; i < numDim; i ++)
		{
			int singleFeatureOffset = 0;
			if (areaSize[i] % 2 == 0)
			{
				if (state->getContinuousState(dimensions[i]) < activePosition->element(i))
				{
					singleFeatureOffset ++;
				}
				singleFeatureOffset += (singleFeatureOffset - 1) / 2;
			}
			else
			{
//.........这里部分代码省略.........

	void CAuthModule::Handle_Login_Packet( CLoginPacket* pPacket, CConnection* pConnection ) {
		// Make sure username is in all lowercase
		std::string Name = pPacket->Get_Username();
		std::transform(Name.begin(), Name.end(), Name.begin(), ::tolower);
	
		// This will try loading from disk if it isn't already in mem
		CUser* pUser = Get_User_By_Name( Name );
		
		if( !pUser ) {
			// Not loaded in mem, can't loaded from disk
	
			// Check if we are allowing new users
			CStateModule* pStateModule = (CStateModule*)GETMODULE(MODULE_STATE);
			CState* pState = pStateModule->Get_Current_State();
			
			// Only Master server can create new users
			if( (CDCEngine::GetInstance()->Get_Driver_Mode() == MODE_MASTER) && (pState->Allow_New_User()) ) {
			
				DLog(LOG_AUTH, "Creating new user: %s\n", Name.c_str());
				
				CPlayer* pPlayer = NULL;

				// Create the new User obj
				pPlayer = (CPlayer*)Create_New_User( pPacket->Get_UserType() );
				pPlayer->m_Name = Name;
				pPlayer->m_Password = pPacket->Get_Password();
				
				// Establish link between connection and user
				pPlayer->m_pConnection = pConnection;
				pConnection->m_pUser = pPlayer;

				// Add to loaded users map
				m_UsersByName.insert( USER_MAP_NAME_PAIR(pPlayer->Get_Name(),pPlayer) );
				m_UsersByID.insert( USER_MAP_ID_PAIR(pPlayer->Get_UserID(), pPlayer) );
				
				// Send Ident
				Send_Ident( pConnection );
				
				// Notify engine of new login
				CDCEngine::GetInstance()->On_New_Login( pPlayer );
				
				return;
			}
			// Disconnect this connection
			Log(LOG_DRIVER, "Not allowing new users, disconnecting: %s:%d\n", pConnection->Get_Address().c_str(), pConnection->Get_Port());
			m_pNetworkModule->Disconnect_Connection( pConnection->Get_ID(), DR_NO_NEW_USERS );
			
			return;
		}
		
		// User is loaded
		DLog(LOG_AUTH, "User logged in new: %s\n", pUser->Get_Name().c_str());

		// Link connection and user
		pUser->m_pConnection = pConnection;
		pConnection->m_pUser = pUser;
		
		// Send Ident
		Send_Ident( pConnection );
		
		// Notify Engine
		CDCEngine::GetInstance()->On_New_Login( pUser );
		
		return;
	}

void CFeatureRewardModel::nextStep(CStateCollection *oldState, CAction *action, double reward, CStateCollection *newState)
{
	CFeatureMap *featMap;

	CState *oldS = oldState->getState(properties);
	CState *newS = newState->getState(properties);

	double oldreward = 0.0;
	double visits = 0.0;

	int actionIndex = getActions()->getIndex(action);
	
	int type = oldS->getStateProperties()->getType() & (DISCRETESTATE | FEATURESTATE);
	switch (type)
	{
		case FEATURESTATE:
		{
			for (unsigned int oldIndex = 0; oldIndex < oldS->getNumDiscreteStates(); oldIndex++)
			{
				int oldFeature = oldS->getDiscreteState(oldIndex);
				featMap = rewardTable->get(actionIndex, oldFeature);

				for (unsigned int newIndex = 0; newIndex < newS->getNumDiscreteStates(); newIndex++)
				{
					int newFeature = newS->getDiscreteState(newIndex);

					oldreward = featMap->getValue(newFeature);
				

					(*featMap)[newFeature] = oldreward + reward * newS->getContinuousState(newIndex) * oldS->getContinuousState(oldIndex);
					
					if (!bExternVisitSparse)
					{
						visits = visitTable->get(actionIndex, oldFeature)->getValue(newFeature);
					
						(*visitTable->get(actionIndex, oldFeature))[newFeature] = visits + newS->getContinuousState(newIndex) * oldS->getContinuousState(oldIndex);;
					}
				}
			}
			break;
		}
		case DISCRETESTATE:
		default: 
		{
			featMap = rewardTable->get(actionIndex, oldS->getDiscreteStateNumber());

			oldreward = featMap->getValue(newS->getDiscreteStateNumber());
		
			int feata = oldS->getDiscreteStateNumber();
			int featb = newS->getDiscreteStateNumber();

			(*featMap)[featb] = oldreward + reward;
			
			if (!bExternVisitSparse)
			{
				visits = visitTable->get(actionIndex, feata)->getValue(featb);
			
				(*visitTable->get(actionIndex, feata))[featb] = visits + 1.0;
			}
			break;
		}
	}
}

void MainApplication::runApplication(int argc, char *argv[])
{
    double dt, T, Tbath, tau, L;
    int nSteps, thermostat, N, calculateStatistics, saveStates;

    if (argc != 11)
    {
        cout << endl << "! Usage: 'dt nSteps T(MD) thermostat#(0,1,2) Tbath(MD) tau L(SI) N calculateStatistics saveStates'" << endl;
        if (argc == 1)
        {
            dt = 0.005;
            nSteps = 200;
            T = 1.7; // to get 0.851
            thermostat = 1;
            Tbath = 0.851;
            tau = 15;
            L = 5.720;
            N = 20;
            calculateStatistics = 1;
            saveStates = 0;

            cout << endl << "! Using default of: dt = " << dt << ", nSteps = " << nSteps << ", T = " << T
                 << ", thermostat# = " << thermostat << ", Tbath = " << Tbath
                 << ", tau = " << tau << ", L = " << L
                 << ", N = " << N << ", statistics? = " << calculateStatistics
                 << ", save states? = " << saveStates << endl << endl;
        } else
            exit(1);
    }
    else if (argc == 11)
    {
        dt = atof(argv[1]);
        nSteps = atoi(argv[2]);
        T = atof(argv[3]);
        thermostat = atoi(argv[4]);
        Tbath = atof(argv[5]);
        tau = atof(argv[6]);
        L = atof(argv[7]);
        N = atoi(argv[8]);
        calculateStatistics = atoi(argv[9]);
        saveStates = atoi(argv[10]);
    }

    double tt = 1.0/10;
    long seed = -1;
    cout << "dt                 :    " << dt << endl;
    cout << "Tbath              :    " << Tbath << endl;

    CState state;
    state = initialize(T, L, N, &seed);
    CStatisticsSampler sampler(state);
    sampler.initialize_pairCorrelation(200, 1);

    ostringstream filename;

//    state.load("./output/states/state.1000.xyz");
    for (int i = 0; i < nSteps; i++)
    {
        if (i%50==0) cout << "n = " << i << " of " << nSteps << endl;

        filename.str(string());
        filename << "./output/states/state." << setfill('0') << setw(4) << i << ".xyz";

        if (saveStates) state.save(filename.str(), 1, 1);

        if (calculateStatistics) sampler.sample(state, 1, dt*i);
//        if (i>250) sampler.pairCorrelation();

        if (thermostat == 1 && calculateStatistics) state.berendsen(Tbath, sampler.T, tt);
        else if (thermostat == 2) state.andersen(Tbath, tt, &seed);

        state.move(dt, calculateStatistics);
    }
    sampler.sample(state, 1, nSteps*dt);
//    filename.str(string());
//    filename << "./output/states/state." << setfill('0') << setw(4) << nSteps << ".xyz";
//    state.save(filename.str(), 0, 0);

//    sampler.pairCorrelation_manual("./output/pairCorrelation_final.dat", 1, 200);
}