void Texture::setbad( const string & s)
{
// Put both current path+texfile and shared texfile since they both have been looked for
bool * b = new bool( true);
if( VSFileSystem::current_path.back()!="")
badtexHashTable.Put( VSFileSystem::GetHashName(s), b);
badtexHashTable.Put( VSFileSystem::GetSharedTextureHashName(s), b);
}
// This program exercises the Ref class.
int main(void)
{
CompleteSetupSystem setupSystem;
printf("sizeof(TestItemRef)=%i\n", (int)sizeof(TestItemRef));
{
printf("Checking queue...\n");
Queue<TestItemRef> q;
printf("Adding refs...\n");
for (int i=0; i<10; i++)
{
char temp[50]; muscleSprintf(temp, "%i", i);
TestItemRef tr(new TestItem(temp));
ConstTestItemRef ctr(tr);
ConstTestItemRef t2(ctr);
q.AddTail(tr);
}
printf("Removing refs...\n");
while(q.HasItems()) q.RemoveHead();
printf("Done with queue test!\n");
}
{
printf("Checking hashtable\n");
Hashtable<String, TestItemRef> ht;
printf("Adding refs...\n");
for (int i=0; i<10; i++)
{
char temp[50]; muscleSprintf(temp, "%i", i);
ht.Put(String(temp), TestItemRef(new TestItem(temp)));
}
printf("Removing refs...\n");
for (int i=0; i<10; i++)
{
char temp[50]; muscleSprintf(temp, "%i", i);
ht.Remove(String(temp));
}
printf("Done with hash table test!\n");
}
printf("Beginning multithreaded object usage test...\n");
{
const uint32 NUM_THREADS = 50;
TestThread threads[NUM_THREADS];
for (uint32 i=0; i<NUM_THREADS; i++) threads[i].StartInternalThread();
Snooze64(SecondsToMicros(10));
for (uint32 i=0; i<NUM_THREADS; i++) threads[i].ShutdownInternalThread();
printf("Multithreaded object usage test complete.\n");
}
printf("testrefcount complete, bye!\n");
return 0;
}
collideTrees::collideTrees( const std::string &hk, csOPCODECollider *cT,
csOPCODECollider *cS ) : hash_key( hk )
, colShield( cS )
{
for (unsigned int i = 0; i < collideTreesMaxTrees; ++i)
rapidColliders[i] = NULL;
rapidColliders[0] = cT;
refcount = 1;
unitColliders.Put( hash_key, this );
}
/**
* Returns the relationship between myfaction and theirfaction
* 1 is happy. 0 is neutral (btw 1 and 0 will not attack)
* -1 is mad. <0 will attack
*/
int FactionUtil::GetFactionIndex( const string& name )
{
static Hashtable< string, int, 47 >factioncache;
int *tmp = factioncache.Get( name );
if (tmp)
return *tmp;
int i = GetFactionLookup( name.c_str() );
tmp = new int;
*tmp = i;
factioncache.Put( name, tmp );
return i;
}
void Texture::modold (const string &s, bool shared, string & hashname) {
hashname = shared?VSFileSystem::GetSharedTextureHashName(s):VSFileSystem::GetHashName(s);
Texture * oldtex = new Texture;
// oldtex->InitTexture();new calls this
oldtex->name=-1;
oldtex->refcount=1;
oldtex->original=NULL;
oldtex->palette=NULL;
oldtex->data=NULL;
texHashTable.Put(hashname, oldtex);
original = oldtex;
}
StdinDataIO :: StdinDataIO(bool blocking, bool writeToStdout)
: _stdinBlocking(blocking)
, _writeToStdout(writeToStdout)
#ifdef USE_WIN32_STDINDATAIO_IMPLEMENTATION
, _slaveSocketTag(0)
#else
, _fdIO(ConstSocketRef(&_stdinSocket, false), true)
#endif
{
#ifdef USE_WIN32_STDINDATAIO_IMPLEMENTATION
if (_stdinBlocking == false)
{
// For non-blocking I/O, we need to handle stdin in a separate thread.
// note that I freopen stdin to "nul" so that other code (read: Python)
// won't try to muck about with stdin and interfere with StdinDataIO's
// operation. I don't know of any good way to restore it again after,
// though... so a side effect of StdinDataIO under Windows is that
// stdin gets redirected to nul... once you've created one non-blocking
// StdinDataIO, you'll need to continue accessing stdin only via
// non-blocking StdinDataIOs.
bool okay = false;
ConstSocketRef slaveSocket;
if ((CreateConnectedSocketPair(_masterSocket, slaveSocket, false) == B_NO_ERROR)&&(SetSocketBlockingEnabled(slaveSocket, true) == B_NO_ERROR)&&(_slaveSocketsMutex.Lock() == B_NO_ERROR))
{
bool threadCreated = false;
if (_stdinThreadStatus == STDIN_THREAD_STATUS_UNINITIALIZED)
{
DWORD junkThreadID;
#if __STDC_WANT_SECURE_LIB__
FILE * junkFD;
#endif
_stdinThreadStatus = ((DuplicateHandle(GetCurrentProcess(), GetStdHandle(STD_INPUT_HANDLE), GetCurrentProcess(), &_stdinHandle, 0, false, DUPLICATE_SAME_ACCESS))&&
#if __STDC_WANT_SECURE_LIB__
(freopen_s(&junkFD, "nul", "r", stdin) == 0)
#else
(freopen("nul", "r", stdin) != NULL)
#endif
&&((_slaveThread = (::HANDLE) _beginthreadex(NULL, 0, StdinThreadEntryFunc, NULL, CREATE_SUSPENDED, (unsigned *) &junkThreadID)) != 0)) ? STDIN_THREAD_STATUS_RUNNING : STDIN_THREAD_STATUS_EXITED;
threadCreated = (_stdinThreadStatus == STDIN_THREAD_STATUS_RUNNING);
}
if ((_stdinThreadStatus == STDIN_THREAD_STATUS_RUNNING)&&(_slaveSockets.Put(_slaveSocketTag = (++_slaveSocketTagCounter), slaveSocket) == B_NO_ERROR)) okay = true;
else LogTime(MUSCLE_LOG_ERROR, "StdinDataIO: Could not start stdin thread!\n");
_slaveSocketsMutex.Unlock();
// We don't start the thread running until here, that way there's no chance of race conditions if the thread exits immediately
if (threadCreated) ResumeThread(_slaveThread);
}
else LogTime(MUSCLE_LOG_ERROR, "StdinDataIO: Error setting up I/O sockets!\n");
if (okay == false) Close();
}
#endif
}
static void TestIteratorSanityOnRemoval(bool backwards)
{
LogTime(MUSCLE_LOG_INFO, "Testing iterator sanity (direction=%s)\n", backwards?"backwards":"forwards");
static const uint32 COUNT = 100;
for (uint32 i=0; i<COUNT; i++)
{
Hashtable<int32, int32> table;
for (uint32 j=0; j<COUNT; j++) table.Put(j, j+COUNT);
uint32 numPairsFound = 0;
int32 prevKey = backwards ? (int32)COUNT : -1;
LogTime(MUSCLE_LOG_DEBUG, " Beginning traversal...\n");
for(HashtableIterator<int32,int32> iter(table, backwards?HTIT_FLAG_BACKWARDS:0); iter.HasData(); iter++)
{
int32 expectedKey = (backwards?(prevKey-1):(prevKey+1));
int32 gotKey = iter.GetKey();
int32 gotValue = iter.GetValue();
LogTime(MUSCLE_LOG_TRACE, " Iter returned " INT32_FORMAT_SPEC" -> " INT32_FORMAT_SPEC"\n", iter.GetKey(), iter.GetValue());
if (gotKey != expectedKey)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Expected key=" INT32_FORMAT_SPEC", got key=" INT32_FORMAT_SPEC" (value=" UINT32_FORMAT_SPEC")\n", expectedKey, gotKey, gotValue);
ExitWithoutCleanup(10);
}
if ((gotKey%(i+1))==0) {LogTime(MUSCLE_LOG_TRACE, " -> Deleting key=" INT32_FORMAT_SPEC"\n", gotKey); table.Remove(gotKey);}
numPairsFound++;
prevKey = gotKey;
}
if (numPairsFound != COUNT)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Expected to iterate across " UINT32_FORMAT_SPEC" pairs, only saw " UINT32_FORMAT_SPEC"!\n", COUNT, numPairsFound);
ExitWithoutCleanup(10);
}
}
}
PyCodeObject *CompilePython (const std::string &name) {
Python::reseterrors();
PyCodeObject * retval = compiled_python.Get (name);
Python::reseterrors();
if (retval) {
return retval;
}
char * str = LoadString (name.c_str());
if (str) {
fprintf(stdout,"Compiling python module %s\n",name.c_str());
std::string compiling_name = getCompilingName(name).c_str();
char * temp = strdup(compiling_name.c_str());
retval = (PyCodeObject *) Py_CompileString (str,temp,Py_file_input);
if (retval) {
compiled_python.Put(name,retval);
}
free (temp);
free (str);
}
return retval;
}
// This program exercises the Hashtable class.
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
Message temp; if (ParseArgs(argc, argv, temp) == B_NO_ERROR) HandleStandardDaemonArgs(temp);
if (temp.HasName("inter")) return DoInteractiveTest();
// Make sure that setting equal to an empty Hashtable clears the buffer (FogBugz #10274)
{
Hashtable<String,String> table;
for (int32 i=0; i<1000; i++) table.Put(String("xxx%1").Arg(i), "foo");
printf("After population of " UINT32_FORMAT_SPEC " items, table size is " UINT32_FORMAT_SPEC "\n", table.GetNumItems(), table.GetNumAllocatedItemSlots());
if (table.ShrinkToFit() == B_NO_ERROR) printf("After shrink-to-fit, table allocation is " UINT32_FORMAT_SPEC " for " UINT32_FORMAT_SPEC " items\n", table.GetNumAllocatedItemSlots(), table.GetNumItems());
else printf("Shrink-to-fit failed!?\n");
printf("Before copy-from-empty, table allocation is " UINT32_FORMAT_SPEC "\n", table.GetNumAllocatedItemSlots());
table = GetDefaultObjectForType< Hashtable<String,String> > ();
printf(" After copy-from-empty, table allocation is " UINT32_FORMAT_SPEC "\n", table.GetNumAllocatedItemSlots());
}
// Test C++11 move semantics to make sure they aren't stealing
{
String key = "key";
String value = "value";
Hashtable<String,String> table;
table.Put(key, value);
if (key != "key") {printf("ERROR, Hashtable stole my key!\n"); exit(10);}
if (value != "value") {printf("ERROR, Hashtable stole my value!\n"); exit(10);}
}
// Test muscleSwap()
TestMuscleSwap<Hashtable<String,String> >("Hashtable");
TestMuscleSwap<OrderedKeysHashtable<String,String> >("OrderedKeysHashtable");
TestMuscleSwap<OrderedValuesHashtable<String,String> >("OrderedValuesHashtable");
// Test iterator behaviour when deleting keys
TestIteratorSanityOnRemoval(false);
TestIteratorSanityOnRemoval(true);
{
LogTime(MUSCLE_LOG_INFO, "Testing a keys-only Hashtable value...\n");
Hashtable<int, Void> keysOnly;
printf("sizeof(keysOnly)=%u\n", (unsigned int) sizeof(keysOnly));
keysOnly.PutWithDefault(1);
keysOnly.PutWithDefault(2);
keysOnly.PutWithDefault(5);
keysOnly.PutWithDefault(10);
for (HashtableIterator<int, Void> iter(keysOnly); iter.HasData(); iter++) printf("key=%i\n", iter.GetKey());
}
{
LogTime(MUSCLE_LOG_INFO, "Testing Tuple as a Hashtable key...\n");
// A quick test of the Tuple class as a Hashtable key
typedef Tuple<2,int> MyType;
Hashtable<MyType, int> tupleTable;
MyType a; a[0] = 5; a[1] = 6;
MyType b; b[0] = 7; b[1] = 8;
tupleTable.Put(a, 1);
tupleTable.Put(b, 2);
for (HashtableIterator<MyType, int> iter(tupleTable); iter.HasData(); iter++)
{
const MyType & key = iter.GetKey();
printf("key=%i,%i val=%i\n", key[0], key[1], iter.GetValue());
}
int * ra = tupleTable.Get(a);
int * rb = tupleTable.Get(b);
printf("tuple: ra=[%i] rb=[%i]\n", ra?*ra:666, rb?*rb:666);
}
{
LogTime(MUSCLE_LOG_INFO, "Testing Rect as a Hashtable key...\n");
// A quick test of the Tuple class as a Hashtable key
Hashtable<Rect, int> tupleTable;
Rect a(1,2,3,4);
Rect b(5,6,7,8);
tupleTable.Put(a, 1);
tupleTable.Put(b, 2);
for (HashtableIterator<Rect, int> iter(tupleTable); iter.HasData(); iter++)
{
const Rect & key = iter.GetKey();
printf("key=%f,%f,%f,%f val=%i\n", key.left(), key.top(), key.right(), key.bottom(), iter.GetValue());
}
int * ra = tupleTable.Get(a);
int * rb = tupleTable.Get(b);
printf("Rect: ra=[%p] rb=[%p]\n", ra, rb);
}
{
LogTime(MUSCLE_LOG_INFO, "Testing Point as a Hashtable key...\n");
// A quick test of the Tuple class as a Hashtable key
Hashtable<Point, int> tupleTable;
Point a(9,10);
Point b(-11,-12);
tupleTable.Put(a, 1);
tupleTable.Put(b, 2);
for (HashtableIterator<Point, int> iter(tupleTable); iter.HasData(); iter++)
{
const Point & key = iter.GetKey();
printf("key=%f,%f val=%i\n", key.x(), key.y(), iter.GetValue());
}
int * ra = tupleTable.Get(a);
int * rb = tupleTable.Get(b);
printf("Point: ra=[%p] rb=[%p]\n", ra, rb);
}
{
LogTime(MUSCLE_LOG_INFO, "Preparing large table for sort...\n");
const uint32 numItems = 100000;
Hashtable<int, Void> table; (void) table.EnsureSize(100000);
for (uint32 i=0; i<numItems; i++) table.PutWithDefault((int)rand());
uint32 actualNumItems = table.GetNumItems(); // may be smaller than numItems, due to duplicate values!
(void) table.CountAverageLookupComparisons(true);
LogTime(MUSCLE_LOG_INFO, "Sorting...\n");
uint64 start = GetRunTime64();
table.SortByKey();
uint64 end = GetRunTime64();
LogTime(MUSCLE_LOG_INFO, "Time to sort " UINT32_FORMAT_SPEC" items: " UINT64_FORMAT_SPEC "ms\n", numItems, (end-start)/1000);
// Check the resulting sorted table for correctness in both directions
CheckTable(table, actualNumItems, false);
CheckTable(table, actualNumItems, true);
}
// Test the sort algorithm for efficiency and correctness
{
LogTime(MUSCLE_LOG_INFO, "Preparing large table for sort...\n");
const uint32 numItems = 100000;
Hashtable<int, Void> table;
for (uint32 i=0; i<numItems; i++) table.PutWithDefault((int)rand());
uint32 actualNumItems = table.GetNumItems(); // may be smaller than numItems, due to duplicate values!
LogTime(MUSCLE_LOG_INFO, "Sorting...\n");
uint64 start = GetRunTime64();
table.SortByKey();
uint64 end = GetRunTime64();
LogTime(MUSCLE_LOG_INFO, "Time to sort " UINT32_FORMAT_SPEC" items: " UINT64_FORMAT_SPEC "ms\n", numItems, (end-start)/1000);
// Check the resulting sorted table for correctness in both directions
CheckTable(table, actualNumItems, false);
CheckTable(table, actualNumItems, true);
}
Hashtable<String, String> table;
{
table.Put("Hello", "World");
table.Put("Peanut Butter", "Jelly");
table.Put("Ham", "Eggs");
table.Put("Pork", "Beans");
table.Put("Slash", "Dot");
table.Put("Data", "Mining");
table.Put("TestDouble", "Play");
table.Put("Abbot", "Costello");
table.Put("Laurel", "Hardy");
table.Put("Thick", "Thin");
table.Put("Butter", "Parkay");
table.Put("Total", "Carnage");
table.Put("Summer", "Time");
table.Put("Terrible", "Twos");
table.CountAverageLookupComparisons(true);
printf("table[\"Summer\"] = [%s]\n", table["Summer"]());
printf("table[\"Butter\"] = [%s]\n", table["Butter"]());
printf("table[\"Total\"] = [%s]\n", table["Total"]());
printf("table[\"Winter\"] = [%s] (should be blank!)\n", table["Winter"]());
if (table.GetNumItems() != 14)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "String table has %i entries in it, expected 14!\n", table.GetNumItems());
ExitWithoutCleanup(10);
}
{
LogTime(MUSCLE_LOG_INFO, "Test partial backwards iteration\n");
for (HashtableIterator<String, String> iter(table, "Slash", HTIT_FLAG_BACKWARDS); iter.HasData(); iter++) LogTime(MUSCLE_LOG_INFO,"[%s] <-> [%s]\n", iter.GetKey()(), iter.GetValue()());
}
String lookup;
if (table.Get(String("Hello"), lookup) == B_NO_ERROR) LogTime(MUSCLE_LOG_DEBUG, "Hello -> %s\n", lookup());
else bomb("Lookup 1 failed.\n");
if (table.Get(String("Peanut Butter"), lookup) == B_NO_ERROR) LogTime(MUSCLE_LOG_DEBUG, "Peanut Butter -> %s\n", lookup());
else bomb("Lookup 2 failed.\n");
LogTime(MUSCLE_LOG_INFO, "Testing delete-as-you-go traveral\n");
for (HashtableIterator<String, String> st(table); st.HasData(); st++)
{
LogTime(MUSCLE_LOG_INFO, "t3 = %s -> %s (tableSize=" UINT32_FORMAT_SPEC")\n", st.GetKey()(), st.GetValue()(), table.GetNumItems());
if (table.Remove(st.GetKey()) != B_NO_ERROR) bomb("Could not remove string!\n");
#if 0
for (HashtableIterator<String,String> st2(table); st2.HasData(); st2++) printf(" tx = %s -> %s\n", nextKeyString(), nextValueString());
#endif
}
Hashtable<uint32, const char *> sillyTable;
sillyTable.Put(15, "Fifteen");
sillyTable.Put(100, "One Hundred");
sillyTable.Put(150, "One Hundred and Fifty");
sillyTable.Put(200, "Two Hundred");
sillyTable.Put((uint32)-1, "2^32 - 1!");
if (sillyTable.ContainsKey((uint32)-1) == false) bomb("large value failed!");
const char * temp = NULL;
sillyTable.Get(100, temp);
sillyTable.Get(101, temp); // will fail
printf("100 -> %s\n",temp);
printf("Entries in sillyTable:\n");
for (HashtableIterator<uint32, const char *> it(sillyTable); it.HasData(); it++)
{
const char * nextValue = NULL;
status_t ret = sillyTable.Get(it.GetKey(), nextValue);
printf("%i %s: " UINT32_FORMAT_SPEC" -> %s\n", it.HasData(), (ret == B_NO_ERROR) ? "OK" : "ERROR", it.GetKey(), nextValue);
}
}
table.Clear();
{
const uint32 NUM_ITEMS = 1000000;
const uint32 NUM_RUNS = 3;
Hashtable<int, int> testCopy;
Hashtable<String, double> tallies;
for (uint32 t=0; t<NUM_RUNS; t++)
{
Hashtable<int, int> table; (void) table.EnsureSize(NUM_ITEMS);
printf("SORT SPEED TEST ROUND " UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC":\n", t+1, NUM_RUNS);
uint64 startTime = GetRunTime64();
srand(0); for (uint32 i=0; i<NUM_ITEMS; i++) table.Put(rand(), rand()); // we want this to be repeatable, hence srand(0)
AddTally(tallies, "place", startTime, NUM_ITEMS);
startTime = GetRunTime64();
table.SortByValue();
AddTally(tallies, "sort", startTime, NUM_ITEMS);
startTime = GetRunTime64();
testCopy = table; // just to make sure copying a table works
AddTally(tallies, "copy", startTime, NUM_ITEMS);
startTime = GetRunTime64();
if (testCopy != table) bomb("Copy was not the same!");
AddTally(tallies, "compare", startTime, NUM_ITEMS);
startTime = GetRunTime64();
if (testCopy.IsEqualTo(table, true) == false) bomb("Copy was not the same, considering ordering!");
AddTally(tallies, "o-compare", startTime, NUM_ITEMS);
startTime = GetRunTime64();
table.Clear();
AddTally(tallies, "clear", startTime, NUM_ITEMS);
}
printf("GRAND AVERAGES OVER ALL " UINT32_FORMAT_SPEC" RUNS ARE:\n", NUM_RUNS);
for (HashtableIterator<String, double> iter(tallies); iter.HasData(); iter++) printf(" %f items/second for %s\n", iter.GetValue()/NUM_RUNS, iter.GetKey()());
}
// Now some timing test with String keys and values, for testing of the C++11 move semantics
PrintAndClearStringCopyCounts("Before String Sort test");
{
const uint32 NUM_ITEMS = 1000000;
const uint32 NUM_RUNS = 3;
Hashtable<String, String> testCopy;
Hashtable<String, double> tallies;
for (uint32 t=0; t<NUM_RUNS; t++)
{
Hashtable<String, String> table; (void) table.EnsureSize(NUM_ITEMS);
printf("STRING SORT SPEED TEST ROUND " UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC":\n", t+1, NUM_RUNS);
uint64 startTime = GetRunTime64();
srand(0); for (uint32 i=0; i<NUM_ITEMS; i++) table.Put(String("%1").Arg(rand()), String("%1").Arg(rand())); // we want this to be repeatable, hence srand(0)
AddTally(tallies, "place", startTime, NUM_ITEMS);
startTime = GetRunTime64();
table.SortByValue();
AddTally(tallies, "sort", startTime, NUM_ITEMS);
startTime = GetRunTime64();
testCopy = table; // just to make sure copying a table works
AddTally(tallies, "copy", startTime, NUM_ITEMS);
startTime = GetRunTime64();
if (testCopy != table) bomb("Copy was not the same!");
AddTally(tallies, "compare", startTime, NUM_ITEMS);
startTime = GetRunTime64();
if (testCopy.IsEqualTo(table, true) == false) bomb("Copy was not the same, considering ordering!");
AddTally(tallies, "o-compare", startTime, NUM_ITEMS);
startTime = GetRunTime64();
table.Clear();
AddTally(tallies, "clear", startTime, NUM_ITEMS);
}
printf("STRING GRAND AVERAGES OVER ALL " UINT32_FORMAT_SPEC" RUNS ARE:\n", NUM_RUNS);
for (HashtableIterator<String, double> iter(tallies); iter.HasData(); iter++) printf(" STRING %f items/second for %s\n", iter.GetValue()/NUM_RUNS, iter.GetKey()());
}
PrintAndClearStringCopyCounts("After String Sort test");
printf("Begin torture test!\n");
_state = 4;
{
bool fastClear = false;
Hashtable<String, uint32> t;
for (uint32 numEntries=1; numEntries < 1000; numEntries++)
{
uint32 half = numEntries/2;
bool ok = true;
printf(UINT32_FORMAT_SPEC" ", numEntries); fflush(stdout);
_state = 5;
{
for(uint32 i=0; i<numEntries; i++)
{
char temp[300];
muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
if (t.Put(temp, i) != B_NO_ERROR)
{
printf("Whoops, (hopefully simulated) memory failure! (Put(" UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC") failed) ... recovering\n", i, numEntries);
ok = false;
numEntries--; // let's do this one over
half = i; // so the remove code won't freak out about not everything being there
break;
}
}
}
if (ok)
{
//printf("Checking that all entries are still there...\n");
_state = 6;
{
if (t.GetNumItems() != numEntries) bomb("ERROR, WRONG SIZE %i vs %i!\n", t.GetNumItems(), numEntries);
for (int32 i=((int32)numEntries)-1; i>=0; i--)
{
char temp[300];
muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
uint32 tv = 0;
if (t.Get(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING KEY [%s]\n", temp);
if (tv != ((uint32)i)) bomb("ERROR, WRONG KEY %s != " UINT32_FORMAT_SPEC"!\n", temp, tv);
}
}
//printf("Iterating through table...\n");
_state = 7;
{
uint32 count = 0;
for (HashtableIterator<String, uint32> iter(t); iter.HasData(); iter++)
{
char buf[300];
muscleSprintf(buf, UINT32_FORMAT_SPEC, count);
if (iter.GetKey() != buf) bomb("ERROR: iteration was wrong, item " UINT32_FORMAT_SPEC" was [%s] not [%s]!\n", count, iter.GetKey()(), buf);
if (iter.GetValue() != count) bomb("ERROR: iteration value was wrong, item " UINT32_FORMAT_SPEC" was " UINT32_FORMAT_SPEC" not " UINT32_FORMAT_SPEC"!i!\n", count, iter.GetValue(), count);
count++;
}
}
//printf("Removing the second half of the entries...\n");
_state = 8;
{
for (uint32 i=half; i<numEntries; i++)
{
char temp[64];
muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
uint32 tv = 0; // just to shut the compiler up
if (t.Remove(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING REMOVE KEY [%s] A\n", temp);
if (tv != i) bomb("ERROR, REMOVE WAS WRONG VALUE " UINT32_FORMAT_SPEC"\n", tv);
}
}
//printf("Iterating over only first half...\n");
_state = 9;
{
uint32 sum = 0;
for (uint32 i=0; i<half; i++) sum += i;
uint32 count = 0, checkSum = 0;
for (HashtableIterator<String, uint32> iter(t); iter.HasData(); iter++)
{
count++;
checkSum += iter.GetValue();
}
if (count != half) bomb("ERROR: Count mismatch " UINT32_FORMAT_SPEC" vs " UINT32_FORMAT_SPEC"!\n", count, numEntries);
if (checkSum != sum) bomb("ERROR: Sum mismatch " UINT32_FORMAT_SPEC" vs " UINT32_FORMAT_SPEC"!\n", sum, checkSum);
}
}
//printf("Clearing Table (%s)\n", fastClear ? "Quickly" : "Slowly");
_state = 10;
if (fastClear) t.Clear();
else
{
for (uint32 i=0; i<half; i++)
{
char temp[300];
muscleSprintf(temp, UINT32_FORMAT_SPEC, i);
uint32 tv = 0; // just to shut the compiler up
if (t.Remove(temp, tv) != B_NO_ERROR) bomb("ERROR, MISSING REMOVE KEY [%s] (" UINT32_FORMAT_SPEC"/" UINT32_FORMAT_SPEC") B\n", temp, i, half);
if (tv != i) bomb("ERROR, REMOVE WAS WRONG VALUE " UINT32_FORMAT_SPEC"\n", tv);
}
}
HashtableIterator<String, uint32> paranoia(t);
if (paranoia.HasData()) bomb("ERROR, ITERATOR CONTAINED ITEMS AFTER CLEAR!\n");
if (t.HasItems()) bomb("ERROR, SIZE WAS NON-ZERO (" UINT32_FORMAT_SPEC") AFTER CLEAR!\n", t.GetNumItems());
fastClear = !fastClear;
}
printf("Finished torture test successfully!\n");
}
#ifdef MUSCLE_AVOID_THREAD_SAFE_HASHTABLE_ITERATORS
printf("Thread-safe hashtable iterators were disabled at compile time, so I won't test them!\n");
return 0;
#else
return DoThreadTest();
#endif
}
// This program is equivalent to the portableplaintext client, except
// that we communicate with a child process instead of a socket.
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
if (argc < 3) PrintUsageAndExit();
const uint32 numProcesses = atol(argv[1]);
if (numProcesses == 0) PrintUsageAndExit();
const char * cmd = argv[2];
Hashtable<String,String> testEnvVars;
(void) testEnvVars.Put("Peanut Butter", "Jelly");
(void) testEnvVars.Put("Jelly", "Peanut Butter");
(void) testEnvVars.Put("Oranges", "Grapes");
Queue<DataIORef> refs;
for (uint32 i=0; i<numProcesses; i++)
{
ChildProcessDataIO * dio = new ChildProcessDataIO(false);
refs.AddTail(DataIORef(dio));
printf("About To Launch child process #" UINT32_FORMAT_SPEC ": [%s]\n", i+1, cmd); fflush(stdout);
ConstSocketRef s = (dio->LaunchChildProcess(argc-2, ((const char **) argv)+2, ChildProcessLaunchFlags(MUSCLE_DEFAULT_CHILD_PROCESS_LAUNCH_FLAGS), NULL, &testEnvVars) == B_NO_ERROR) ? dio->GetReadSelectSocket() : ConstSocketRef();
printf("Finished Launching child process #" UINT32_FORMAT_SPEC ": [%s]\n", i+1, cmd); fflush(stdout);
if (s() == NULL)
{
LogTime(MUSCLE_LOG_CRITICALERROR, "Error launching child process #" UINT32_FORMAT_SPEC " [%s]!\n", i+1, cmd);
return 10;
}
}
StdinDataIO stdinIO(false);
PlainTextMessageIOGateway stdinGateway;
QueueGatewayMessageReceiver stdinInputQueue;
stdinGateway.SetDataIO(DataIORef(&stdinIO, false));
SocketMultiplexer multiplexer;
for (uint32 i=0; i<refs.GetNumItems(); i++)
{
printf("------------ CHILD PROCESS #" UINT32_FORMAT_SPEC " ------------------\n", i+1);
PlainTextMessageIOGateway ioGateway;
ioGateway.SetDataIO(refs[i]);
ConstSocketRef readSock = refs[i]()->GetReadSelectSocket();
QueueGatewayMessageReceiver ioInputQueue;
while(1)
{
int readFD = readSock.GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(readFD);
const int writeFD = ioGateway.HasBytesToOutput() ? refs[i]()->GetWriteSelectSocket().GetFileDescriptor() : -1;
if (writeFD >= 0) multiplexer.RegisterSocketForWriteReady(writeFD);
const int stdinFD = stdinIO.GetReadSelectSocket().GetFileDescriptor();
multiplexer.RegisterSocketForReadReady(stdinFD);
if (multiplexer.WaitForEvents() < 0) printf("testchildprocess: WaitForEvents() failed!\n");
// First, deliver any lines of text from stdin to the child process
if ((multiplexer.IsSocketReadyForRead(stdinFD))&&(stdinGateway.DoInput(ioGateway) < 0))
{
printf("Error reading from stdin, aborting!\n");
break;
}
const bool reading = multiplexer.IsSocketReadyForRead(readFD);
const bool writing = ((writeFD >= 0)&&(multiplexer.IsSocketReadyForWrite(writeFD)));
const bool writeError = ((writing)&&(ioGateway.DoOutput() < 0));
const bool readError = ((reading)&&(ioGateway.DoInput(ioInputQueue) < 0));
if ((readError)||(writeError))
{
printf("Connection closed, exiting.\n");
break;
}
MessageRef incoming;
while(ioInputQueue.RemoveHead(incoming) == B_NO_ERROR)
{
printf("Heard message from server:-----------------------------------\n");
const char * inStr;
for (int i=0; (incoming()->FindString(PR_NAME_TEXT_LINE, i, &inStr) == B_NO_ERROR); i++) printf("Line %i: [%s]\n", i, inStr);
printf("-------------------------------------------------------------\n");
}
if ((reading == false)&&(writing == false)) break;
multiplexer.RegisterSocketForReadReady(readFD);
if (ioGateway.HasBytesToOutput()) multiplexer.RegisterSocketForWriteReady(writeFD);
}
if (ioGateway.HasBytesToOutput())
{
printf("Waiting for all pending messages to be sent...\n");
while((ioGateway.HasBytesToOutput())&&(ioGateway.DoOutput() >= 0)) {printf ("."); fflush(stdout);}
}
}
printf("\n\nBye!\n");
return 0;
}
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
PrintExampleDescription();
Hashtable<String, int> table;
// If we know up-front a limit on the number of items we are likely to place
// into the table, we can reserve that many slots in advance, and thereby
// avoid any chance of the Hashtable having to reallocate its internal array
// while we are adding items to it.
//
// That avoids some inefficiency, and it also means we don't have
// to worry about out-of-memory errors, or the memory-locations of key or
// value-items changing, while populating the table.
if (table.EnsureSize(20) != B_NO_ERROR) WARN_OUT_OF_MEMORY;
// Put some initial data into the table
table.Put("One", 1);
table.Put("Two", 2);
// table.GetWithDefault() returns a reference to the value of the specified
// key, or a reference to a default-constructed value otherwise.
const int & oneRef = table.GetWithDefault("One");
const int & twoRef = table.GetWithDefault("Two");
const int & threeRef = table.GetWithDefault("Three");
printf("A: OneRef=%i twoRef=%i threeRef=%i\n", oneRef, twoRef, threeRef);
printf("\n");
// The [] operator is a synonym for GetWithDefault()
printf("B: table[\"One\"]=%i table[\"Two\"]=%i table[\"Three\"]=%i\n", table["One"], table["Two"], table["Three"]);
printf("\n");
// GetOrPut() returns a pointer to the value of the given key, if the key is present
// If the key isn't present, it places a key/value pair into the Hashtable and returns
// a pointer to the (default-constructed) placed value. This is very useful when
// demand-allocating records.
int * pEight = table.GetOrPut("Eight");
printf("C: table.GetOrPut(\"Eight\") returned %p\n", pEight);
if (pEight) *pEight = 8;
else WARN_OUT_OF_MEMORY; // GetOrPut() returns NULL only on memory-exhaustion
printf("\n");
// The next time we call GetOrPut() we'll get a pointer to the existing value
pEight = table.GetOrPut("Eight");
printf("C: Second call to table.GetOrPut(\"Eight\") returned %p (aka %i)\n", pEight, pEight?*pEight:666);
printf("\n");
// We can also call GetOrPut() with a suggested default-value which will be
// placed into the key/value pair if the supplied key isn't already present.
int * pNine = table.GetOrPut("Nine", 9);
printf("C: table.GetOrPut(\"Nine\", 9) returned %p (aka %i)\n", pNine, pNine?*pNine:666);
printf("\n");
// PutAndGet() is similar to GetOrPut() except it *always* places a value.
// (if the key already existed in the table, its value will be overwritten)
int * pTen = table.PutAndGet("Ten", 10);
printf("D: table.PutAndGet(\"Ten\", 10) returned %p (aka %i)\n", pTen, pTen?*pTen:666);
// Demonstrate PutAndGet()'s overwrite of the previous value
pTen = table.PutAndGet("Ten", 11);
printf("E: table.PutAndGet(\"Ten\", 11) returned %p (aka %i)\n", pTen, pTen?*pTen:666);
// If you want a Hashtable with keys only and don't need values at all
// (similar to e.g. a std::unordered_set<>), a good way to get that is
// to use the Void class as your value-type. A Void object is just a
// placeholder that contains no data.
Hashtable<String, Void> keysOnlyTable;
(void) keysOnlyTable.PutWithDefault("Blue");
(void) keysOnlyTable.PutWithDefault("Red");
(void) keysOnlyTable.PutWithDefault("Green");
printf("\n");
return 0;
}
void StarSystem::AddStarsystemToUniverse( const string &mname )
{
star_system_table.Put( mname, this );
}
int main()
{
ScreenManager::GetInstance().SetText("Testing");
ScreenManager::GetInstance().DrawText();
Material* quartz = new Material((char*)"Quartz", false, false);
Material* granite = new Material((char*)"Granite", false, false);
Clock* clock = new Clock();
World* world = new World();
SolarSystem* solar = new SolarSystem();
// name, mass, diameter (mi), radius (mi), surf gravity (m/s2)
solar->Add(new Star((char*)"Sun", MASS(1.989,30), 864337.3, 432169, 274));
solar->Add(new Planet((char*)"Mercury", MASS(3.285,23), 3032, 1516, 3.7));
solar->Add(new Planet((char*)"Venus", MASS(4.867,24), 7520.8, 3760, 8.87));
solar->Add(new Planet((char*)"Earth", MASS(5.972,24), 7917.5, 3959, 9.807));
solar->Add(new Planet((char*)"Mars", MASS(6.39,23), 4212, 2106, 3.711));
solar->Add(new Planet((char*)"Jupiter", MASS(1.898,27), 86881.4, 43441, 24.79));
solar->Add(new Planet((char*)"Saturn", MASS(5.683,26), 72367.4, 36184, 10.44));
solar->Add(new Planet((char*)"Uranus", MASS(8.681,25), 31518, 15759, 8.87));
solar->Add(new Planet((char*)"Neptune", MASS(1.024,26), 30599, 15299, 11.15));
// name mass diameter (mi)radius (mi)surf gravity (m/s2)
Planet* earth = new Planet( (char*)"Earth", MASS(5.972,24), 7917.5, 3959, 9.807);
Satellite* moon = new Satellite( (char*)"Moon", MASS(7.347,22), 2159, 1079, 1.62);
earth->Add(moon);
solar->Add(earth);
sf::RenderWindow window(sf::VideoMode(WIDTH, HEIGHT), "Game");
window.setFramerateLimit(60);
srand(time(0));
sf::CircleShape shape(100.f);
shape.setFillColor(sf::Color::Green);
Hashtable hash;
hash.Put("Test","Test2");
int one = 1;
hash.Put("one", &one);
printf("Hashtable %s %d",(char *)hash.Get("Test"), *(int *)hash.Get("one"));
while (window.isOpen())
{
sf::Event event;
while (window.pollEvent(event))
{
if (event.type == sf::Event::Closed)
window.close();
}
clock->Update();
window.clear();
window.draw(shape);
window.display();
}
Engine egnine;
return 0;
}
/* This little program demonstrates the semantics of the keys used in a Hashtable */
int main(int argc, char ** argv)
{
CompleteSetupSystem css;
PrintExampleDescription();
// In order to use a type as a Key in a Hashtable, that type must have
// two properties: There must be a way to compute a hash-code for any
// give Key object, and it must be possible to compare two Key objects
// for equality (using the == operator).
//
// If you want to call SortByKey() or use the type as a key in an
// OrderedKeysHashtable, the < operator must also be defined for the type.
// For primitive/POD key types, the Hashtable class uses SFINAE
// magic so that Hashtables with those keys will automatically "just work".
// For example:
Hashtable<int, String> tableWithIntKeys; // works!
Hashtable<uint16, String> tableWithUint16Keys; // works!
Hashtable<uint32, String> tableWithUint32Keys; // works!
Hashtable<int32, String> tableWithInt32Keys; // works!
Hashtable<char, String> tableWithCharKeys; // works!
Hashtable<float, String> tableWithFloatKeys; // works! (but probably a bad idea!)
// When using a "Proper class" as a Key type, you'll want to make
// sure it has a working == operator and that it has a method
// like this one defined:
//
// uint32 HashCode() const;
//
// This method should return a 32-bit value based on the object's
// current state; that value will be used to place the key/value
// pair within the Hashtable's array.
Hashtable<MyKeyClass, int> myTable;
(void) myTable.Put(MyKeyClass(12, 23), 0);
(void) myTable.Put(MyKeyClass(21, 22), 5);
(void) myTable.Put(MyKeyClass(37, 19), 6);
printf("myTable's contents are:\n");
for (HashtableIterator<MyKeyClass, int> iter(myTable); iter.HasData(); iter++)
{
printf(" [%s] -> %i\n", iter.GetKey().ToString()(), iter.GetValue());
}
printf("\n");
// Test retrieving a value using a MyKeyClass object as the key
int retVal;
if (myTable.Get(MyKeyClass(21, 22), retVal) == B_NO_ERROR)
{
printf("myTable.Get(MyKeyClass(21, 22) retrieved a key with value %i\n", retVal);
}
else printf("myTable.Get(MyKeyClass(21, 22) failed!\n");
// You can even use pointers-to-objects as your keys as long as
// the pointed-to-objects can be used as keys. The pointer-keys
// will generally work the same as the value-keys, but note that
// you are responsible for making sure the pointers remain valid
// for the lifetime of the Hashtable!
String s1 = "One";
String s2 = "Two";
String s3 = "Three";
Hashtable<String *, int> ptrTable;
ptrTable.Put(&s1, 1);
ptrTable.Put(&s2, 2);
ptrTable.Put(&s3, 3);
printf("\n");
printf("ptrTable's contents are:\n");
for (HashtableIterator<String *, int> iter(ptrTable); iter.HasData(); iter++)
{
printf(" %s -> %i\n", iter.GetKey()->Cstr(), iter.GetValue());
}
printf("\n");
// Refs can also be used as keys, if, you're in to that sort of thing.
// Here's a Hashtable with ConstSocketRefs as keys!
Hashtable<ConstSocketRef, Void> sockTable;
for (int i=0; i<10; i++) sockTable.PutWithDefault(CreateUDPSocket());
printf("sockTable's contents are:\n");
for (HashtableIterator<ConstSocketRef, Void> iter(sockTable); iter.HasData(); iter++)
{
const Socket * s = iter.GetKey()();
printf(" socket descriptor #%i\n", s ? s->GetFileDescriptor() : -1);
}
printf("\n");
return 0;
}
