/*
* LoadRsc: Loads the RESOURCE_RSC_SPEC files (.rsc or .rsb).
*/
void LoadRsc(void)
{
char file_load_path[MAX_PATH+FILENAME_MAX];
char *filespec = ConfigStr(RESOURCE_RSC_SPEC);
char *filepath = ConfigStr(PATH_RSC);
int files_loaded = 0;
sprintf(file_load_path, "%s%s", filepath, filespec);
StringVector files;
if (FindMatchingFiles(file_load_path, &files))
{
for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
{
sprintf(file_load_path, "%s%s", filepath, it->c_str());
if (RscFileLoad(file_load_path, EachLoadRsc))
{
if (stricmp(filespec, "*.rsb") == 0)
LoadRSBHash(file_load_path);
files_loaded++;
}
else
eprintf("LoadRsc error loading %s\n", it->c_str());
}
}
dprintf("LoadRsc loaded %i of %i found %s files\n",
files_loaded, files.size(), filespec);
}
EStatusCode Type1ToCFFEmbeddedFontWriter::WriteStringIndex()
{
mPrimitivesWriter.WriteCard16((unsigned short)mStrings.size());
if(mStrings.size() > 0)
{
// calculate the total data size to determine the required offset size
unsigned long totalSize=0;
StringVector::iterator it = mStrings.begin();
for(; it != mStrings.end(); ++it)
totalSize += (unsigned long)it->size();
Byte sizeOfOffset = GetMostCompressedOffsetSize(totalSize + 1);
mPrimitivesWriter.WriteOffSize(sizeOfOffset);
mPrimitivesWriter.SetOffSize(sizeOfOffset);
unsigned long currentOffset = 1;
// write the offsets
for(it = mStrings.begin(); it != mStrings.end(); ++it)
{
mPrimitivesWriter.WriteOffset(currentOffset);
currentOffset += (unsigned long)it->size();
}
mPrimitivesWriter.WriteOffset(currentOffset);
// write the data
for(it = mStrings.begin(); it != mStrings.end(); ++it)
mFontFileStream.Write((const Byte*)(it->c_str()),it->size());
}
return mPrimitivesWriter.GetInternalState();
}
QStringList FaerieAnimationsDelegate::GetAnimationsList() {
StringVector names = _collection->GetAnimationsNames();
QStringList animationsList;
for (StringVector::iterator i = names.begin(); i != names.end(); ++i) {
animationsList.push_back(tr(i->c_str()));
}
return animationsList;
}
VmbErrorType EnumFeature::GetValues( const char **pRange, VmbUint32_t &rnSize )
{
if ( NULL == m_pFeatureContainer )
{
return VmbErrorDeviceNotOpen;
}
VmbUint32_t nCount = 0;
VmbError_t res = VmbFeatureEnumRangeQuery( m_pFeatureContainer->GetHandle(), m_featureInfo.name.c_str(), NULL, 0, &nCount );
if ( VmbErrorSuccess == res
&& 0 < nCount )
{
std::vector<const char*> data( nCount );
res = VmbFeatureEnumRangeQuery( m_pFeatureContainer->GetHandle(), m_featureInfo.name.c_str(), &data[0], nCount, &nCount );
if ( VmbErrorSuccess == res )
{
m_EnumStringValues.clear();
for ( std::vector<const char*>::iterator iter = data.begin();
data.end() != iter;
++iter )
{
m_EnumStringValues.push_back( std::string( *iter ));
}
if ( NULL == pRange )
{
rnSize = (VmbUint32_t)m_EnumStringValues.size();
res = VmbErrorSuccess;
}
else if ( m_EnumStringValues.size() <= rnSize )
{
VmbUint32_t i = 0;
for ( StringVector::iterator iter = m_EnumStringValues.begin();
m_EnumStringValues.end() != iter;
++iter, ++i )
{
pRange[i] = iter->c_str();
}
rnSize = (VmbUint32_t)m_EnumStringValues.size();
res = VmbErrorSuccess;
}
else
{
res = VmbErrorMoreData;
}
}
}
return (VmbErrorType)res;
}
//FindFiles
Int DirectoryArchiveHandler::FindFiles( const String& archiveLocation, StringVector* files, bool recurse )
{
// Find the files:
Int count = searchDirectory( archiveLocation, files, recurse );
// Go through the files and remove the directory from the name
StringVector::iterator fileIter = files->begin();
Int length = archiveLocation.length() + 1;
for ( fileIter; fileIter != files->end(); fileIter++ )
{
fileIter->erase( 0, length );
}
return count;
}
//bool stringCompare( const string &left, const string &right )
//{
// for( string::const_iterator lit = left.begin(), rit = right.begin(); lit != left.end() && rit != right.end(); ++lit, ++rit )
// if( tolower( *lit ) < tolower( *rit ) )
// return true;
// else if( tolower( *lit ) > tolower( *rit ) )
// return false;
// if( left.size() < right.size() )
// return true;
// return false;
//}
StringVector CDirectoryManagerBase::GetDirectoriesFromString(const std::string& directoryListString)
{
StringVector tmp1 = Tokenize(directoryListString, "|");
StringVector tmp2;
for (StringVector::iterator it = tmp1.begin(); it != tmp1.end(); it++)
{
Trim(*it);
if (!it->empty())
{
if (!IsPathEndOk(*it))
*it += '\\';
*it = SimplifyFilePath(*it);
if (tmp2.Find(*it, false) == UNKNOWN_POS)
tmp2.push_back(*it);
}
}
return tmp2;
}
bool parseIntegerVec(std::string str, IntegerVec& intVector)
{
StringVector strVector = explodeString(str, ";");
IntegerVec tmpIntVector;
for(StringVector::iterator it = strVector.begin(); it != strVector.end(); ++it)
{
tmpIntVector = vectorAtoi(explodeString((*it), "-"));
if(!tmpIntVector[0] && it->substr(0, 1) != "0")
continue;
intVector.push_back(tmpIntVector[0]);
if(tmpIntVector.size() > 1)
{
while(tmpIntVector[0] < tmpIntVector[1])
intVector.push_back(++tmpIntVector[0]);
}
}
return true;
}
void NotesHelper::CreateNotesMessage(const std::tstring& recipients, const std::tstring& subject, StringVector& body, LNMailMessage &message)
{
LNSTATUS status = Session::Instance()->GetNotesSession().CreateMailMessage(&message);
if(NOERROR != status)
{
std::vector<char> errorbuffer(LNERROR_MESSAGE_LENGTH);
LNINT charCount = LNGetErrorMessage(status, &errorbuffer[0]);
throw CppUnitException(std::tstring(errorbuffer.begin(), errorbuffer.begin() + charCount), __LINE__, _T(__FILE__));
}
message.SendTo(Workshare::Conversions::W22LNString(recipients.c_str()));
message.SetSubject(Workshare::Conversions::W22LNString(subject.c_str()));
LNRichText rtBody;
message.GetBody(&rtBody);
for(StringVector::iterator bodyIter = body.begin(); bodyIter != body.end(); ++bodyIter)
{
rtBody.Append(Workshare::Conversions::W22LNString(bodyIter->c_str()));
}
}
int main ( )
{
PME regex ( ", " );
int i = regex.split ( "very, very2, tired" );
for ( int j = 0; j < i; j++ ) {
printf ( "%s\n", regex [ j ].c_str ( ) );
}
StringVector sv = regex.GetStringVector ( );
for ( StringVector::iterator i = sv.begin ( );
i != sv.end ( );
i++ ) {
printf ( "%s\n", i->c_str ( ) );
}
PME match ( "([a-z])([0-9])([A-Z])" );
match.match ( "b2Z" );
sv = match.GetStringVector ( );
for ( StringVector::iterator i = sv.begin ( );
i != sv.end ( );
i++ ) {
printf ( "%s\n", i->c_str ( ) );
}
}
void LoadRsc(void)
{
char file_load_path[MAX_PATH+FILENAME_MAX];
int files_loaded = 0;
StringVector files;
if (FindMatchingFiles(ConfigStr(PATH_RSC), RSC_EXTENSION, &files))
{
for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
{
sprintf(file_load_path,"%s%s",ConfigStr(PATH_RSC), it->c_str());
if (RscFileLoad(file_load_path,EachLoadRsc))
files_loaded++;
else
eprintf("LoadRsc error loading %s\n", it->c_str());
}
}
/*
dprintf("LoadRsc loaded %i of %i found .rsc files\n",files_loaded,files.size());
*/
}
void LoadBof(void)
{
char file_load_path[MAX_PATH+FILENAME_MAX];
char file_copy_path[MAX_PATH+FILENAME_MAX];
int files_loaded = 0;
sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF),BOF_SPEC);
StringVector files;
if (FindMatchingFiles(file_load_path, &files))
{
for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
{
sprintf(file_load_path,"%s%s",ConfigStr(PATH_BOF), it->c_str());
sprintf(file_copy_path,"%s%s",ConfigStr(PATH_MEMMAP), it->c_str());
if (BlakMoveFile(file_load_path,file_copy_path))
files_loaded++;
}
}
/*
if (!files.empty())
dprintf("LoadBof moved in %i of %i found new .bof files\n",files_loaded,files.size());
*/
//dprintf("starting to load bof files\n");
files_loaded = 0;
sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP),BOF_SPEC);
if (FindMatchingFiles(file_load_path, &files))
{
for (StringVector::iterator it = files.begin(); it != files.end(); ++it)
{
sprintf(file_load_path,"%s%s",ConfigStr(PATH_MEMMAP), it->c_str());
if (LoadBofName(file_load_path))
files_loaded++;
else
eprintf("LoadAllBofs can't load %s\n", it->c_str());
}
}
SetClassesSuperPtr();
SetClassVariables();
SetMessagesPropagate();
dprintf("LoadBof loaded %i of %i found .bof files\n",files_loaded,files.size());
}
//---------------------------------------------------------------------
void GLSLProgramManagerCommon::parseIndividualConstant(const String& src, GpuNamedConstants& defs,
String::size_type currPos,
const String& filename, GpuSharedParametersPtr sharedParams)
{
GpuConstantDefinition def;
String paramName = "";
String::size_type endPos = src.find(";", currPos);
String line = src.substr(currPos, endPos - currPos);
// Remove spaces before opening square braces, otherwise
// the following split() can split the line at inappropriate
// places (e.g. "vec3 something [3]" won't work).
for (String::size_type sqp = line.find (" ["); sqp != String::npos;
sqp = line.find (" ["))
line.erase (sqp, 1);
// Split into tokens
StringVector parts = StringUtil::split(line, ", \t\r\n");
for (StringVector::iterator i = parts.begin(); i != parts.end(); ++i)
{
// Is this a type?
StringToEnumMap::iterator typei = mTypeEnumMap.find(*i);
if (typei != mTypeEnumMap.end())
{
completeDefInfo(typei->second, def);
}
else
{
// if this is not a type, and not empty, it should be a name
StringUtil::trim(*i);
if (i->empty()) continue;
// Skip over precision keywords
if(StringUtil::match((*i), "lowp") ||
StringUtil::match((*i), "mediump") ||
StringUtil::match((*i), "highp"))
continue;
String::size_type arrayStart = i->find("[", 0);
if (arrayStart != String::npos)
{
// potential name (if butted up to array)
String name = i->substr(0, arrayStart);
StringUtil::trim(name);
if (!name.empty())
paramName = name;
String::size_type arrayEnd = i->find("]", arrayStart);
String arrayDimTerm = i->substr(arrayStart + 1, arrayEnd - arrayStart - 1);
StringUtil::trim(arrayDimTerm);
// the array term might be a simple number or it might be
// an expression (e.g. 24*3) or refer to a constant expression
// we'd have to evaluate the expression which could get nasty
// TODO
def.arraySize = StringConverter::parseInt(arrayDimTerm);
}
else
{
paramName = *i;
def.arraySize = 1;
}
// Name should be after the type, so complete def and add
// We do this now so that comma-separated params will do
// this part once for each name mentioned
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage("Problem parsing the following GLSL Uniform: '"
+ line + "' in file " + filename);
// next uniform
break;
}
// Special handling for shared parameters
if(sharedParams.isNull())
{
// Complete def and add
// increment physical buffer location
def.logicalIndex = 0; // not valid in GLSL
if (def.isFloat())
{
def.physicalIndex = defs.floatBufferSize;
defs.floatBufferSize += def.arraySize * def.elementSize;
}
else
{
def.physicalIndex = defs.intBufferSize;
defs.intBufferSize += def.arraySize * def.elementSize;
}
defs.map.insert(GpuConstantDefinitionMap::value_type(paramName, def));
// Generate array accessors
defs.generateConstantDefinitionArrayEntries(paramName, def);
}
else
{
try
{
const GpuConstantDefinition &sharedDef = sharedParams->getConstantDefinition(paramName);
(void)sharedDef; // Silence warning
}
catch (Exception& e)
{
// This constant doesn't exist so we'll create a new one
sharedParams->addConstantDefinition(paramName, def.constType);
}
}
}
}
}
//---------------------------------------------------------------------
void GLSLESProgramManagerCommon::extractConstantDefs(const String& src,
GpuNamedConstants& defs, const String& filename)
{
// Parse the output string and collect all uniforms
// NOTE this relies on the source already having been preprocessed
// which is done in GLSLESProgram::loadFromSource
String line;
String::size_type currPos = src.find("uniform");
while (currPos != String::npos)
{
GpuConstantDefinition def;
String paramName;
// Now check for using the word 'uniform' in a larger string & ignore
bool inLargerString = false;
if (currPos != 0)
{
char prev = src.at(currPos - 1);
if (prev != ' ' && prev != '\t' && prev != '\r' && prev != '\n'
&& prev != ';')
inLargerString = true;
}
if (!inLargerString && currPos + 7 < src.size())
{
char next = src.at(currPos + 7);
if (next != ' ' && next != '\t' && next != '\r' && next != '\n')
inLargerString = true;
}
// skip 'uniform'
currPos += 7;
if (!inLargerString)
{
// find terminating semicolon
String::size_type endPos = src.find(";", currPos);
if (endPos == String::npos)
{
// problem, missing semicolon, abort
break;
}
line = src.substr(currPos, endPos - currPos);
// Remove spaces before opening square braces, otherwise
// the following split() can split the line at inappropriate
// places (e.g. "vec3 something [3]" won't work).
for (String::size_type sqp = line.find (" ["); sqp != String::npos;
sqp = line.find (" ["))
line.erase (sqp, 1);
// Split into tokens
StringVector parts = StringUtil::split(line, ", \t\r\n");
for (StringVector::iterator i = parts.begin(); i != parts.end(); ++i)
{
// Is this a type?
StringToEnumMap::iterator typei = mTypeEnumMap.find(*i);
if (typei != mTypeEnumMap.end())
{
completeDefInfo(typei->second, def);
}
else
{
// if this is not a type, and not empty, it should be a name
StringUtil::trim(*i);
if (i->empty()) continue;
// Skip over precision keywords
if(StringUtil::match((*i), "lowp") ||
StringUtil::match((*i), "mediump") ||
StringUtil::match((*i), "highp"))
continue;
String::size_type arrayStart = i->find("[", 0);
if (arrayStart != String::npos)
{
// potential name (if butted up to array)
String name = i->substr(0, arrayStart);
StringUtil::trim(name);
if (!name.empty())
paramName = name;
String::size_type arrayEnd = i->find("]", arrayStart);
String arrayDimTerm = i->substr(arrayStart + 1, arrayEnd - arrayStart - 1);
StringUtil::trim(arrayDimTerm);
// the array term might be a simple number or it might be
// an expression (e.g. 24*3) or refer to a constant expression
// we'd have to evaluate the expression which could get nasty
// TODO
def.arraySize = StringConverter::parseUnsignedLong(arrayDimTerm);
}
else
{
paramName = *i;
def.arraySize = 1;
}
// Name should be after the type, so complete def and add
// We do this now so that comma-separated params will do
// this part once for each name mentioned
if (def.constType == GCT_UNKNOWN)
{
LogManager::getSingleton().logMessage(
"Problem parsing the following GLSL Uniform: '"
+ line + "' in file " + filename);
// next uniform
break;
}
// Complete def and add
// increment physical buffer location
def.logicalIndex = 0; // not valid in GLSL
if (def.isFloat())
{
def.physicalIndex = defs.floatBufferSize;
defs.floatBufferSize += def.arraySize * def.elementSize;
}
else
{
def.physicalIndex = defs.intBufferSize;
defs.intBufferSize += def.arraySize * def.elementSize;
}
defs.map.insert(GpuConstantDefinitionMap::value_type(paramName, def));
// Generate array accessors
defs.generateConstantDefinitionArrayEntries(paramName, def);
}
}
} // not commented or a larger symbol
// Find next one
currPos = src.find("uniform", currPos);
}
}