void EventSource::connect()
{
LOG(TRACE) + "Connecting EventSource: " + m_url;
ASSERT(m_state == CONNECTING);
ASSERT(m_pNetRequest == 0);
Hashtable<String,String> headers;
headers.put("Accept","text/event-stream");
headers.put("Cache-Control", "no-cache");
if (!m_lastEventId.empty())
headers.put("Last-Event-ID", m_lastEventId);
{
common::CMutexLock lock(m_mxReqAccess);
m_pNetRequest = new net::CAsyncNetRequest();
m_pNetRequest->setMethod("GET");
m_pNetRequest->setUrl(m_url);
m_pNetRequest->setHeaders(headers);
m_pNetRequest->setCallback(this);
new common::CRhoCallInThread<net::CAsyncNetRequest>( m_pNetRequest );
}
}
static size_t curlHeaderCallback(void *ptr, size_t size, size_t nmemb, void *opaque)
{
Hashtable<String,String>* pHeaders = (Hashtable<String,String>*)opaque;
size_t nBytes = size*nmemb;
String strHeader((const char *)ptr, nBytes);
RAWTRACE1("Received header: %s", strHeader.c_str());
int nSep = strHeader.find(':');
if (nSep > 0 )
{
String strName = String_trim(strHeader.substr(0, nSep));
String lName;
std::transform(strName.begin(), strName.end(), std::back_inserter(lName), &::tolower);
String strValue = String_trim(strHeader.substr(nSep+1, strHeader.length() - (nSep+3) ));
if ( pHeaders->containsKey(lName) )
{
strValue += ";" + pHeaders->get( lName );
pHeaders->put( lName, strValue );
}
else
pHeaders->put(lName, strValue);
}
return nBytes;
}
const Hashtable*
LocaleUtility::getAvailableLocaleNames(const UnicodeString& bundleID)
{
// LocaleUtility_cache is a hash-of-hashes. The top-level keys
// are path strings ('bundleID') passed to
// ures_openAvailableLocales. The top-level values are
// second-level hashes. The second-level keys are result strings
// from ures_openAvailableLocales. The second-level values are
// garbage ((void*)1 or other random pointer).
UErrorCode status = U_ZERO_ERROR;
umtx_initOnce(LocaleUtilityInitOnce, locale_utility_init, status);
Hashtable *cache = LocaleUtility_cache;
if (cache == NULL) {
// Catastrophic failure.
return NULL;
}
Hashtable* htp;
umtx_lock(NULL);
htp = (Hashtable*) cache->get(bundleID);
umtx_unlock(NULL);
if (htp == NULL) {
htp = new Hashtable(status);
if (htp && U_SUCCESS(status)) {
CharString cbundleID;
cbundleID.appendInvariantChars(bundleID, status);
const char* path = cbundleID.isEmpty() ? NULL : cbundleID.data();
UEnumeration *uenum = ures_openAvailableLocales(path, &status);
for (;;) {
const UChar* id = uenum_unext(uenum, NULL, &status);
if (id == NULL) {
break;
}
htp->put(UnicodeString(id), (void*)htp, status);
}
uenum_close(uenum);
if (U_FAILURE(status)) {
delete htp;
return NULL;
}
umtx_lock(NULL);
Hashtable *t = static_cast<Hashtable *>(cache->get(bundleID));
if (t != NULL) {
// Another thread raced through this code, creating the cache entry first.
// Discard ours and return theirs.
umtx_unlock(NULL);
delete htp;
htp = t;
} else {
cache->put(bundleID, (void*)htp, status);
umtx_unlock(NULL);
}
}
}
return htp;
}
void LoadBalancingListener::createRoom()
{
char name[16];
sprintf(name, "native-%d",rand() % 100);
Hashtable props;
props.put("s", mGridSize);
props.put("m", mMap);
mpLbc->opCreateRoom(name, true, true, 0, props);
mpView->info( "Creating room %s", name );
}
const Hashtable* getSupportedIDs(UErrorCode& status) const
{
if (supportedIDs == NULL) {
Hashtable* table = new Hashtable();
table->put(UnicodeString(californio), (void*)table, status);
table->put(UnicodeString(valley), (void*)table, status);
table->put(UnicodeString(surfer), (void*)table, status);
table->put(UnicodeString(geek), (void*)table, status);
// not necessarily atomic, but this is a test...
supportedIDs = table;
}
return supportedIDs;
}
bool rhom_method_name_isreserved(const String& strName)
{
static Hashtable<String,int> reserved_names;
if ( reserved_names.size() == 0 )
{
reserved_names.put("object",1);
reserved_names.put("source_id",1);
reserved_names.put("update_type",1);
reserved_names.put("attrib_type",1);
reserved_names.put("set_notification",1);
reserved_names.put("clear_notification",1);
}
return reserved_names.get(strName) != 0;
}
virtual void updateVisibleIDs(Hashtable& result, UErrorCode& status) const
{
if (U_SUCCESS(status)) {
const UnicodeString& id = fID;
result.put(id, (void*)this, status);
}
}
void updateVisibleIDs(Hashtable& result, UErrorCode& status) const {
if (U_SUCCESS(_status)) {
for (int32_t i = 0; i < _ids.size(); ++i) {
result.put(*(UnicodeString*)_ids[i], (void*)this, status);
}
}
}
void
LocaleKeyFactory::updateVisibleIDs(Hashtable & result, UErrorCode & status) const
{
const Hashtable * supported = getSupportedIDs(status);
if (supported)
{
UBool visible = (_coverage & 0x1) == 0;
const UHashElement * elem = NULL;
int32_t pos = 0;
while ((elem = supported->nextElement(pos)) != NULL)
{
const UnicodeString & id = *((const UnicodeString *)elem->key.pointer);
if (!visible)
{
result.remove(id);
}
else
{
result.put(id, (void *)this, status); // this is dummy non-void marker used for set semantics
if (U_FAILURE(status))
{
break;
}
}
}
}
}
bool LoadBalancingListener::setLocalPlayerPos(int x, int y)
{
if(x >= 0 && x < mGridSize && y >= 0 && y < mGridSize)
{
int prevGroup = getGroupByPos();
mLocalPlayer.x = x;
mLocalPlayer.y = y;
if(prevGroup != getGroupByPos())
updateGroups();
Hashtable data;
nByte coords[] = {static_cast<nByte>(mLocalPlayer.x), static_cast<nByte>(mLocalPlayer.y)};
data.put((nByte)1, coords, 2);
if(mSendGroup)
mpLbc->opRaiseEvent(false, data, 2, 0, 0, 0, 0, 0, mSendGroup);
else
{
if(mUseGroups)
mpLbc->opRaiseEvent(false, data, 2, 0, 0, 0, 0, 0, getGroupByPos());
else
mpLbc->opRaiseEvent(false, data, 2);
}
mpView->changePlayerPos(mLcalPlayerNr, mLocalPlayer.x, mLocalPlayer.y);
return true;
}
else
return false;
}
Hashtable Game::stateToProps(bool turnPass)
{
const int BUF_SIZE = 20; // 1 int with some prefix
char buf[BUF_SIZE];
Hashtable props;
for(int i = 0;i < TILE_COUNT;++i)
{
if(tiles[i])
{
sprintf(buf, "%d", i);
props.put(buf, tiles[i]);
}
}
props.put("flips", flippedTiles, 2);
props.put("pt", nextTurnPlayer);
props.put("t#", turnNumber);
sprintf(buf, "pt%d", myActorNr());
props.put(buf, myPoints); // we always only save "our" points. this will not affect the opponent's score.
if(abandoned)
props.put("abandoned", abandoned);
if(turnPass)
props.put(PROP_TURN, lbl->getNextPlayer(nextTurnPlayer));
return props;
}
void MutablePlayer::setName(const JString& name)
{
if(mName != name)
{
Hashtable properties;
properties.put(static_cast<nByte>(Properties::Player::PLAYERNAME), mName=name);
mLoadBalancingClient->opSetPropertiesOfPlayer(mNumber, properties);
}
}
void
SimpleFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const
{
if (_visible) {
result.put(_id, (void*)this, status); // cast away const
} else {
result.remove(_id);
}
}
int main(void)
{
Hashtable *x = new Hashtable();
char *hola = "Hola";
x->put(hola, 1);
cout << (*x)[hola];
return(0);
}
void
SimpleLocaleKeyFactory::updateVisibleIDs(Hashtable& result, UErrorCode& status) const
{
if (U_SUCCESS(status)) {
if (_coverage & 0x1) {
result.remove(_id);
} else {
result.put(_id, (void*)this, status);
}
}
}
Handle_ptr hashsetCommand( CBuiltinAdapter *adapter, Context &ctx,
Environment *env, std::vector<Handle_ptr> args)
{
if (3 != args.size()) {
throw ArgumentCountException( 3, __FILE__, __LINE__);
}
Hashtable *hashtable = asHashtable( args[0]);
std::string key = args[1]->stringValue();
hashtable->put( key, args[2]);
return args[1];
}
void MutableRoom::setPropsListedInLobby(const JVector<JString>& propsListedInLobby)
{
if(mPropsListedInLobby != propsListedInLobby)
{
mPropsListedInLobby = propsListedInLobby;
JString* propsListedInLobbyArr = allocateArray<JString>(propsListedInLobby.getSize());
for(unsigned int i=0; i<propsListedInLobby.getSize(); ++i)
propsListedInLobbyArr[i] = propsListedInLobby[i];
Hashtable properties;
properties.put(static_cast<nByte>(Properties::Room::PROPS_LISTED_IN_LOBBY), propsListedInLobbyArr, propsListedInLobby.getSize());
deallocateArray(propsListedInLobbyArr);
mLoadBalancingPeer->opSetPropertiesOfRoom(properties);
}
}
void CRingtoneManager::getAllRingtones (Hashtable<String, String>& ringtones)
{
SNDFILEINFO *sndFilesList = NULL;
int filesNum = 0;
//TODO: check result
SndGetSoundFileList(SND_EVENT_RINGTONELINE1, SND_LOCATION_ALL, &sndFilesList, &filesNum);
LOG(INFO) + __FUNCTION__ + ": " + filesNum + " found";
USES_CONVERSION;
for (int i = 0; i < filesNum; i++) {
SNDFILEINFO& sndFile = sndFilesList[i];
if (sndFile.sstType == SND_SOUNDTYPE_FILE)
ringtones.put( convertToStringA(sndFile.szDisplayName), convertToStringA(sndFile.szPathName));
}
}
/**
* Return the set of ids that this factory supports (visible or
* otherwise). This can be called often and might need to be
* cached if it is expensive to create.
*/
virtual const Hashtable* getSupportedIDs(UErrorCode& status) const
{
if (U_SUCCESS(status)) {
if (!_ids) {
int32_t count = 0;
const UnicodeString * const idlist = _delegate->getSupportedIDs(count, status);
((NFFactory*)this)->_ids = new Hashtable(status); /* cast away const */
if (_ids) {
for (int i = 0; i < count; ++i) {
_ids->put(idlist[i], (void*)this, status);
}
}
}
return _ids;
}
return NULL;
}
/**
* Register a source-target/variant in the specDAG. Variant may be
* empty, but source and target must not be. If variant is empty then
* the special variant NO_VARIANT is stored in slot zero of the
* UVector of variants.
*/
void TransliteratorRegistry::registerSTV(const UnicodeString& source,
const UnicodeString& target,
const UnicodeString& variant) {
// assert(source.length() > 0);
// assert(target.length() > 0);
UErrorCode status = U_ZERO_ERROR;
Hashtable *targets = (Hashtable*) specDAG.get(source);
if (targets == 0) {
targets = new Hashtable(TRUE, status);
if (U_FAILURE(status) || targets == 0) {
return;
}
targets->setValueDeleter(uprv_deleteUObject);
specDAG.put(source, targets, status);
}
UVector *variants = (UVector*) targets->get(target);
if (variants == 0) {
variants = new UVector(uprv_deleteUObject,
uhash_compareCaselessUnicodeString, status);
if (variants == 0) {
return;
}
targets->put(target, variants, status);
}
// assert(NO_VARIANT == "");
// We add the variant string. If it is the special "no variant"
// string, that is, the empty string, we add it at position zero.
if (!variants->contains((void*) &variant)) {
UnicodeString *tempus; // Used for null pointer check.
if (variant.length() > 0) {
tempus = new UnicodeString(variant);
if (tempus != NULL) {
variants->addElement(tempus, status);
}
} else {
tempus = new UnicodeString(); // = NO_VARIANT
if (tempus != NULL) {
variants->insertElementAt(tempus, 0, status);
}
}
}
}
boolean CNetRequestImpl::readHeaders(Hashtable<String,String>& oHeaders)
{
oHeaders.clear();
CAtlStringW strHeaders;
DWORD dwLen = 0;
DWORD nIndex = 0;
if( !HttpQueryInfo( hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, null, &dwLen, &nIndex) )
{
DWORD dwErr = ::GetLastError();
if ( dwErr != ERROR_INSUFFICIENT_BUFFER )
{
pszErrFunction = L"HttpQueryInfo";
return false;
}
}
if( !HttpQueryInfo( hRequest, HTTP_QUERY_RAW_HEADERS_CRLF, strHeaders.GetBuffer(dwLen), &dwLen, &nIndex) )
{
pszErrFunction = L"HttpQueryInfo";
return false;
}
strHeaders.ReleaseBuffer();
int nStart = 0;
for(int nEnd = strHeaders.Find(L"\r\n", nStart); nEnd > 0; nStart = nEnd+2, nEnd = strHeaders.Find(L"\r\n", nStart) )
{
CAtlStringW strHeader = strHeaders.Mid(nStart, nEnd-nStart);
int nSep = strHeader.Find(':');
if (nSep < 0 )
continue;
CAtlStringW strName = strHeader.Mid(0, nSep);
strName.Trim();
strName.MakeLower();
CAtlStringW strValue = strHeader.Mid(nSep+1);
strValue.Trim();
oHeaders.put(common::convertToStringA(strName.GetString()),common::convertToStringA(strValue.GetString()));
}
return true;
}
CFactory(CollatorFactory* delegate, UErrorCode& status)
: LocaleKeyFactory(delegate->visible() ? VISIBLE : INVISIBLE)
, _delegate(delegate)
, _ids(NULL)
{
if (U_SUCCESS(status)) {
int32_t count = 0;
_ids = new Hashtable(status);
if (_ids) {
const UnicodeString * idlist = _delegate->getSupportedIDs(count, status);
for (int i = 0; i < count; ++i) {
_ids->put(idlist[i], (void*)this, status);
if (U_FAILURE(status)) {
delete _ids;
_ids = NULL;
return;
}
}
} else {
status = U_MEMORY_ALLOCATION_ERROR;
}
}
}
/*static*/void CDBAttrManager::loadAttrs(CDBAdapter& db, HashtablePtr< int, Hashtable<String,int>* >& mapAttrs, String strDBAttr)
{
mapAttrs.clear();
String strSql = "SELECT source_id,";
strSql += strDBAttr + " from sources";
IDBResult res = db.executeSQL(strSql.c_str());
for ( ; !res.isEnd(); res.next() )
{
int nSrcID = res.getIntByIdx(0);
String strAttribs = res.getStringByIdx(1);
if ( strAttribs.length() == 0 )
continue;
CTokenizer oTokenizer( strAttribs, "," );
Hashtable<String,int>* pmapAttr = new Hashtable<String,int>();
String strAttr = "";
while (oTokenizer.hasMoreTokens())
{
String tok = oTokenizer.nextToken();
if (tok.length() == 0)
continue;
if ( strAttr.length() > 0 )
{
int nCounter = 0;
convertFromStringA(tok.c_str(),nCounter);
pmapAttr->put(strAttr, nCounter);
strAttr = "";
}else
strAttr = tok;
}
mapAttrs.put(nSrcID,pmapAttr);
}
}
void rho_syncclient_itemdestroy( const char* szModel, unsigned long hash )
{
Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
String src_name = szModel;
String obj = hashObject.get("object");
String update_type="delete";
DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
if ( res.isEnd())
{
//TODO: report error - unknown source
return;
}
int nSrcID = res.getIntByIdx(0);
String db_partition = res.getStringByIdx(1);
bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
String tableName = isSchemaSrc ? src_name : "object_values";
db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
db.startTransaction();
//save list of attrs
unsigned long item = 0;
if ( isSchemaSrc )
{
DBResult( attrsList, db.executeSQL( ("SELECT * FROM " + tableName + " WHERE object=?").c_str(), obj) );
if ( !attrsList.isEnd() )
item = rhom_make_object(attrsList,nSrcID,isSchemaSrc);
}else
{
DBResult( attrsList, db.executeSQL( ("SELECT attrib, value FROM " + tableName + " WHERE object=? and source_id=?").c_str(), obj, nSrcID) );
if ( !attrsList.isEnd() )
item = rhom_make_object(attrsList,nSrcID,isSchemaSrc);
}
//first delete the record from viewable list
db.executeSQL( ("DELETE FROM " + tableName + " WHERE object=?").c_str(), obj );
if ( isSyncSrc )
{
DBResult( resCreateType, db.executeSQL("SELECT update_type FROM changed_values WHERE object=? and update_type=? and sent=?",
obj, "create", 0) );
db.executeSQL("DELETE FROM changed_values WHERE object=? and sent=?", obj, 0);
if ( resCreateType.isEnd() && item != 0 )
{
Hashtable<String,String>& hashItem = *((Hashtable<String,String>*)item);
for ( Hashtable<String,String>::iterator it = hashItem.begin(); it != hashItem.end(); ++it )
{
String key = it->first;
String val = it->second;
if ( rhom_method_name_isreserved(key) )
continue;
Hashtable<String,String> fields;
fields.put("source_id", convertToStringA(nSrcID));
fields.put("object", obj);
fields.put("attrib", key);
fields.put("value", val);
fields.put("update_type", update_type);
db_insert_into_table(db, "changed_values", fields );
}
rho_syncclient_hash_delete(item);
}
}
db.endTransaction();
}
void CanonicalIteratorTest::TestBasic() {
UErrorCode status = U_ZERO_ERROR;
static const char * const testArray[][2] = {
{"\\u00C5d\\u0307\\u0327", "A\\u030Ad\\u0307\\u0327, A\\u030Ad\\u0327\\u0307, A\\u030A\\u1E0B\\u0327, "
"A\\u030A\\u1E11\\u0307, \\u00C5d\\u0307\\u0327, \\u00C5d\\u0327\\u0307, "
"\\u00C5\\u1E0B\\u0327, \\u00C5\\u1E11\\u0307, \\u212Bd\\u0307\\u0327, "
"\\u212Bd\\u0327\\u0307, \\u212B\\u1E0B\\u0327, \\u212B\\u1E11\\u0307"},
{"\\u010d\\u017E", "c\\u030Cz\\u030C, c\\u030C\\u017E, \\u010Dz\\u030C, \\u010D\\u017E"},
{"x\\u0307\\u0327", "x\\u0307\\u0327, x\\u0327\\u0307, \\u1E8B\\u0327"},
};
#if 0
// This is not interesting for C/C++ as the data is already built beforehand
// check build
UnicodeSet ss = CanonicalIterator.getSafeStart();
logln("Safe Start: " + ss.toPattern(true));
ss = CanonicalIterator.getStarts('a');
expectEqual("Characters with 'a' at the start of their decomposition: ", "", CanonicalIterator.getStarts('a'),
new UnicodeSet("[\u00E0-\u00E5\u0101\u0103\u0105\u01CE\u01DF\u01E1\u01FB"
+ "\u0201\u0203\u0227\u1E01\u1EA1\u1EA3\u1EA5\u1EA7\u1EA9\u1EAB\u1EAD\u1EAF\u1EB1\u1EB3\u1EB5\u1EB7]")
);
#endif
// check permute
// NOTE: we use a TreeSet below to sort the output, which is not guaranteed to be sorted!
Hashtable *permutations = new Hashtable(FALSE, status);
permutations->setValueDeleter(uhash_deleteUnicodeString);
UnicodeString toPermute("ABC");
CanonicalIterator::permute(toPermute, FALSE, permutations, status);
logln("testing permutation");
expectEqual("Simple permutation ", "", collectionToString(permutations), "ABC, ACB, BAC, BCA, CAB, CBA");
delete permutations;
// try samples
logln("testing samples");
Hashtable *set = new Hashtable(FALSE, status);
set->setValueDeleter(uhash_deleteUnicodeString);
int32_t i = 0;
CanonicalIterator it("", status);
if(U_SUCCESS(status)) {
for (i = 0; i < ARRAY_LENGTH(testArray); ++i) {
//logln("Results for: " + name.transliterate(testArray[i]));
UnicodeString testStr = CharsToUnicodeString(testArray[i][0]);
it.setSource(testStr, status);
set->removeAll();
for (;;) {
//UnicodeString *result = new UnicodeString(it.next());
UnicodeString result(it.next());
if (result.isBogus()) {
break;
}
set->put(result, new UnicodeString(result), status); // Add result to the table
//logln(++counter + ": " + hex.transliterate(result));
//logln(" = " + name.transliterate(result));
}
expectEqual(i + ": ", testStr, collectionToString(set), CharsToUnicodeString(testArray[i][1]));
}
} else {
errln("Couldn't instantiate canonical iterator. Error: %s", u_errorName(status));
}
delete set;
}
void rho_syncclient_save( const char* szModel, unsigned long hash )
{
Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
String src_name = szModel;
DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
if ( res.isEnd())
{
//TODO: report error - unknown source
return;
}
int nSrcID = res.getIntByIdx(0);
String obj = hashObject.get("object");
String db_partition = res.getStringByIdx(1);
bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
String tableName = isSchemaSrc ? src_name : "object_values";
db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
db.startTransaction();
String update_type = "";
String sql;
Vector<String> arValues;
if (isSchemaSrc)
{
sql = "SELECT object FROM " + tableName + " WHERE object=? LIMIT 1 OFFSET 0";
arValues.addElement(obj);
}
else
{
sql = "SELECT object FROM " + tableName + " WHERE object=? AND source_id=? LIMIT 1 OFFSET 0";
arValues.addElement(obj);
arValues.addElement(convertToStringA(nSrcID));
}
DBResult( res1, db.executeSQLEx(sql.c_str(), arValues ) );
if (!res1.isEnd())
{
if (isSyncSrc)
{
DBResult( resUpdateType, db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and source_id=? and sent=?",
obj, nSrcID, 0 ) );
if (!resUpdateType.isEnd())
update_type = resUpdateType.getStringByIdx(0);
else
update_type = "update";
}else
update_type = "update";
}
else
{
rho_syncclient_create_object(szModel, hash);
}
if (!res.isEnd())
{
unsigned long item = rhom_load_item_by_object( db, src_name, nSrcID, obj, isSchemaSrc);
Hashtable<String, String>& hashItem = *((Hashtable<String, String>*)item);
for ( Hashtable<String,String>::iterator it = hashObject.begin(); it != hashObject.end(); ++it )
{
String key = it->first;
String val = it->second;
if ( rhom_method_name_isreserved(key) )
continue;
// add rows excluding object, source_id and update_type
Hashtable<String,String> fields;
fields.put("source_id", convertToStringA(nSrcID));
fields.put("object", obj);
fields.put("attrib", key);
fields.put("value", val);
fields.put("update_type", update_type);
if ( db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, key.c_str()) )
fields.put( "attrib_type", "blob.file");
if ( hashItem.containsKey(key) )
{
bool isModified = hashItem.get(key) != val;
if (isModified)
{
if (isSyncSrc)
{
DBResult( resUpdateType, db.executeSQL( "SELECT update_type FROM changed_values WHERE object=? and attrib=? and source_id=? and sent=?",
obj, key, nSrcID, 0 ) );
if (!resUpdateType.isEnd())
{
fields.put("update_type", resUpdateType.getStringByIdx(0) );
db.executeSQL( "DELETE FROM changed_values WHERE object=? and attrib=? and source_id=? and sent=?",
obj, key, nSrcID, 0 );
}
db_insert_into_table(db, "changed_values", fields);
}
if ( isSchemaSrc )
db.executeSQL( (String("UPDATE ") + tableName + " SET " + key + "=? WHERE object=?").c_str(), val, obj );
else
db.executeSQL( "UPDATE object_values SET value=? WHERE object=? and attrib=? and source_id=?", val, obj, key, nSrcID );
}
}else
{
if (isSyncSrc)
db_insert_into_table(db, "changed_values", fields);
fields.remove("update_type");
fields.remove("attrib_type");
if (isSchemaSrc)
db.executeSQL( (String("UPDATE ") + tableName + " SET " + key + "=? WHERE object=?").c_str(), val, obj );
else
db_insert_into_table(db, tableName, fields);
}
}
}
db.endTransaction();
}
void rho_syncclient_create_object(const char* szModel, unsigned long hash)
{
Hashtable<String, String>& hashObject = *((Hashtable<String, String>*)hash);
String src_name = szModel;
DBResult( res, db::CDBAdapter::getUserDB().executeSQL("SELECT source_id, partition, schema, sync_type from sources WHERE name=?", src_name) );
if ( res.isEnd())
{
//TODO: report error - unknown source
return;
}
String update_type = "create";
int nSrcID = res.getIntByIdx(0);
String obj = hashObject.containsKey("object") ? hashObject.get("object") : rhom_generate_id();
String db_partition = res.getStringByIdx(1);
bool isSchemaSrc = res.getStringByIdx(2).length() > 0;
bool isSyncSrc = res.getStringByIdx(3).compare("none") != 0;
String tableName = isSchemaSrc ? src_name : "object_values";
db::CDBAdapter& db = db::CDBAdapter::getDB(db_partition.c_str());
hashObject.put("source_id", convertToStringA(nSrcID));
hashObject.put("object", obj);
db.startTransaction();
if ( isSchemaSrc )
db_insert_into_table(db, tableName, hashObject, "source_id");
if ( isSyncSrc || !isSchemaSrc )
{
for ( Hashtable<String,String>::iterator it = hashObject.begin(); it != hashObject.end(); ++it )
{
String key = it->first;
String val = it->second;
if ( rhom_method_name_isreserved(key) )
continue;
// add rows excluding object, source_id and update_type
Hashtable<String,String> fields;
fields.put("source_id", convertToStringA(nSrcID));
fields.put("object", obj);
fields.put("attrib", key);
fields.put("value", val);
fields.put("update_type", update_type);
if ( db::CDBAdapter::getDB(db_partition.c_str()).getAttrMgr().isBlobAttr(nSrcID, key.c_str()) )
fields.put( "attrib_type", "blob.file");
if ( isSyncSrc )
db_insert_into_table(db, "changed_values", fields);
fields.remove("update_type");
fields.remove("attrib_type");
if ( !isSchemaSrc )
db_insert_into_table(db, tableName, fields);
}
}
db.endTransaction();
}
void LoadBalancingListener::raiseColorEvent(void)
{
Hashtable data;
data.put((nByte)1, mLocalPlayer.color);
mpLbc->opRaiseEvent(true, data, 1,0,ExitGames::Lite::EventCache::ADD_TO_ROOM_CACHE);
}
LKFSubclass(UBool visible)
: LocaleKeyFactory(visible ? VISIBLE : INVISIBLE, "LKFSubclass")
{
UErrorCode status = U_ZERO_ERROR;
table.put("en_US", this, status);
}
void CollationServiceTest::TestRegisterFactory(void)
{
#if !UCONFIG_NO_SERVICE
int32_t n1, n2, n3;
Locale fu_FU("fu", "FU", "");
Locale fu_FU_FOO("fu", "FU", "FOO");
UErrorCode status = U_ZERO_ERROR;
Hashtable* fuFUNames = new Hashtable(FALSE, status);
if (!fuFUNames) {
errln("memory allocation error");
return;
}
fuFUNames->setValueDeleter(uhash_deleteUnicodeString);
fuFUNames->put(fu_FU.getName(), new UnicodeString("ze leetle bunny Fu-Fu"), status);
fuFUNames->put(fu_FU_FOO.getName(), new UnicodeString("zee leetel bunny Foo-Foo"), status);
fuFUNames->put(Locale::getDefault().getName(), new UnicodeString("little bunny Foo Foo"), status);
Collator* frcol = Collator::createInstance(Locale::getFrance(), status);
Collator* gecol = Collator::createInstance(Locale::getGermany(), status);
Collator* jpcol = Collator::createInstance(Locale::getJapan(), status);
if(U_FAILURE(status)) {
errcheckln(status, "Failed to create collators with %s", u_errorName(status));
delete frcol;
delete gecol;
delete jpcol;
delete fuFUNames;
return;
}
CollatorInfo** info = new CollatorInfo*[4];
if (!info) {
errln("memory allocation error");
return;
}
info[0] = new CollatorInfo(Locale::getUS(), frcol, NULL);
info[1] = new CollatorInfo(Locale::getFrance(), gecol, NULL);
info[2] = new CollatorInfo(fu_FU, jpcol, fuFUNames);
info[3] = NULL;
TestFactory* factory = new TestFactory(info);
if (!factory) {
errln("memory allocation error");
return;
}
Collator* uscol = Collator::createInstance(Locale::getUS(), status);
Collator* fucol = Collator::createInstance(fu_FU, status);
{
n1 = checkAvailable("before registerFactory");
URegistryKey key = Collator::registerFactory(factory, status);
n2 = checkAvailable("after registerFactory");
assertTrue("count after > count before", n2 > n1);
Collator* ncol = Collator::createInstance(Locale::getUS(), status);
if (*frcol != *ncol) {
errln("frcoll for en_US failed");
}
delete ncol; ncol = NULL;
ncol = Collator::createInstance(fu_FU_FOO, status);
if (*jpcol != *ncol) {
errln("jpcol for fu_FU_FOO failed");
}
Locale loc = ncol->getLocale(ULOC_REQUESTED_LOCALE, status);
if (loc != fu_FU_FOO) {
errln(UnicodeString("requested locale for fu_FU_FOO is not fu_FU_FOO but ") + loc.getName());
}
loc = ncol->getLocale(ULOC_VALID_LOCALE, status);
if (loc != fu_FU) {
errln(UnicodeString("valid locale for fu_FU_FOO is not fu_FU but ") + loc.getName());
}
delete ncol; ncol = NULL;
UnicodeString locName = fu_FU.getName();
StringEnumeration* localeEnum = Collator::getAvailableLocales();
UBool found = FALSE;
const UnicodeString* locStr;
for (locStr = localeEnum->snext(status);
!found && locStr != NULL;
locStr = localeEnum->snext(status))
{
if (locName == *locStr) {
found = TRUE;
}
}
delete localeEnum;
if (!found) {
errln("new locale fu_FU not reported as supported locale");
}
UnicodeString name;
Collator::getDisplayName(fu_FU, name);
if (name != "little bunny Foo Foo") {
errln(UnicodeString("found ") + name + " for fu_FU");
}
Collator::getDisplayName(fu_FU, fu_FU_FOO, name);
if (name != "zee leetel bunny Foo-Foo") {
errln(UnicodeString("found ") + name + " for fu_FU in fu_FU_FOO");
}
if (!Collator::unregister(key, status)) {
errln("failed to unregister factory");
}
// ja, fr, ge collators no longer valid
ncol = Collator::createInstance(fu_FU, status);
if (*fucol != *ncol) {
errln("collator after unregister does not match original fu_FU");
}
delete ncol;
n3 = checkAvailable("after unregister");
assertTrue("count after unregister == count before register", n3 == n1);
}
delete fucol;
delete uscol;
#endif
}
