bool ConsoleCommandParserCombatEngine::performParsing (const NetworkId & userId, const StringVector_t & argv, const String_t & originalCommand, String_t & result, const CommandParser * node) { NOT_NULL (node); UNREF (userId); UNREF(originalCommand); //----------------------------------------------------------------- if (isAbbrev( argv [0], "reload")) { if (CombatEngine::reloadCombatData()) result += getErrorMessage(argv[0], ERR_SUCCESS); else result += getErrorMessage(argv[0], ERR_NO_ERROR_MSG); } //----------------------------------------------------------------- else { result += getErrorMessage(argv[0], ERR_NO_HANDLER); } return true; }
bool Renderer::CreateTimerQuery() { ::IDirect3DDevice9 *lpD3DDevice = static_cast<::IDirect3DDevice9 *>(this->mpD3DDevice); ::IDirect3DQuery9 *lpQuery = 0; ::HRESULT lResult; lResult = lpD3DDevice->CreateQuery(::D3DQUERYTYPE_TIMESTAMPFREQ, &lpQuery); if (FAILED(lResult)) { REPORTERROR2("CreatePixelShader failed, HR=0x%x '%s'", lResult, getErrorMessage(lResult)); return false; } uint64 lu64TimerFrequency; while (S_FALSE == lpQuery->GetData(&lu64TimerFrequency, sizeof(lu64TimerFrequency), D3DGETDATA_FLUSH)) { } lpQuery->Release(); lResult = lpD3DDevice->CreateQuery(::D3DQUERYTYPE_TIMESTAMP, &lpQuery); if (FAILED(lResult)) { REPORTERROR2("CreatePixelShader failed, HR=0x%x '%s'", lResult, getErrorMessage(lResult)); return false; } this->mu64TimerFrequency = lu64TimerFrequency; this->mpTimerQuery = lpQuery; return true; }
/****************************************************************************** * AUTHOR : Balaji R. * DATE : 23-DEC-2004 * NAME : LTKTraceGroup * DESCRIPTION : Initialization constructor * ARGUMENTS : inTraceVector - vector of traces to be set to class member * RETURNS : * NOTES : * CHANGE HISTROY * Author Date Description of change ******************************************************************************/ LTKTraceGroup::LTKTraceGroup(const LTKTraceVector& inTraceVector, float xScaleFactor, float yScaleFactor) : m_traceVector(inTraceVector) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Enter: LTKTraceGroup::LTKTraceGroup(LTKTraceVector&, float,float)"<<endl; if(xScaleFactor <= 0) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<<EINVALID_X_SCALE_FACTOR <<": "<< getErrorMessage(EINVALID_X_SCALE_FACTOR) << "LTKTraceGroup::LTKTraceGroup(LTKTraceVector&, float,float)"<<endl; throw LTKException(EINVALID_X_SCALE_FACTOR); } if(yScaleFactor <= 0) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<<EINVALID_Y_SCALE_FACTOR <<": "<< getErrorMessage(EINVALID_Y_SCALE_FACTOR) << "LTKTraceGroup::LTKTraceGroup(LTKTraceVector&, float,float)"<<endl; throw LTKException(EINVALID_Y_SCALE_FACTOR); } m_xScaleFactor = xScaleFactor; m_yScaleFactor = yScaleFactor; LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exit: LTKTraceGroup::LTKTraceGroup(LTKTraceVector&, float,float)"<<endl; }
/****************************************************************************** * AUTHOR : Nidhi sharma * DATE : 08-Feb-2007 * NAME : LTKLipiEngineModule::validateProfile * DESCRIPTION : * ARGUMENTS : * RETURNS : * NOTES : * CHANGE HISTROY * Author Date Description of change * ******************************************************************************/ int LTKLipiEngineModule::validateProfile(const string& strProjectName, const string& strProfileName, const string& projectType, string& outRecognizerString) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Entering: LTKLipiEngineModule::validateProfile()"<<endl; int errorCode; string profileCfgPath = m_strLipiRootPath + PROJECTS_PATH_STRING + strProjectName + PROFILE_PATH_STRING + strProfileName + SEPARATOR + PROFILE_CFG_STRING; LTKConfigFileReader* profileConfigReader = NULL; try { profileConfigReader = new LTKConfigFileReader(profileCfgPath); } catch(LTKException e) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<< getErrorMessage(e.getErrorCode()) << profileCfgPath << " LTKLipiEngineModule::validateProfile()"<<endl; LTKReturnError(e.getErrorCode()); } errorCode = profileConfigReader->getConfigValue(projectType, outRecognizerString); if(errorCode != SUCCESS) { /* No recognizer specified. */ if (projectType == SHAPE_RECOGNIZER_STRING ) { errorCode = ENO_SHAPE_RECOGNIZER; } else { errorCode = ENO_WORD_RECOGNIZER; } LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<< getErrorMessage(errorCode) << profileCfgPath << " LTKLipiEngineModule::validateProfile()"<<endl; delete profileConfigReader; LTKReturnError(errorCode); } delete profileConfigReader; LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting: LTKLipiEngineModule::validateProfile()"<<endl; return SUCCESS; }
/****************************************************************************** * AUTHOR : Nidhi sharma * DATE : 08-Feb-2007 * NAME : LTKLipiEngineModule::validateProject * DESCRIPTION : * ARGUMENTS : * RETURNS : * NOTES : * CHANGE HISTROY * Author Date Description of change * *******************************************************************************/ int LTKLipiEngineModule::validateProject(const string& strProjectName, const string& projectType) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Enterng: LTKLipiEngineModule::validateProject()"<<endl; LTKConfigFileReader* projectConfigReader = NULL; string projectTypeCfgEntry = ""; if(strProjectName == "") { /* invalid or no entry for project name */ LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<< getErrorMessage(EINVALID_PROJECT_NAME) << "LTKLipiEngineModule::validateProject()"<<endl; LTKReturnError(EINVALID_PROJECT_NAME); } string projectCfgPath = m_strLipiRootPath + PROJECTS_PATH_STRING + strProjectName + PROFILE_PATH_STRING + PROJECT_CFG_STRING; try { projectConfigReader = new LTKConfigFileReader(projectCfgPath); } catch(LTKException e) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<< getErrorMessage(e.getErrorCode()) << projectCfgPath << " LTKLipiEngineModule::validateProject()"<<endl; LTKReturnError(EINVALID_PROJECT_NAME); } int errorCode = projectConfigReader->getConfigValue(PROJECT_TYPE_STRING, projectTypeCfgEntry); if( errorCode != SUCCESS || projectTypeCfgEntry != projectType) { /* Invalid configuration entry for ProjectType */ LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: "<< getErrorMessage(EINVALID_PROJECT_TYPE) << " LTKLipiEngineModule::validateProject()"<<endl; delete projectConfigReader; //Project type in CFG is missing or an invalid value LTKReturnError(EINVALID_PROJECT_TYPE); } delete projectConfigReader; LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting: LTKLipiEngineModule::validateProject()"<<endl; return SUCCESS; }
/****************************************************************************** * AUTHOR : Thanigai * DATE : 29-JUL-2005 * NAME : mapShapeAlgoModuleFunctions * DESCRIPTION : To map function addresses of the methods exposed by * the shape recognition modules * ARGUMENTS : None * RETURNS : 0 on success and other values on error * NOTES : * CHANGE HISTROY * Author Date Description of change ******************************************************************************/ int LTKLipiEngineModule::mapShapeAlgoModuleFunctions(void *dllHandle) { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)<< "Entering: LTKLipiEngineModule::mapShapeAlgoModuleFunctions()"<<endl; module_createShapeRecognizer = NULL; module_deleteShapeRecognizer = NULL; void* functionHandle = NULL; int returnVal = m_OSUtilPtr->getFunctionAddress(dllHandle, CREATESHAPERECOGNIZER_FUNC_NAME, &functionHandle); // Could not map the function from the DLL if(returnVal != SUCCESS) { LOG(LTKLogger::LTK_LOGLEVEL_ERR)<< "Error: "<< getErrorMessage(EDLL_FUNC_ADDRESS) <<" "<<CREATESHAPERECOGNIZER_FUNC_NAME <<" "<<"LTKLipiEngineModule::mapShapeAlgoModuleFunctions()"<<endl; m_OSUtilPtr->unloadSharedLib(dllHandle); LTKReturnError(EDLL_FUNC_ADDRESS); } module_createShapeRecognizer = (FN_PTR_CREATESHAPERECOGNIZER)functionHandle; functionHandle = NULL; returnVal = m_OSUtilPtr->getFunctionAddress(dllHandle, DELETESHAPERECOGNIZER_FUNC_NAME, &functionHandle); // Could not map the function from the DLL if(returnVal != SUCCESS) { LOG(LTKLogger::LTK_LOGLEVEL_ERR)<< "Error: "<< getErrorMessage(EDLL_FUNC_ADDRESS) <<" "<<DELETESHAPERECOGNIZER_FUNC_NAME <<" "<<"LTKLipiEngineModule::mapShapeAlgoModuleFunctions()"<<endl; m_OSUtilPtr->unloadSharedLib(dllHandle); LTKReturnError(EDLL_FUNC_ADDRESS); } module_deleteShapeRecognizer = (FN_PTR_DELETESHAPERECOGNIZER)functionHandle; LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)<< "Exiting: LTKLipiEngineModule::mapShapeAlgoModuleFunctions()"<<endl; return SUCCESS; }
bool Socket::bindImpl(const std::string& hostname,int port) { close(); addrinfo* p=getAddrInfo(hostname.c_str(),port,false); for(;p != 0; p = p->ai_next) { m_socket=socket(p->ai_family,p->ai_socktype,p->ai_protocol); if(m_socket == int(INVALID_SOCKET)) { std::cerr<<"Cannot create a socket: "<<getErrorMessage()<<std::endl; continue; } if(::bind(m_socket,p->ai_addr,p->ai_addrlen)==SOCKET_ERROR) { std::cerr<<"Cannot bind to port "<<port<<": "<<getErrorMessage()<<std::endl; close(); continue; } break; } freeAddrInfo(p); if(!p) { std::cerr<<"Cannot create a socket: "<<getErrorMessage()<<std::endl; return false; } if(listen(m_socket,10)==SOCKET_ERROR) { std::cerr<<"Cannot listen socket:"<<getErrorMessage()<<std::endl; close(); return false; } if(setNonBlock(m_socket) == false) { std::cerr<<"Cannot set socket to non-blocking mode: "<<getErrorMessage()<<std::endl; close(); return false; } return true; }
int NPenShapeFeatureExtractor::readConfig(const string& cfgFilePath) { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Entering " << "NPenShapeFeatureExtractor::readConfig()" << endl; LTKConfigFileReader* configurableProperties = NULL; string tempStringVar = ""; try { configurableProperties = new LTKConfigFileReader(cfgFilePath); int errorCode = configurableProperties->getConfigValue(NPEN_WINDOW_SIZE, tempStringVar); if( errorCode == SUCCESS) { if (setWindowSize(atoi((tempStringVar).c_str())) != SUCCESS) { LOG(LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << ECONFIG_FILE_RANGE << " : " << getErrorMessage(ECONFIG_FILE_RANGE) << " NPenShapeFeatureExtractor::readConfig" <<endl; throw LTKReturnError(ECONFIG_FILE_RANGE); } } } catch(LTKException e) { delete configurableProperties; int eCode = e.getErrorCode(); LOG(LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << eCode << " : " << getErrorMessage(eCode) << " NPenShapeFeatureExtractor::readConfig" <<endl; LTKReturnError(eCode); } delete configurableProperties; LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting " << "NPenShapeFeatureExtractor::readConfig()" << endl; return SUCCESS; }
//----------------------------------------------- CanESD::CanESD(int iIniBaudRate, int iNrNet) { //initial values int net=1; /* logical net number (here: 0) */ uint32_t mode=0; /* mode used for canOpen() */ int32_t txqueuesize=100; /* size of transmit queue */ int32_t rxqueuesize=100; /* size of receive queue */ int32_t txtimeout=0; /* timeout for transmit operations in ms */ int32_t rxtimeout=0; /* timeout for receive operations in ms */ NTCAN_RESULT retvalue; /* return values of NTCAN API calls */ //uint32_t baud=2; /* configured CAN baudrate (here: 500 kBit/s.) */ CMSG cmsg[8]; /* can message buffer */ int rtr=0; /* rtr bit */ int32_t len; /* # of CAN messages */ retvalue = canOpen(iNrNet, mode, txqueuesize, rxqueuesize, txtimeout, rxtimeout, &m_Handle); if (retvalue != NTCAN_SUCCESS) { LOGINFO("canOpen() failed: " << getErrorMessage(retvalue)); } Sleep(300); retvalue = canSetBaudrate(m_Handle, getBaudRate(iIniBaudRate)); if (retvalue != 0) { LOGINFO("canSetBaudrate() failed: " << getErrorMessage(retvalue)); canClose(m_Handle); } else { LOGINFO("Baudrate set to " << getBaudRate(iIniBaudRate)); } Sleep(300); //set Amtek Arm IDs int i; for(i=1; i < 2048; i++) { retvalue = canIdAdd(m_Handle, i); if (retvalue != NTCAN_SUCCESS) { LOGERROR("canIdAdd() failed: " << getErrorMessage(retvalue)); } } Sleep(300); m_LastID = -1; }
/****************************************************************************** * AUTHOR : Thanigai * DATE : 29-JUL-2005 * NAME : deleteWordRecognizer * DESCRIPTION : To delete the recognizer object which is created * using "createWordRecognizer" call * ARGUMENTS : obj - handle the previously created recognizer object * RETURNS : 0 on success other values error * NOTES : * CHANGE HISTROY * Author Date Description of change ******************************************************************************/ int LTKLipiEngineModule::deleteWordRecognizer(LTKWordRecognizer* obj) { LOG(LTKLogger::LTK_LOGLEVEL_INFO)<< "Entering: LTKLipiEngineModule::deleteWordRecognizer()"<<endl; int errorCode; // Call recognition module's deleteWordRecognizer(obj) if(obj) { deleteModule(obj); errorCode = module_deleteWordRecognizer(obj); if(errorCode !=SUCCESS) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << getErrorMessage(errorCode) << "LTKLipiEngineModule::deleteShapeRecognizer()"<<endl; LTKReturnError(errorCode); } obj = NULL; } LOG(LTKLogger::LTK_LOGLEVEL_INFO)<< "Exiting: LTKLipiEngineModule::deleteWordRecognizer()"<<endl; return SUCCESS; }
/****************************************************************************** * AUTHOR : Saravanan R. * DATE : 09-Feb-2007 * NAME : * DESCRIPTION : * ARGUMENTS : * RETURNS : * NOTES : * CHANGE HISTROY * Author Date Description of change * ******************************************************************************/ int LTKLipiEngineModule::loadRecognizerDLL(const string& recognizerName, void **dllHandler) { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)<< "Entering: LTKLipiEngineModule::loadRecognizerDLL()"<<endl; string recognizerDLLPath = ""; int returnVal = SUCCESS; returnVal = m_OSUtilPtr->loadSharedLib(m_strLipiRootPath, recognizerName, dllHandler); if(returnVal != SUCCESS) { LOG(LTKLogger::LTK_LOGLEVEL_ERR)<< "Error: "<< getErrorMessage(ELOAD_SHAPEREC_DLL) <<" "<<recognizerDLLPath << "LTKLipiEngineModule::loadRecognizerDLL()"<<endl; LTKReturnError(ELOAD_SHAPEREC_DLL); } LOG(LTKLogger::LTK_LOGLEVEL_DEBUG)<< "Exiting: LTKLipiEngineModule::loadRecognizerDLL()"<<endl; return SUCCESS; }
void PINExchangeProcess::finalize() { if(!success) { LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token!") np->handleMessage(user, "twitter-account", "Error while exchanging PIN for Access Token!"); np->handleLogoutRequest(user, ""); } else { std::string replyMsg; while(replyMsg.length() == 0) { twitObj->getLastWebResponse(replyMsg); } std::string error = getErrorMessage(replyMsg); if(error.length()) { LOG4CXX_ERROR(logger, user << ": Error while exchanging PIN for Access Token! " << error) np->handleMessage(user, "twitter-account", error); np->handleLogoutRequest(user, ""); return; } std::string OAuthAccessTokenKey, OAuthAccessTokenSecret; twitObj->getOAuth().getOAuthTokenKey( OAuthAccessTokenKey ); twitObj->getOAuth().getOAuthTokenSecret( OAuthAccessTokenSecret ); if(np->storeUserOAuthKeyAndSecret(user, OAuthAccessTokenKey, OAuthAccessTokenSecret) == false) { np->handleLogoutRequest(user, ""); return; } np->pinExchangeComplete(user, OAuthAccessTokenKey, OAuthAccessTokenSecret); LOG4CXX_INFO(logger, user << ": Sent PIN " << data << " and obtained Access Token"); } }
//----------------------------------------------- bool CanESD::transmitMsg(CanMsg &CMsg) { CMSG NTCANMsg; NTCANMsg.id = CMsg.m_iID; NTCANMsg.len = CMsg.m_iLen; for(int i=0; i<8; i++) NTCANMsg.data[i] = CMsg.getAt(i); NTCAN_RESULT ret; int32_t len; bool bRet = true; len = 1; //ret = canWrite(m_Handle, canmsg, &len, NULL); ret = canSend(m_Handle, &NTCANMsg, &len); if( ret != NTCAN_SUCCESS) { LOGERROR("canSend() failed: " << getErrorMessage(ret)); bRet = false; } m_LastID = (int)NTCANMsg.data[0]; //ret auswerten return bRet; }
Regex& Regex::compile(const std::string& pattern) { mPattern = pattern; destroy(); // TODO: So, I would like an RAII object for this. But, this object would // need to call pcre2_compile() in its constructor rather than take // ownership of a pointer (so that it has access to the error code // information on failure) and its copy constructor / assignment // operator would need to hold onto mPattern. At that point the // class is close to being this Regex class itself. static const int FLAGS = PCRE2_DOTALL; int errorCode; PCRE2_SIZE errorOffset; mPCRE = pcre2_compile(reinterpret_cast<PCRE2_SPTR>(mPattern.c_str()), mPattern.length(), FLAGS, &errorCode, &errorOffset, NULL); // Use default compile context if (mPCRE == NULL) { std::ostringstream ostr; ostr << "PCRE compilation failed at offset " << errorOffset << ": " << getErrorMessage(errorCode); throw RegexException(Ctxt(ostr.str())); } return *this; }
int LTKStrEncoding::tamilCharToUnicode(const unsigned short& shapeID, vector<unsigned short>& unicodeString) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << " Entering: LTKStrEncoding::tamilCharToUnicode()" << endl; if(shapeID < 35) { if(shapeID == 34) { unicodeString.push_back(0x0b95); unicodeString.push_back(0x0bcd); unicodeString.push_back(0x0bb7); } else { unicodeString.push_back(tamilIsoCharMap[shapeID]); } } else { LOG(LTKLogger::LTK_LOGLEVEL_ERR) <<"Error : "<< EINVALID_SHAPEID <<":"<< getErrorMessage(EINVALID_SHAPEID) <<"LTKStrEncoding::tamilCharToUnicode()" <<endl; LTKReturnError(EINVALID_SHAPEID); } LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << " Exiting: LTKStrEncoding::tamilCharToUnicode()" << endl; return SUCCESS; }
int PointFloatShapeFeatureExtractor::readConfig(const string& cfgFilePath) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Entering " << "PointFloatShapeFeatureExtractor::readConfig()" << endl; LTKConfigFileReader* configurableProperties = NULL; string tempStringVar = ""; try { configurableProperties = new LTKConfigFileReader(cfgFilePath); } catch(LTKException e) { delete configurableProperties; int eCode = e.getErrorCode(); LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << eCode << " : " << getErrorMessage(eCode) << " PointFloatShapeFeatureExtractor::readConfig" <<endl; LTKReturnError(eCode); } delete configurableProperties; LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting " << "PointFloatShapeFeatureExtractor::readConfig()" << endl; return SUCCESS; }
void Socket::commitWrite() { if(m_write_buffer.size() == 0) return; int res; do { res=send(m_socket,m_write_buffer.c_str(),m_write_buffer.size(),0); if(res==SOCKET_ERROR) { #ifdef WIN32 if(WSAGetLastError()!=WSAEWOULDBLOCK) #else if(errno!=EWOULDBLOCK) #endif { close(); throw ConnectionClosedException("Writing failed: " + getErrorMessage()); } return; } m_write_buffer.erase(0,res); } while(res); }
int Socket::readImpl(char* data,int size) { if(m_socket == int(INVALID_SOCKET)) return 0; int res=recv(m_socket,data,size,0); if(res==SOCKET_ERROR) { #ifdef WIN32 if(WSAGetLastError()!=WSAEWOULDBLOCK) #else if(errno!=EWOULDBLOCK) #endif { close(); throw ConnectionClosedException("Reading failed: " + getErrorMessage()); } return 0; } if(res==0) { close(); throw ConnectionClosedException("Connection closed gracefully."); } return res; }
int copyRTEELF(void *arg) { DiskType type; int rv; setEnableDisc(-1); if (isDVDVSupported()) { type = CDDA_DiskType(); /* Detect disk type, so loading will work. */ if (type == DiskType_DVDV) { CDVD_SetDVDV(1); } else { CDVD_SetDVDV(0); } } rv = real_copyRTEELF(arg); if (isDVDVSupported()) { /* Always stop CD/DVD when an error happened. */ CDVD_Stop(); CDVD_FlushCache(); } setEnableDisc(0); if (getErrorMessage() == NULL) { graphic_setPercentage(0, NULL); } return 0; }
bool Renderer::CreateImmediateModeVertexBuffer() { ::IDirect3DDevice9 *lpD3DDevice = static_cast<::IDirect3DDevice9 *>(this->mpD3DDevice); const ::UINT lu32Length = this->mu32ImmediateModeVBLength; const ::DWORD lu32Usage = D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY; const ::DWORD lu32FVF = 0; const ::D3DPOOL lePool = ::D3DPOOL_DEFAULT; ::IDirect3DVertexBuffer9 *lpVertexBuffer = 0; ::HRESULT lResult = lpD3DDevice->CreateVertexBuffer( lu32Length, lu32Usage, lu32FVF, lePool, &lpVertexBuffer, 0); if (FAILED(lResult)) { REPORTERROR2("CreateVertexBuffer failed, HR=0x%x '%s'", lResult, getErrorMessage(lResult)); return false; } this->mpImmediateModeVB = lpVertexBuffer; this->mu32ImmediateModeOffset = 0; return true; }
void * Renderer::BeginImmediateMode(const unsigned int lu32Size, unsigned int &lu32Offset) { ::DWORD lu32Flags = 0; unsigned int lu32CurrentOffset = this->mu32ImmediateModeOffset; const unsigned int lu32NextOffset = lu32CurrentOffset + lu32Size; if (lu32NextOffset >= this->mu32ImmediateModeVBLength) { lu32CurrentOffset = 0; lu32Flags |= D3DLOCK_DISCARD; } else { lu32Flags |= D3DLOCK_NOOVERWRITE; } ::IDirect3DVertexBuffer9 *lpVertexBuffer = static_cast<::IDirect3DVertexBuffer9 *>(this->mpImmediateModeVB); void *lpData; ::HRESULT lResult = lpVertexBuffer->Lock(lu32CurrentOffset, lu32Size, &lpData, lu32Flags); if (FAILED(lResult)) { REPORTERROR2("VertexBuffer Lock failed, HR=0x%x '%s'", lResult, getErrorMessage(lResult)); return 0; } lu32Offset = lu32CurrentOffset; this->mu32ImmediateModeOffset = lu32NextOffset; return lpData; }
/********************************************************************************** * AUTHOR : Deepu V. * DATE : 22-FEB-2005 * NAME : LTKRecognitionContext * DESCRIPTION : Initialization constructor * ARGUMENTS : * RETURNS : * NOTES : * CHANGE HISTROY * Author Date Description of change *************************************************************************************/ LTKRecognitionContext::LTKRecognitionContext(LTKWordRecognizer *wordRecPtr ) :m_wordRecPtr(wordRecPtr), m_confidThreshold(0), m_numResults(0), m_nextBestResultIndex(0) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << " Entering: LTKRecognitionContext::LTKRecognitionContext(LTKWordRecognizer*)" << endl; if(m_wordRecPtr == NULL) { LOG(LTKLogger::LTK_LOGLEVEL_ERR) <<"Error : "<< ENULL_POINTER <<":"<< getErrorMessage(ENULL_POINTER) <<" LTKRecognitionContext::LTKRecognitionContext(LTKWordRecognizer*)" <<endl; throw LTKException(ENULL_POINTER); } m_recognitionFlags.clear(); m_wordRecPtr = wordRecPtr; LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << " Exiting: LTKRecognitionContext::LTKRecognitionContext(LTKWordRecognizer*)" << endl; }
/********************************************************************************** * AUTHOR : Saravanan. R * DATE : 25-01-2007 * NAME : deletePreprocessor * DESCRIPTION : This method is used to deletes the PreProcessor instance * ARGUMENTS : ptrPreprocInstance : Holds the pointer to the LTKPreprocessorInterface * RETURNS : none * NOTES : * CHANGE HISTROY * Author Date Description *************************************************************************************/ int featurefilewriter::deletePreprocessor() { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Entering " << "featurefilewriter::deletePreprocessor()" << endl; //deleting the preprocessor instance if(m_ptrPreproc != NULL) { m_deleteLTKLipiPreProcessor(m_ptrPreproc); m_ptrPreproc = NULL; } //Unload the dll int returnStatus = unloadPreprocessorDLL(); if(returnStatus != SUCCESS) { LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Error: " << getErrorMessage(returnStatus) << " featurefilewriter::deletePreprocessor()" << endl; LTKReturnError(returnStatus); } LOG(LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting " << "featurefilewriter::deletePreprocessor()" << endl; return SUCCESS; }
void CEstEIDIEPluginBHO::setError(unsigned int code) { EstEID_log(""); this->errorCode = code; this->errorMessage.assign(getErrorMessage(code)); EstEID_log("Set error: %s (HEX %Xh, DEC %u)", this->errorMessage.c_str(), code, code); }
v8::Local<v8::Value> ErrorMessage::getErrorMessage(const int errorCode, const name_map_t &errorcodeMapper, const std::string &customMessage) { return getErrorMessage(errorCode, errorcodeMapper, customMessage, std::string(), static_cast<nrfjprogdll_err_t>(0)); }
bool MainWindow::tryToOpenPIP (const File& pipFile) { PIPGenerator generator (pipFile); if (! generator.hasValidPIP()) return false; auto generatorResult = generator.createJucerFile(); if (generatorResult != Result::ok()) { AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "PIP Error.", generatorResult.getErrorMessage()); return false; } if (! generator.createMainCpp()) { AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "PIP Error.", "Failed to create Main.cpp."); return false; } if (! ProjucerApplication::getApp().mainWindowList.openFile (generator.getJucerFile())) return false; openPIP (generator); return true; }
int16_t sendPushoverNotification(const char* apikey, const char* event, const char* desc) { int16_t result = -1; int32_t data_size; char url[128]; HTTPResponse *response = NULL; char *data = NULL; data = createMessage(apikey, event, desc, &data_size); if(data) { snprintf(url, 128, "%s%s", PUSHOVER_URL, PUSHOVER_ADD); response = sendHTTPData(url, NULL, data, data_size); if(response) { if(response->responseCode == 200) { result = 1; } else { dbg_printf(P_ERROR, "Pushover Notification failed: %s (%d)", getErrorMessage(response->responseCode), response->responseCode); result = -response->responseCode; } HTTPResponse_free(response); } am_free(data); } return result; }
void memoryError(){ //printf("memoryError\n"); exitStatus = 4; getErrorMessage(ER_MALLOC_E); yyerror(NULL); exit(exitStatus); }
void sendResponseError(const GServerEvent& event, int httpErrorCode, const std::string& errorMessage) { std::string errorMessageActual = errorMessage; if (errorMessageActual.empty()) { errorMessageActual = getErrorMessage(httpErrorCode); } getPlatform()->httpserver_sendResponse(event.getRequestID(), httpErrorCode, CONTENT_TYPE_ERROR, errorMessageActual); }
Win32Exception::Win32Exception( DWORD errorCode, const std::string& fileName, int lineNo ) : std::runtime_error( "" ) , errorCode_( errorCode ) { std::stringstream str; str << fileName << "(" << lineNo << "):" << getErrorMessage( errorCode ); errorMessage_ = str.str(); }