void PeakMatchingResults::GetMatches(std::vector<int> &vectFeatureIndices, std::vector<int> &vectMassTagIndices, std::vector<int> &vectProteinIndices , const std::vector<MultiAlignEngine::MassTags::Protein>* &vectProteins, const std::vector<MultiAlignEngine::MassTags::MassTag>* &vectMasstags) const { // The mass tag database has stored in it all the proteins and mass tags corresponding to the matches. // So thats where we need to get all the data from. int numMatches = (int) mvectPeakMatches.size(); std::set <int> massTagID; stdext::hash_map <int, int > massTagSeen; // first get all mass tags in the matches into the set of mass tags. for (int matchNum = 0; matchNum < numMatches; matchNum++) { PeakMatch match = mvectPeakMatches[matchNum]; massTagSeen.insert(std::pair<int,int>(match.mintMasstagID, matchNum)); } // copy hash to mass tag vector std::vector<int> vectMassTagIDs; vectMassTagIDs.reserve(massTagSeen.size()); for (stdext::hash_map <int, int >::iterator massTagIter = massTagSeen.begin(); massTagIter != massTagSeen.end(); massTagIter++) { vectMassTagIDs.push_back((*massTagIter).first); } vectMasstags = mobjMasstagDB.GetMassTagVector(); vectProteins = mobjMasstagDB.GetProteinVector(); const std::multimap<int,int> mapMassTagId2ProteinIndex = mobjMasstagDB.GetMassTagId2ProteinIndexMap(); const stdext::hash_map <int, int > hashMapMassTagId2Index = mobjMasstagDB.GetMassTagId2IndexHash(); // now the relevant mass tags are copied, their ids are copied, the protein names are copied. // So lets create the table of matches using the three vectors vectFeatureIndices, vectMassTagIndices and // vectProteinIndices. Basically, vectFeatureIndices will have the index of the ms feature in a peak match. // the vectMassTagIndices will have the corresponding massTagID, and vectProteinIndices will have the corresponding // parent protein. for (std::multimap<int,int>::const_iterator featureIter = mmapFeatureIndex2PeakMatch.begin(); featureIter != mmapFeatureIndex2PeakMatch.end(); featureIter++) { int featureIndex = (*featureIter).first; int peakMatchIndex = (*featureIter).second; PeakMatch pkMatch = mvectPeakMatches[peakMatchIndex]; int massTagID = pkMatch.mintMasstagID; stdext::hash_map <int, int>::const_iterator massTagIterHash = hashMapMassTagId2Index.find(massTagID); int massTagIndex = (*massTagIterHash).second; // now go through each of the parent proteins of this massTagID and push the triplet into their // corresponding vectors for (std::multimap<int,int>::const_iterator massTagIter = mapMassTagId2ProteinIndex.find(massTagID); massTagIter != mapMassTagId2ProteinIndex.end(); massTagIter++) { if ((*massTagIter).first != massTagID) break; vectFeatureIndices.push_back(featureIndex); vectMassTagIndices.push_back(massTagIndex); vectProteinIndices.push_back((*massTagIter).second); } } }
virtual void ProcessingMaterial(GLMmodel* model, KScene& scene, const stdext::hash_map<UINT32, UINT32>& nodeToMtl) { // Create material KMaterialLibrary* pML = KMaterialLibrary::GetInstance(); for (UINT32 mi = 0; mi < model->nummaterials; ++mi) { ISurfaceShader* pSurfShader = pML->CreateMaterial("simple_phong_default.template", model->materials[mi].name); pSurfShader->SetParam("diffuse_color", model->materials[mi].diffuse, sizeof(float)*3); if (model->materials[mi].shininess > 3.0f) { pSurfShader->SetParam("specular_color", model->materials[mi].specular, sizeof(float)*3); pSurfShader->SetParam("power", &model->materials[mi].shininess, sizeof(float)); } else { float specular[3] = {0,0,0}; float pow = 0; pSurfShader->SetParam("specular_color", specular, sizeof(float)*3); pSurfShader->SetParam("power", &pow, sizeof(float)); } pSurfShader->SetParam("opacity", model->materials[mi].transparency, sizeof(float)*3); if (mUseTexMap && model->materials[mi].diffuse_map) { pSurfShader->SetParam("diffuse_map", model->materials[mi].diffuse_map, 0); } } for (UINT32 i = 0; i < scene.GetNodeCnt(); ++i) { KNode* pNode = scene.GetNode(i); stdext::hash_map<UINT32, UINT32>::const_iterator it = nodeToMtl.find(i); assert(it != nodeToMtl.end()); pNode->mpSurfShader = pML->OpenMaterial(model->materials[it->second].name); } }
/********************************************************************************************************************** CConvertibleEnum::Convert_Internal -- internal function to convert from an integer value to a string value -- integer to convert from entry_name -- output parameter for the string value Returns: success/failure **********************************************************************************************************************/ bool CConvertibleEnum::Convert_Internal( uint64 value, std::string &entry_name ) const { auto iter = ValueToNameTable.find( value ); if ( iter == ValueToNameTable.end() ) { return false; } entry_name = iter->second; return true; }
/********************************************************************************************************************** CConvertibleEnum::Convert_Internal -- internal function to convert from a string to an integer value entry_name -- string value to convert from output_value -- output parameter for the integer to convert to Returns: success/failure **********************************************************************************************************************/ bool CConvertibleEnum::Convert_Internal( const std::string &entry_name, uint64 &output_value ) const { std::string upper_entry_name; NStringUtils::To_Upper_Case( entry_name, upper_entry_name ); auto iter = NameToValueTable.find( upper_entry_name ); if ( iter == NameToValueTable.end() ) { return false; } output_value = iter->second; return true; }
/********************************************************************************************************************** CConvertibleEnum::Register_Entry -- registers a string and integer value pair as convertible entry_name -- corresponding string value value -- integer to convert to/from **********************************************************************************************************************/ void CConvertibleEnum::Register_Entry( const std::string &entry_name, uint64 value ) { std::string upper_entry_name; NStringUtils::To_Upper_Case( entry_name, upper_entry_name ); auto name_iter = NameToValueTable.find( upper_entry_name ); FATAL_ASSERT( name_iter == NameToValueTable.end() ); auto value_iter = ValueToNameTable.find( value ); FATAL_ASSERT( value_iter == ValueToNameTable.end() ); NameToValueTable[ upper_entry_name ] = value; ValueToNameTable[ value ] = upper_entry_name; }
HRESULT __wrapper_FilterGetMessage( HANDLE hPort, PFILTER_MESSAGE_HEADER lpMessageBuffer, DWORD dwMessageBufferSize, LPOVERLAPPED lpOverlapped ) { Chess::SyncVarAccess(GetWin32SyncManager()->GetSyncVarFromHandle(hPorte), SVOP::FLT_RW); if(qsize.find(hPorte) == qsize.end()) qsize[hPorte] = 0; if(lpOverlapped != NULL){ HRESULT ret = Real_FilterGetMessage(hPort, lpMessageBuffer, dwMessageBufferSize, lpOverlapped); if(ret == ERROR_IO_PENDING) qsize[hPorte]++; return ret; } LPOVERLAPPED myOverlapped; OVERLAPPED tempOverlapped; memset(&tempOverlapped, 0, sizeof(OVERLAPPED)); myOverlapped = &tempOverlapped; myOverlapped->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL); HRESULT ret = Real_FilterGetMessage(hPort, lpMessageBuffer, dwMessageBufferSize, myOverlapped); //if(ret != S_OK || ret != ERROR_IO_PENDING) // return ret; assert(ret != S_OK); qsize[hPorte]++; Chess::SyncVarAccess(GetWin32SyncManager()->GetSyncVarFromHandle(hPorte), SVOP::FLT_RW); while(true){ HRESULT retVal = WaitForSingleObject(myOverlapped->hEvent, 0); switch(retVal){ case WAIT_OBJECT_0 : CloseHandle(myOverlapped->hEvent); return S_OK; case WAIT_TIMEOUT : Chess::LocalBacktrack(); break; default: fprintf(stderr, "Waiting for event failed in Wrapper FilterGetMessage"); return retVal; } } assert(false); return S_OK; }
HRESULT __wrapper_FilterSendMessage( HANDLE hPort, LPVOID lpInBuffer, DWORD dwInBufferSize, LPVOID lpOutBuffer, DWORD dwOutBufferSize, LPDWORD lpBytesReturned ) { Chess::SyncVarAccess(GetWin32SyncManager()->GetSyncVarFromHandle(hPorte), SVOP::FLT_RW); if(qsize.find(hPorte) == qsize.end()) qsize[hPorte] = 0; while(qsize[hPorte] == 0){ Chess::LocalBacktrack(); } qsize[hPorte]--; return Real_FilterSendMessage(hPort, lpInBuffer, dwInBufferSize, lpOutBuffer, dwOutBufferSize, lpBytesReturned); }
static void push( lua_State* lua_state, const stdext::hash_map<Key, Data, Traits, Allocator>& value ) { lua_push( lua_state, value.begin(), value.end() ); }
DWORD _stdcall AIGetLastTarget(DWORD source) { iter itr=targets.find(source); if(itr==targets.end()) return 0; else return itr->second; }
DWORD _stdcall AIGetLastAttacker(DWORD target) { iter itr=sources.find(target); if(itr==sources.end()) return 0; else return itr->second; }
bool LoadDIASymbols(const wxString &strPDBFile, wxInt32 modulenum, std::list<CFunctionDescription> & llFuncs, stdext::hash_map<BasedAddress,int> & addressmap ) { // Create DIA80 Data Source Object IDiaDataSource *pDataSource; HRESULT hr = NoRegCoCreate( L"msdia80.dll", _uuidof( DiaSource ), _uuidof( IDiaDataSource ), (void **) &(pDataSource)); if(!SUCCEEDED(hr)) { return false; } /* HMODULE mod=LoadLibrary(L"msdia80.dll"); if(!mod) { return false; } TYPEOF_DllGetClassObject *pGetClassObject=(TYPEOF_DllGetClassObject *)GetProcAddress(mod,"DllGetClassObject"); if(!pGetClassObject) { FreeLibrary(mod); return false; } IClassFactory *pcf; HRESULT hr=(*pGetClassObject)(CLSID_DiaSource,IID_IClassFactory,(void **)&pcf); if(!SUCCEEDED(hr)) { FreeLibrary(mod); return false; } IDiaDataSource *pDataSource; hr=pcf->CreateInstance(NULL,_uuidof(IDiaDataSource),(void **)&pDataSource); if(!SUCCEEDED(hr)) { pcf->Release(); FreeLibrary(mod); return false; } pcf->Release(); */ // Load the executable's debug symbols hr=pDataSource->loadDataFromPdb(strPDBFile); if(!SUCCEEDED(hr)) { pDataSource->Release(); return false; } // Open a symbol session IDiaSession *pDIASession; hr=pDataSource->openSession(&pDIASession); if(!SUCCEEDED(hr)) { pDataSource->Release(); return false; } // Set the UNBASED address on the session, for resolving BasedAddress addrs hr=pDIASession->put_loadAddress(0); if(!SUCCEEDED(hr)) { pDIASession->Release(); pDataSource->Release(); return false; } // Get addresses for this module std::list<BasedAddress> addresses; for(stdext::hash_map<BasedAddress,int>::iterator iter=addressmap.begin();iter!=addressmap.end();iter++) { if(iter->first.nModule==modulenum) { addresses.push_back(iter->first); } } stdext::hash_map<DWORD,wxInt32> functions; int curidx=(int)llFuncs.size(); for(std::list<BasedAddress>::iterator itera=addresses.begin();itera!=addresses.end();itera++) { // Get the symbol for this thing IDiaSymbol* pFunc; if(FAILED(pDIASession->findSymbolByVA(itera->nAddr, SymTagFunction, &pFunc)) || pFunc==NULL) { continue; } // Get the unique symbol index id DWORD indexId; if(FAILED(pFunc->get_symIndexId(&indexId))) { pFunc->Release(); continue; } // See if we have this function already stdext::hash_map<DWORD,int>::iterator iterf=functions.find(indexId); if(iterf!=functions.end()) { addressmap[*itera]=iterf->second; } else { CFunctionDescription func; ////// ULONGLONG addr; if(FAILED(pFunc->get_virtualAddress(&addr))) { pFunc->Release(); continue; } ////// ULONGLONG length; if(FAILED(pFunc->get_length(&length))) { pFunc->Release(); continue; } ///////// BSTR pName; if(FAILED(pFunc->get_name(&pName))) { pFunc->Release(); continue; } func.strMangledName=(const LPWSTR)pName; LocalFree(pName); char mangled[512]; WideCharToMultiByte(CP_UTF8,0,func.strMangledName,-1,mangled,512,NULL,NULL); ///////// char outbase[512]; __unDName(outbase,mangled,512,&malloc,&free,0x1000); wchar_t outbasew[512]; MultiByteToWideChar(CP_UTF8,0,outbase,-1,outbasew,512); func.strBaseName=(const wchar_t *)(outbasew); ///////// char outfull[512]; __unDName(outfull,mangled,512,&malloc,&free,0); wchar_t outfullw[512]; MultiByteToWideChar(CP_UTF8,0,outfull,-1,outfullw,512); func.strFullName=(const wchar_t *)(outfullw); ////////// func.nAddress=BasedAddress(addr,modulenum); func.nByteLength=length; ///////// IDiaEnumLineNumbers *pdeln; func.strSourceFile=wxT("<unknown>"); func.nFirstSourceLine=0; func.nLastSourceLine=0; bool bGotFile=false; if(SUCCEEDED(pDIASession->findLinesByVA(addr,length,&pdeln))) { IDiaLineNumber *pdln; int nLineItem=0; while(SUCCEEDED(pdeln->Item(nLineItem,&pdln))) { DWORD dwLineNumber; IDiaSourceFile *pdsf; if(SUCCEEDED(pdln->get_lineNumber(&dwLineNumber)) && SUCCEEDED(pdln->get_sourceFile(&pdsf))) { BSTR filename; if(SUCCEEDED(pdsf->get_fileName(&filename))) { if(bGotFile) { if(filename==func.strSourceFile) { if(dwLineNumber<func.nFirstSourceLine) { func.nFirstSourceLine=dwLineNumber; } if(dwLineNumber>func.nLastSourceLine) { func.nLastSourceLine=dwLineNumber; } } } else { bGotFile=true; func.strSourceFile=filename; func.nFirstSourceLine=dwLineNumber; func.nLastSourceLine=dwLineNumber; } LocalFree(filename); } pdsf->Release(); } pdln->Release(); nLineItem++; } pdeln->Release(); } llFuncs.push_back(func); functions[indexId]=curidx; addressmap[*itera]=curidx; curidx++; } } pDIASession->Release(); pDataSource->Release(); // FreeLibrary(mod); return true; }