// **************************************************************************** unsigned long cHashedString::CalculateHash(const cString & strIdent) { if(strIdent.IsEmpty()) { return 0; } // largest prime smaller than 65536 unsigned long lBASE = 65521L; // lMAX is the largest n such that // 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 unsigned int lMAX = 5522; unsigned int s1 = 0; unsigned int s2 = 0; int i = 0; unsigned int length = strIdent.GetLength(); while(length > 0) { int k = length < lMAX ? length : lMAX; length -= k; while(--k >= 0) { s1 += (unsigned int)(tolower(strIdent[i++]) & 0XFF); s2 += s1; } s1 %= lBASE; s2 %= lBASE; } return ((s2 << 16) | s1); }
bool cTimeAndDate::SetTimeZone(cString tz, bool isUTC, bool tostdout, cString external_exec) { cTimeAndDate *now; cExec exec; if(geteuid()==0) { now=new cTimeAndDate; now->SetUTC(isUTC); now->SetTimezone(tz); ofstream fout; if(tostdout) { if(!now->ApplyTimeZone(cout)) return false; } else { if(!cExec::CopyFile("/usr/share/zoneinfo/"+tz,"/etc/localtime")) { return false; } fout.open("/etc/sysconfig/clock"); if(!now->ApplyTimeZone(fout)) { return false; } fout.close(); } delete now; } else if(external_exec!="") { if(!external_exec.Contains(tz)) external_exec+=" -timezone "+tz; if(isUTC || external_exec.Contains("isUTC")) external_exec+=" -isUTC"; if(!exec.ForkExecFG(external_exec)) { cerr<<"failed to exec: "<<external_exec<<endl; return false; } } else { cerr<<"not root, but no external_exec defined either"<<endl; return false; } return true; }
// ********** File IO **************** // bool cStringList::FromFile(const cString & fname) { if(fname.Contains('*')) return false; #ifndef WIN32 if(!FileExists(fname)) return false; struct stat buf; stat(fname,&buf); ifstream infile(fname); if(fname.Contains("/proc") || buf.st_size==0) { if(!FromFile(infile)) { infile.close(); return false; } } else { if(!FromFile(infile,buf.st_size)) { infile.close(); return false; } } infile.close(); if((*this)[-1]=="" && Length()!=0) used--; #else FILE* fptr=fopen(fname,"r"); FromFile(fptr); fclose(fptr); #endif return true; }
// Verifies that directory exists. // Returns success if the directory exists and is readable (failure may mean // it's busy or permissions denied on win32) //----------------------------------------------------------------------------- CPUTResult CPUTFileSystem::DoesDirectoryExist(const cString &path) { #ifdef CPUT_OS_ANDROID // On Android, all files are in the APK and are compressed. // We do not have access to the standard file system, so // all files need streaming from memory through the android asset manager AAssetManager* assetManager = CPUTWindowAndroid::GetAppState()->activity->assetManager; AAssetDir* AssetDir = AAssetManager_openDir(assetManager, path.c_str()); if (AssetDir) return CPUT_SUCCESS; #else struct stat fileAttributes; int result = stat(path.c_str(), &fileAttributes); if (result == -1) { DEBUG_ERROR(strerror(errno)); result = CPUT_ERROR; } if (S_ISDIR(fileAttributes.st_mode)) { return CPUT_SUCCESS; } #endif return CPUT_ERROR; }
static void AssignStr(cString &dest, const char *start, const char *end, _locale_t locale) { dest.clear(); if (end <= start) { return; } static const int NBUF = 64; wchar_t buf[NBUF]; int nb = 0; size_t len = end - start; size_t initial = len + 1; // assume most characters are 1-byte dest.reserve(initial); const char *p = start; while (p < end) { int len = _mbtowc_l(&buf[nb++], p, end - p, locale); if (len < 1) { break; } p += len; if (p >= end || nb >= NBUF) { dest.append(buf, nb); nb = 0; } } }
CPUTFileSystem::CPUTandroidifstream::CPUTandroidifstream(const cString &fileName, std::ios_base::openmode mode) : iCPUTifstream(fileName, mode) { mpAsset = NULL; mpAssetDir = NULL; mbEOF = true; // Extract the file and dir int length = fileName.length(); int index = fileName.find_last_of("\\/"); cString file = fileName.substr(index + 1, (length - 1 - index)); cString dir = fileName.substr(0, index); // On Android, all files are in the APK and are compressed. // We do not have access to the standard file system, so // all files need streaming from memory through the android asset manager AAssetManager* assetManager = CPUTWindowAndroid::GetAppState()->activity->assetManager; mpAssetDir = AAssetManager_openDir(assetManager, dir.c_str()); if (!mpAssetDir) DEBUG_PRINT("Failed to load asset Dir"); const char* assetFileName = NULL; while ((assetFileName = AAssetDir_getNextFileName(mpAssetDir)) != NULL) { if (strcmp(file.c_str(), assetFileName) == 0) { // For some reason we need to pass in the fully pathed filename here, rather than the relative filename // that we have just been given. This feels like a bug in Android! mpAsset = AAssetManager_open(assetManager, fileName.c_str()/*assetFileName*/, AASSET_MODE_STREAMING); if (mpAsset) mbEOF = false; return; } } }
void FileList_R(cStringList &mylist, cString fullpath, bool usedirs) { cStringList split; // cerr<<"fullpath="<<fullpath<<endl; if(fullpath.Contains('*')) split.FromString(fullpath,"*."); else split.FromString(fullpath,"."); FileList_R(mylist,fullpath.ChopRt('/'),fullpath.ChopAllLf('/'),usedirs); }
void FileList_1(cStringList &mylist, cString fullpath, bool usedirs) { cStringList split; if(fullpath.Contains('*')) split.FromString(fullpath,"*."); else split.FromString(fullpath,"."); FileList_1(mylist,fullpath.ChopRt('/'),fullpath.ChopAllLf('/'),usedirs); }
cString cString::pad(const cString& object, uint number, character padding) { if (object.length() >= number) return object; return object + dup(" ", number - object.length()); }
CPUTKey MapKey(cString strKey) { for(int i = 0; i < KEY_NUM_KEYS; i++) { if( 0 == strKey.compare(CPUTKeyMap[i].name)) return CPUTKeyMap[i].value; } DEBUG_PRINT(_L("Unknown Key: %s"), strKey.c_str()); return KEY_NUM_KEYS; }
//Converts a string day into it's number int cTimeAndDate::Day2Number(cString day,int st) { day=day.ToUpper(); if(day.Contains("SUN")) return ((0-st)+7)%7; if(day.Contains("MON")) return ((1-st)+7)%7; if(day.Contains("TUE")) return ((2-st)+7)%7; if(day.Contains("WED")) return ((3-st)+7)%7; if(day.Contains("THU")) return ((4-st)+7)%7; if(day.Contains("FRI")) return ((5-st)+7)%7; if(day.Contains("SAT")) return ((6-st)+7)%7; return -1; }
// // This function parses configuration options from a text string. Removes any previous // options stored in the configuration list. // void CommandParser::ParseConfigurationOptions(cString arguments, cString delimiter) { CleanConfigurationOptions(); std::vector<cString> argumentList; size_t pos; size_t nextPos = arguments.find_first_of(delimiter, 0); // // Break out parameters from command line // while (nextPos != std::string::npos) { pos = nextPos + 1; nextPos = arguments.find_first_of(delimiter, pos); argumentList.push_back(arguments.substr(pos, nextPos - pos)); } // // Remove leading spaces from arguments. // for (std::vector<cString>::iterator it = argumentList.begin(); it != argumentList.end(); it++) { std::string::size_type pos = it->find_first_not_of(' '); if (pos != std::string::npos) { it->erase(0, pos); } } // // Remove trailing spaces from arguments // for (std::vector<cString>::iterator it = argumentList.begin(); it != argumentList.end(); it++) { std::string::size_type pos = it->find_last_not_of(' '); if (pos != std::string::npos) { it->erase(pos + 1); } } // // Split the values from the parameter name // cString arg; for (std::vector<cString>::iterator it = argumentList.begin(); it != argumentList.end(); it++) { arg = *it; pos = arg.find_first_of(_L(":"), 0); if (pos != cString::npos) { m_ArgumentMap.insert(std::make_pair(arg.substr(0, pos), arg.substr(pos + 1, std::string::npos))); } else { m_ArgumentMap.insert(std::make_pair(arg.substr(0, pos), _L(""))); } } return; }
uint cString::rfind(const cString& string, uint startIndex) const { uint i = startIndex; uint ln = length(); uint on = string.length(); // Incase of empty string. Always match if (on == 0) { return startIndex; } // If the current string is empty, search failed. if (ln == 0) return 0; // If this string doesn't have at least the number of characters 'string' // has, the search will probably failed. Returns the length of this string. if (ln < on) return ln; // Set the postion to the end of the string if (i >= ln - on) i = ln - on; bool shouldExit = false; do { /* Try to find a match */ if (m_buffer->getBuffer()[i] == string.m_buffer->getBuffer()[0]) { /* Scan the reset of the string */ uint j; for (j = i + 1; ((j < ln) && (j < i + on) && (string.m_buffer->getBuffer()[j - i] == m_buffer->getBuffer()[j])); j++) { /* Match is ok */ } if (j == i + string.length()) return i; } // Since i is uint... if (i == 0) shouldExit = true; else i--; } while (!shouldExit); return ln; }
/*int cStringList::FromMem(struct memfile &f) { int len; int bytes=0; bytes+=memread(f,&len,sizeof(int)); cString temp=""; char * tempchar=NULL; for(int i=0; i<len; i++) { tempchar=(char*)f.start; tempchar+=f.offset; temp=tempchar; bytes+=temp.Length()+1; f.offset+=temp.Length()+1; (*this)+=temp; temp=""; } if((*this)[-1]=="" && Length()!=0) used--; return bytes; } */ void cStringList::FromString(const cString &strng, cString delim) { if(delim.Length()==1) return FromString(strng,delim[0]); delete [] Array; Array=NULL; allocated=0; used=0; Resize(500); cString substrng=delim; cString temp; used=1; for(int i=0; i<strng.Length(); ) FromString_innerloop(strng,delim,substrng, i); }
void cStringList::FromString_innerloop(const cString & strng, cString delim, cString &substrng, int & i) { int s=strng.Length(); for(int j=0; j<delim.Length() && i+j<strng.Length(); j++) substrng[j]=strng[i+j]; if(substrng!=delim && i<s) { if(used+1>allocated) { Resize(allocated+500); } Array[used-1]+=strng[i]; i++; } else { used++; i+=substrng.Length(); } }
tVoid DriverFilter::getManeuverFromString(const cString &name, Maneuver &maneuver) { if (name.Compare("left") == 0) { maneuver = MANEUVER_LEFT; } else if (name.Compare("right") == 0) { maneuver = MANEUVER_RIGHT; } else if (name.Compare("straight") == 0) { maneuver = MANEUVER_STRAIGHT; } else if (name.Compare("parallel_parking") == 0) { maneuver = MANEUVER_PARALLEL_PARKING; } else if (name.Compare("cross_parking") == 0) { maneuver = MANEUVER_CROSS_PARKING; } else if (name.Compare("pull_out_right") == 0) { maneuver = MANEUVER_PULL_OUT_RIGHT; } else if (name.Compare("pull_out_left") == 0) { maneuver = MANEUVER_PULL_OUT_LEFT; } else { LOG_INFO(cString::Format("Unbekannter Befehl: %s", name.GetPtr())); } }
bool cFile::isFileExist(const cString& filename) { WIN32_FIND_DATA findData; HANDLE hFind = FindFirstFile(OS_CSTRING(filename.getBuffer()), &findData); if (hFind == INVALID_HANDLE_VALUE) return false; FindClose(hFind); // If filename contains * or ? character this prevent any problems. if ((filename.find("*") == filename.length()) && (filename.find("?") == filename.length())) return true; return false; }
void CPUTGUIElement::SetText(cString string) { DEBUG_PRINT(_L("GUIElement SetText: %s"), string.c_str()); mText = string; if(mpFont && mpTextMaterial) { DEBUG_PRINT(_L("\t have font and material")); if(!mpTextMesh) { #ifdef CPUT_FOR_DX11 mpTextMesh = new CPUTMeshDX11(); #else mpTextMesh = new CPUTMeshOGL(); #endif } unsigned int numCharacters = (unsigned int) string.size(); unsigned int numVertices = numCharacters * 6; CPUTGUIVertex* pVB = new CPUTGUIVertex[numVertices]; CPUTBufferElementInfo pGUIVertex[3] = { { "POSITION", 0, 0, CPUT_F32, 3, 3*sizeof(float), 0 }, { "TEXCOORD", 0, 1, CPUT_F32, 2, 2*sizeof(float), 3*sizeof(float)}, { "COLOR", 0, 2, CPUT_F32, 4, 4*sizeof(float), 5*sizeof(float)}, }; mpFont->LayoutText(NULL, &mTextWidth, &mTextHeight, mText, 0, 0); mTextX = (mWidth-mTextWidth)/2; mTextY = (mHeight-mTextHeight)/2; mpFont->LayoutText(pVB, &mTextWidth, &mTextHeight, mText, 0, 0); mpTextMesh->CreateNativeResources(NULL, 1, 3, pGUIVertex, numVertices, pVB, NULL, 0, NULL); #ifdef CPUT_FOR_DX11 mpTextMesh->SetMeshTopology(CPUT_TOPOLOGY_INDEXED_TRIANGLE_LIST); D3D11_INPUT_ELEMENT_DESC layout[] = { { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 }, { "COLOR", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 20, D3D11_INPUT_PER_VERTEX_DATA, 0 }, }; UINT numElements = ARRAYSIZE( layout ); ID3DBlob* pBlob = ((CPUTMaterialEffectDX11*)mpTextMaterial->GetMaterialEffects()[0])->GetVertexShader()->GetBlob(); CPUT_DX11::GetDevice()->CreateInputLayout( layout, numElements, pBlob->GetBufferPointer(), pBlob->GetBufferSize(), &mpVertexLayout ); CPUTSetDebugName( mpVertexLayout, "CPUT GUI InputLayout object"); #else #endif SAFE_DELETE_ARRAY(pVB); } }
// Read the entire contents of a file and return a pointer/size to it //----------------------------------------------------------------------------- CPUTResult CPUTFileSystem::ReadFileContents(const cString &fileName, UINT *pSizeInBytes, void **ppData, bool bAddTerminator, bool bLoadAsBinary) { FILE *pFile = NULL; errno_t err; if (bLoadAsBinary) { #if defined (UNICODE) || defined(_UNICODE) err = _wfopen_s(&pFile, fileName.c_str(), _L("rb")); #else err = fopen_s(&pFile, fileName.c_str(), "rb"); #endif } else { #if defined (UNICODE) || defined(_UNICODE) err = _wfopen_s(&pFile, fileName.c_str(), _L("r")); #else err = fopen_s(&pFile, fileName.c_str(), "r"); #endif } if(0 == err) { // get file size fseek(pFile, 0, SEEK_END); *pSizeInBytes = ftell(pFile); fseek (pFile, 0, SEEK_SET); // allocate buffer *ppData = (void*) new char[*pSizeInBytes]; ASSERT( *ppData, _L("Out of memory") ); // read it all in UINT numBytesRead = (UINT) fread(*ppData, sizeof(char), *pSizeInBytes, pFile); if (bAddTerminator) { ((char *)(*ppData))[numBytesRead++] = '\0'; (*pSizeInBytes)++; } //fixme - this isn't doing what it appears to be doing. counts off for Windows... //ASSERT( numBytesRead == *pSizeInBytes, _L("File read byte count mismatch.") ); UNREFERENCED_PARAMETER(numBytesRead); // close and return fclose(pFile); return CPUT_SUCCESS; } // some kind of file error, translate the error code and return it return TranslateFileError(err); }
//----------------------------------------------------------------------------- void CPUTSetDebugName( void *pResource, cString name ) { #ifdef _DEBUG char pCharString[CPUT_MAX_STRING_LENGTH]; const wchar_t *pWideString = name.c_str(); UINT ii; UINT length = min( (UINT)name.length(), (CPUT_MAX_STRING_LENGTH-1)); for(ii=0; ii<length; ii++) { pCharString[ii] = (char)pWideString[ii]; } pCharString[ii] = 0; // Force NULL termination ((ID3D11DeviceChild*)pResource)->SetPrivateData( WKPDID_D3DDebugObjectName, (UINT)name.length(), pCharString ); #endif // _DEBUG }
int GetEventValue(StringMap eventMap[], cString event) { int i = 0; while(eventMap[i].value > 0) { if(event.compare(eventMap[i].key) == 0) { DEBUG_PRINT(_L("Found Event: %s\n"), event.c_str()); return eventMap[i].value; } i++; } return -1; }
// ******************************************************************************************************************* const weak_ptr<IXMLNode> cXMLNode::VAddElement(const cString & ElementName, const cString & ElementValue) { const shared_ptr<cXMLNode> pNode(DEBUG_NEW cXMLNode()); pNode->m_pElement = m_pDoc->NewElement(ElementName.GetData()); pNode->m_pDoc = m_pDoc; if (!ElementValue.IsEmpty()) { XMLText * pText = m_pDoc->NewText(ElementValue.GetData()); pNode->m_pElement->InsertEndChild(pText); } m_pElement->LinkEndChild(pNode->m_pElement); m_ChildNodes.push_back(pNode); return pNode; }
// Retrieve specified pixel shader //----------------------------------------------------------------------------- CPUTResult CPUTAssetLibraryDX11::GetPixelShader( const cString &name, ID3D11Device *pD3dDevice, const cString &shaderMain, const cString &shaderProfile, CPUTPixelShaderDX11 **ppPixelShader, bool nameIsFullPathAndFilename ) { CPUTResult result = CPUT_SUCCESS; cString finalName; if( name.at(0) == '$' ) { finalName = name; } else { // Resolve name to absolute path CPUTOSServices *pServices = CPUTOSServices::GetOSServices(); pServices->ResolveAbsolutePathAndFilename( nameIsFullPathAndFilename? name : (mShaderDirectoryName + name), &finalName); } // see if the shader is already in the library void *pShader = FindPixelShader(finalName + shaderMain + shaderProfile, true); if(NULL!=pShader) { *ppPixelShader = (CPUTPixelShaderDX11*) pShader; (*ppPixelShader)->AddRef(); return result; } *ppPixelShader = CPUTPixelShaderDX11::CreatePixelShader( finalName, pD3dDevice, shaderMain, shaderProfile ); return result; }
void cSockAddrIn::getAllHostsName(const cString& name, cList<cSockAddrIn>& lists, WORD port /* = 0 */) { socketInitSingleton::GetHandle().init(); cSockAddrIn ret; // The new constructor INET addressed ret.sin_family = AF_INET; ret.sin_port = htons(port); lists.removeAll(); // Lock the mutex cLock lock(g_getHostByNameLock); /* Invoke the 'gethostname' function call */ /* Recieve a list of all address */ cSArray<char> asciiName = name.getASCIIstring(); hostent * addr = gethostbyname(asciiName.getBuffer()); for (unsigned int i = 0; ((DWORD *)addr->h_addr_list[i] != NULL) ; i++) { /* Get the address */ #ifndef XSTL_LINUX ret.sin_addr.S_un.S_addr = *((DWORD *)(addr->h_addr_list[i])); // Return the first address #else ret.sin_addr.s_addr = *((DWORD *)(addr->h_addr_list[i])); // Return the first address #endif /* Fill with new valid address */ lists.append(ret); } }
//----------------------------------------------------------------------------- void CPUTAssetLibrary::AddAsset(const cString &name, void *pAsset, CPUTAssetListEntry **pHead) { // convert string to lowercase cString lowercaseName = name; std::transform(lowercaseName.begin(), lowercaseName.end(), lowercaseName.begin(), ::tolower); // Do we already have one by this name? CPUTAssetListEntry *pTail = *pHead; // TODO: Save explicit tail pointer instead of iterating to find the null. for( CPUTAssetListEntry *pCur=*pHead; NULL!=pCur; pCur=pCur->pNext ) { // Assert that we haven't added one with this name ASSERT( 0 != _wcsicmp( pCur->name.data(), name.data() ), _L("Warning: asset ")+name+_L(" already exists") ); pTail = pCur; } CPUTAssetListEntry **pDest = pTail ? &pTail->pNext : pHead; *pDest = new CPUTAssetListEntry(); (*pDest)->hash = CPUTComputeHash(name); (*pDest)->name = name; (*pDest)->pData = pAsset; (*pDest)->pNext = NULL; // TODO: Our assets are not yet all derived from CPUTRenderNode. // TODO: For now, rely on caller performing the AddRef() as it knows the assets type. ((CPUTRefCount*)pAsset)->AddRef(); }
void cException::whereExceptionOccured(cString& ret) { // XXX: NOT PORTABLE! ret = m_atFile; ret.concat(":"); ret+= cString(m_atLine, 10, 10); }
//----------------------------------------------------------------------------- CPUTResult CPUTTextureDX11::CreateNativeTexture( ID3D11Device *pD3dDevice, const cString &fileName, ID3D11ShaderResourceView **ppShaderResourceView, ID3D11Resource **ppTexture, bool ForceLoadAsSRGB) { HRESULT hr; hr = DirectX::CreateDDSTextureFromFileEx( pD3dDevice, fileName.c_str(), 0,//maxsize D3D11_USAGE_DEFAULT, D3D11_BIND_SHADER_RESOURCE, 0, 0, ForceLoadAsSRGB, ppTexture, ppShaderResourceView); if( FAILED( hr ) ) { ASSERT( false, _L("Failed to load texture: ") + fileName ) return CPUT_TEXTURE_LOAD_ERROR; } CPUTSetDebugName( *ppTexture, fileName ); CPUTSetDebugName( *ppShaderResourceView, fileName ); return CPUT_SUCCESS; }
cSockAddrIn cSockAddrIn::getHostByName(const cString& name, WORD port /* = 0 */) { socketInitSingleton::GetHandle().init(); cSockAddrIn ret; ret.sin_family = AF_INET; ret.sin_port = htons(port); // Lock the mutex cLock lock(g_getHostByNameLock); // Query the address. cSArray<char> asciiName = name.getASCIIstring(); hostent* addr = gethostbyname(asciiName.getBuffer()); // Return the first address of the hostent struct. #if defined(XSTL_WINDOWS) || defined (XSTL_CE) // Windows ordering. ret.sin_addr.S_un.S_addr = *((DWORD *)(addr->h_addr_list[0])); #else #ifdef XSTL_LINUX // Linux version ret.sin_addr.s_addr = *((DWORD *)(addr->h_addr_list[0])); #else #error "Add platform functionalty here!"; #endif #endif return ret; }
// ******************************************************************************************************************* void cString::Insert(const int index, const cString & text) { if (index >= 0 && index <= GetLength()) { m_str.insert(index, text.GetData()); } }
cRoadSigns::cRoadSigns(cString filename,RoadSign enumGiven , tInt minHessian, tInt shapeIdentifier) : m_detector(minHessian,20) //setting parameters of detector minHessian and nOctaves { //m_image = imread(filename, CV_LOAD_IMAGE_GRAYSCALE ); m_enumSign = enumGiven; m_shapeIdentifier = shapeIdentifier; if (std::ifstream(filename.GetPtr())) { m_image = imread(filename.GetPtr(), CV_LOAD_IMAGE_COLOR); //blur(m_image,m_image,cvSize(9,9)); m_minHessian = minHessian; #if defined(WIN32) //setting parameters of detector m_detector.set("hessianThreshold",minHessian); m_detector.set("nOctaves",20); #endif m_detector.detect( m_image, m_keypoints ); if (m_keypoints.size() == 0) { m_state=tFalse; return; } //remove keypoints which are near to border tInt borderSize = m_image.cols/4; m_keypoints.erase( remove_if(m_keypoints.begin(), m_keypoints.end(), RoiPredicatePic((tFloat32)borderSize, (tFloat32)borderSize, (tFloat32)(m_image.cols - borderSize), (tFloat32)(m_image.rows - borderSize))), m_keypoints.end() ); m_extractor.compute( m_image, m_keypoints, m_descriptors ); if (m_descriptors.total() == 0) { m_state=tFalse; return; } //drawKeypoints( m_image, m_keypoints, m_image, Scalar::all(-1), DrawMatchesFlags::DEFAULT ); m_state = tTrue; } else m_state=tFalse; }