void
AliasDB::getAliases (
const Url& contactIdentity,
ResultSet& rResultSet ) const
{
UtlString contactIdentityStr;
contactIdentity.getIdentity(contactIdentityStr);
// This should erase the contents of the existing resultset
rResultSet.clear();
if ( !contactIdentityStr.isNull() && (m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
// Match a all rows where the contact identity matches
UtlString queryString = "contact like '%" + contactIdentityStr + "%'";
dbQuery query;
query=queryString;
// Search to see if we have a Credential Row
dbCursor< AliasRow > cursor;
if ( cursor.select(query) > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* contactValue =
new UtlString ( cursor->contact );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* contactKey = new UtlString( gContactKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
contactKey, contactValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
void
AliasDB::getContacts (
const Url& identity,
ResultSet& rResultSet ) const
{
UtlString identityStr;
identity.getIdentity(identityStr);
// This should erase the contents from the resultset object
rResultSet.clear();
if ( !identityStr.isNull() && (m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
dbQuery query;
// Primary Key is the urialias's identity
query="identity=",identityStr;
// Search to see if we have a Credential Row
dbCursor< AliasRow > cursor;
if ( cursor.select(query) > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* contactValue =
new UtlString ( cursor->contact );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* contactKey = new UtlString( gContactKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
contactKey, contactValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
size_t Language::TypeScavenger::Find(ExecutionContextScope *exe_scope,
const char *key, ResultSet &results,
bool append) {
if (!exe_scope || !exe_scope->CalculateTarget().get())
return false;
if (!key || !key[0])
return false;
if (!append)
results.clear();
size_t old_size = results.size();
if (this->Find_Impl(exe_scope, key, results))
return results.size() - old_size;
return 0;
}
void
UserLocationDB::getLocations (
const UtlString& identityString,
ResultSet& rResultSet ) const
{
// This should erase the contents of the existing resultset
rResultSet.clear();
if ( !identityString.isNull() && ( m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
dbQuery query;
query="identity=",identityString;
// Search to see if we have a Credential Row
dbCursor< UserLocationRow > cursor;
if ( cursor.select(query) > 0 )
{
do {
UtlHashMap record;
UtlString* identityValue =
new UtlString ( cursor->identity );
UtlString* locationValue =
new UtlString ( cursor->location );
// Memory Leak fixes, make shallow copies of static keys
UtlString* identityKey = new UtlString( gIdentityKey );
UtlString* locationKey = new UtlString( gLocationKey );
record.insertKeyAndValue (
identityKey, identityValue );
record.insertKeyAndValue (
locationKey, locationValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
void
CredentialDB::getAllCredentials (
const Url& uri,
ResultSet& rResultSet ) const
{
UtlString identity;
uri.getIdentity(identity);
// This should erase the contents of the existing resultset
rResultSet.clear();
if ( !identity.isNull() && (m_pFastDB != NULL) )
{
// Thread Local Storage
m_pFastDB->attach();
// Search to see if we have a Credential Row
dbCursor< CredentialRow > cursor;
dbQuery query;
query="np_identity=",identity;
if ( cursor.select( query ) > 0 )
{
do {
UtlHashMap record;
UtlString* uriValue =
new UtlString ( cursor->uri );
UtlString* realmValue =
new UtlString ( cursor->realm );
UtlString* useridValue =
new UtlString ( cursor->userid );
UtlString* passtokenValue =
new UtlString ( cursor->passtoken );
UtlString* pintokenValue =
new UtlString ( cursor->pintoken );
UtlString* authtypeValue =
new UtlString ( cursor->authtype );
// Memory Leak fixes, make shallow copies of static keys
UtlString* uriKey = new UtlString( gUriKey );
UtlString* realmKey = new UtlString( gRealmKey );
UtlString* useridKey = new UtlString( gUseridKey );
UtlString* passtokenKey = new UtlString( gPasstokenKey );
UtlString* pintokenKey = new UtlString( gPintokenKey );
UtlString* authtypeKey = new UtlString( gAuthtypeKey );
record.insertKeyAndValue ( uriKey, uriValue );
record.insertKeyAndValue ( realmKey, realmValue );
record.insertKeyAndValue ( useridKey, useridValue );
record.insertKeyAndValue ( passtokenKey, passtokenValue );
record.insertKeyAndValue ( pintokenKey, pintokenValue );
record.insertKeyAndValue ( authtypeKey, authtypeValue );
rResultSet.addValue(record);
} while ( cursor.next() );
}
// Commit the rows to memory - multiprocess workaround
m_pFastDB->detach(0);
}
}
bool Classifier::processFeatures(const FeatureVector& featureVector, ResultSet &results)
{
//K-nearest-neighbour
const int K = 10;
Neighbour neighbours[K];
Neighbour& lastNeighbour = neighbours[K-1];
for(int i = 0; i < K; ++i){ neighbours[i].symbol = 0; neighbours[i].dist = 0.0f; }
//Loop through all symbols
for(unsigned int i = 0; i < database->getSymbolCount(); ++i)
{
void* symbolHandle = database->getSymbolHandle(i);
//Loop through all sample points of this symbol
for(unsigned int j = 0; j < database->getSymbolFeatureCount(symbolHandle, FeatureTypeVector); ++j)
{
float distance = getDistance(featureVector, *(FeatureVector*)database->getSymbolFeature(symbolHandle, FeatureTypeVector, j));
if( lastNeighbour.symbol == 0 || distance < lastNeighbour.dist )
{
//See where it should be in the array
for(int i = 0; i < K; ++i)
{
if( neighbours[i].symbol == 0 ) //If we did not have K neighbours yet
{
neighbours[i].symbol = symbolHandle;
neighbours[i].dist = distance;
break;
}
if( distance < neighbours[i].dist )
{
//shift the remaining neighbours
for(int j = K-1; j > i; --j)
{
neighbours[j].symbol = neighbours[j-1].symbol;
neighbours[j].dist = neighbours[j-1].dist;
}
neighbours[i].symbol = symbolHandle;
neighbours[i].dist = distance;
break;
}
}
}
}
}
//Now generate the scores
results.clear();
for(int i = 0; i < K; ++i)
{
if( neighbours[i].symbol == 0 ) break; //no more neighbours
const char* symbol = database->getSymbolString(neighbours[i].symbol);
if( symbol == 0 ) continue;
float score = 1 - 0.2f*neighbours[i].dist;
if( score <= 0.0f ) break;
//Check if this symbol was already in the result set
bool found = false;
for(unsigned int j = 0; j < results.size(); ++j)
{
if( results[j].symbol == symbol )
{
results[j].score += 0.5f*score;
found = true;
break;
}
}
if( found == false )
{
results.push_back(Result(symbol, score));
}
}
//TODO:
//If there is a single neighbour really close and all other neighbours much further away
//then the score of this single neighbour should be higher since it may be the only sample of a feature
bool certain = false;
for(unsigned int j = 0; j < results.size(); ++j)
{
if( results[j].score > 0.6 )
{
certain = true;
break;
}
}
#if LDEBUG
if( neighbours[0].symbol == 0 ) std::cout << "No best symbol found.\n";
else
{
std::cout << "Nearest neighbours:";
for(int i = 0; i < K; ++i)
{
const char* symbol = database->getSymbolString(neighbours[i].symbol);
if( symbol == 0 ) std::cout << " ERR";
else std::cout << " " << symbol;
std::cout << "(" << std::setprecision(3) << neighbours[i].dist << ")";
}
std::cout << std::endl;
}
#endif
return certain;
}
void PrintResults()
{
#if defined(EASTL_BENCHMARK_WRITE_FILE) && EASTL_BENCHMARK_WRITE_FILE
FileWriter fileWriter; // This will auto-execute.
#endif
// Print the results
EA::UnitTest::Report("\n");
EA::UnitTest::Report("****************************************************************************************\n");
EA::UnitTest::Report("EASTL Benchmark test results\n");
EA::UnitTest::Report("****************************************************************************************\n");
EA::UnitTest::Report("\n");
EA::UnitTest::Report("EASTL version: %s\n", EASTL_VERSION);
EA::UnitTest::Report("Platform: %s\n", gEnvironment.msPlatform.c_str());
EA::UnitTest::Report("Compiler: %s\n", EA_COMPILER_STRING);
#if defined(EA_DEBUG) || defined(_DEBUG)
EA::UnitTest::Report("Allocator: PPMalloc::GeneralAllocatorDebug. Thread safety enabled.\n");
EA::UnitTest::Report("Build: Debug. Inlining disabled. STL debug features disabled.\n");
#else
EA::UnitTest::Report("Allocator: PPMalloc::GeneralAllocator. Thread safety enabled.\n");
EA::UnitTest::Report("Build: Full optimization. Inlining enabled.\n");
#endif
EA::UnitTest::Report("\n");
EA::UnitTest::Report("Values are ticks and time to complete tests; smaller values are better.\n");
EA::UnitTest::Report("\n");
EA::UnitTest::Report("%-42s%26s%26s%13s%13s\n", "Test", gEnvironment.msSTLName1.c_str(), gEnvironment.msSTLName2.c_str(), "Ratio", "Difference?");
EA::UnitTest::Report("---------------------------------------------------------------------------------------------------------------------\n");
eastl::string sTestTypeLast;
eastl::string sTestTypeTemp;
for(ResultSet::iterator it = gResultSet.begin(); it != gResultSet.end(); ++it)
{
const Result& result = *it;
eastl_size_t n = result.msName.find('/');
if(n == eastl::string::npos)
n = result.msName.length();
sTestTypeTemp.assign(result.msName, 0, n);
if(sTestTypeTemp != sTestTypeLast) // If it looks like we are changing to a new test type... add an empty line to help readability.
{
if(it != gResultSet.begin())
EA::UnitTest::Report("\n");
sTestTypeLast = sTestTypeTemp;
}
PrintResultLine(result);
}
// We will print out a final line that has the sum of the rows printed above.
Result resultSum;
resultSum.msName = "sum";
for(ResultSet::iterator its = gResultSet.begin(); its != gResultSet.end(); ++its)
{
const Result& resultTemp = *its;
EASTL_ASSERT(resultTemp.mUnits == EA::StdC::Stopwatch::kUnitsCPUCycles); // Our ConvertStopwatchUnits call below assumes that every measured time is CPUCycles.
resultSum.mTime1 += resultTemp.mTime1;
resultSum.mTime2 += resultTemp.mTime2;
}
// We do this convert as a final step instead of the loop in order to avoid loss of precision.
resultSum.mTime1NS = ConvertStopwatchUnits(EA::StdC::Stopwatch::kUnitsCPUCycles, resultSum.mTime1, EA::StdC::Stopwatch::kUnitsNanoseconds);
resultSum.mTime2NS = ConvertStopwatchUnits(EA::StdC::Stopwatch::kUnitsCPUCycles, resultSum.mTime2, EA::StdC::Stopwatch::kUnitsNanoseconds);
EA::UnitTest::Report("\n");
PrintResultLine(resultSum);
EA::UnitTest::Report("\n");
EA::UnitTest::Report("****************************************************************************************\n");
EA::UnitTest::Report("\n");
// Clear the results
gResultSet.clear();
gEnvironment.clear();
}