Beta matching MxAtom classes (#847)

* Beta matching MxAtom classes

* Remove unused getter

* Restore operator!= for modern compilers

LEGO1/omni/src/common/mxatom.cpp

@@ -4,33 +4,38 @@
 #include "mxmisc.h"
 #include "mxomni.h"
 
+#include <assert.h>
+
 DECOMP_SIZE_ASSERT(MxAtomId, 0x04);
-DECOMP_SIZE_ASSERT(MxAtomIdCounter, 0x14);
-DECOMP_SIZE_ASSERT(MxAtomIdCounterSet, 0x10);
+DECOMP_SIZE_ASSERT(MxAtom, 0x14);
+DECOMP_SIZE_ASSERT(MxAtomSet, 0x10);
 
 // FUNCTION: LEGO1 0x100acf90
+// FUNCTION: BETA10 0x1012308b
 MxAtomId::MxAtomId(const char* p_str, LookupMode p_mode)
 {
 	if (!MxOmni::GetInstance()) {
 		return;
 	}
 
-	if (!AtomIdCounterSet()) {
+	if (!AtomSet()) {
 		return;
 	}
 
-	MxAtomIdCounter* counter = GetCounter(p_str, p_mode);
-	m_internal = counter->GetKey()->GetData();
-	counter->Inc();
+	MxAtom* atom = GetAtom(p_str, p_mode);
+	*this = atom->GetKey();
+	atom->Inc();
 }
 
 // FUNCTION: LEGO1 0x100acfd0
+// FUNCTION: BETA10 0x10123130
 MxAtomId::~MxAtomId()
 {
 	Destroy();
 }
 
 // FUNCTION: LEGO1 0x100acfe0
+// FUNCTION: BETA10 0x101231a6
 void MxAtomId::Destroy()
 {
 	if (!m_internal) {
@@ -41,34 +46,36 @@ void MxAtomId::Destroy()
 		return;
 	}
 
-	if (!AtomIdCounterSet()) {
+	if (!AtomSet()) {
 		return;
 	}
 
 #ifdef COMPAT_MODE
-	MxAtomIdCounterSet::iterator it;
+	MxAtomSet::iterator it;
 	{
-		MxAtomIdCounter idCounter(m_internal);
-		it = AtomIdCounterSet()->find(&idCounter);
+		MxAtom idAtom(m_internal);
+		it = AtomSet()->find(&idAtom);
 	}
 #else
-	MxAtomIdCounterSet::iterator it = AtomIdCounterSet()->find(&MxAtomIdCounter(m_internal));
+	MxAtomSet::iterator it = AtomSet()->find(&MxAtom(m_internal));
 #endif
+	assert(it != AtomSet()->end());
 
-	MxAtomIdCounter* counter = (MxAtomIdCounter*) (*it);
-	counter->Dec();
+	MxAtom* atom = (MxAtom*) (*it);
+	atom->Dec();
 }
 
 // FUNCTION: LEGO1 0x100ad1c0
+// FUNCTION: BETA10 0x101232b9
 MxAtomId& MxAtomId::operator=(const MxAtomId& p_atomId)
 {
 	if (m_internal) {
 		Destroy();
 	}
 
-	if (p_atomId.m_internal && MxOmni::GetInstance() && AtomIdCounterSet()) {
-		MxAtomIdCounter* counter = GetCounter(p_atomId.m_internal, e_exact);
-		counter->Inc();
+	if (p_atomId.m_internal && MxOmni::GetInstance() && AtomSet()) {
+		MxAtom* atom = GetAtom(p_atomId.m_internal, e_exact);
+		atom->Inc();
 	}
 
 	m_internal = p_atomId.m_internal;
@@ -77,36 +84,41 @@ MxAtomId& MxAtomId::operator=(const MxAtomId& p_atomId)
 }
 
 // FUNCTION: LEGO1 0x100ad210
-MxAtomIdCounter* MxAtomId::GetCounter(const char* p_str, LookupMode p_mode)
+// FUNCTION: BETA10 0x10123378
+MxAtom* MxAtomId::GetAtom(const char* p_str, LookupMode p_mode)
 {
 	MxAtomId unused;
-	MxAtomIdCounter* counter = new MxAtomIdCounter(p_str);
+	MxAtom* atom = new MxAtom(p_str);
+	assert(atom);
 
 	switch (p_mode) {
-	case e_lowerCase:
-	case e_lowerCase2:
-		counter->GetKey()->ToLowerCase();
+	case e_exact:
 		break;
 	case e_upperCase:
-		counter->GetKey()->ToUpperCase();
+		atom->GetKey().ToUpperCase();
+		break;
+	case e_lowerCase:
+	case e_lowerCase2:
+		atom->GetKey().ToLowerCase();
 		break;
 	}
 
-	MxAtomIdCounterSet::iterator it = AtomIdCounterSet()->find(counter);
-	if (it != AtomIdCounterSet()->end()) {
-		// Counter already in the set. Delete temp value and return it.
-		delete counter;
-		counter = *it;
+	MxAtomSet::iterator it = AtomSet()->find(atom);
+	if (it != AtomSet()->end()) {
+		// Atom already in the set. Delete temp value and return it.
+		delete atom;
+		atom = *it;
 	}
 	else {
-		// Counter is not in the set. Add it.
-		AtomIdCounterSet()->insert(counter);
+		// Atom is not in the set. Add it.
+		AtomSet()->insert(atom);
 	}
 
-	return counter;
+	return atom;
 }
 
 // FUNCTION: LEGO1 0x100ad7e0
+// FUNCTION: BETA10 0x100553e0
 void MxAtomId::Clear()
 {
 	// Reset but do not delete MxAtomId object.
@@ -115,13 +127,15 @@ void MxAtomId::Clear()
 }
 
 // FUNCTION: LEGO1 0x100ad7f0
-void MxAtomIdCounter::Inc()
+// FUNCTION: BETA10 0x101235d5
+void MxAtom::Inc()
 {
 	m_value++;
 }
 
 // FUNCTION: LEGO1 0x100ad800
-void MxAtomIdCounter::Dec()
+// FUNCTION: BETA10 0x1012364a
+void MxAtom::Dec()
 {
 	if (m_value) {
 		m_value--;

LEGO1/omni/src/common/mxmisc.cpp

@@ -2,6 +2,8 @@
 
 #include "mxomni.h"
 
+#include <assert.h>
+
 // FUNCTION: LEGO1 0x100acea0
 MxObjectFactory* ObjectFactory()
 {
@@ -27,9 +29,11 @@ MxTimer* Timer()
 }
 
 // FUNCTION: LEGO1 0x100acee0
-MxAtomIdCounterSet* AtomIdCounterSet()
+// FUNCTION: BETA10 0x10124e4c
+MxAtomSet* AtomSet()
 {
-	return MxOmni::GetInstance()->GetAtomIdCounterSet();
+	assert(MxOmni::GetInstance());
+	return MxOmni::GetInstance()->GetAtomSet();
 }
 
 // FUNCTION: LEGO1 0x100acef0

LEGO1/omni/src/main/mxomni.cpp

@@ -66,7 +66,7 @@ void MxOmni::Init()
 	m_eventManager = NULL;
 	m_timer = NULL;
 	m_streamer = NULL;
-	m_atomIdCounterSet = NULL;
+	m_atomSet = NULL;
 	m_timerRunning = FALSE;
 }
 
@@ -82,7 +82,7 @@ MxResult MxOmni::Create(MxOmniCreateParam& p_param)
 {
 	MxResult result = FAILURE;
 
-	if (!(m_atomIdCounterSet = new MxAtomIdCounterSet())) {
+	if (!(m_atomSet = new MxAtomSet())) {
 		goto done;
 	}
 
@@ -177,6 +177,7 @@ done:
 }
 
 // FUNCTION: LEGO1 0x100afe90
+// FUNCTION: BETA10 0x1012fe5b
 void MxOmni::Destroy()
 {
 	{
@@ -210,15 +211,15 @@ void MxOmni::Destroy()
 	delete m_tickleManager;
 
 	// There could be a tree/iterator function that does this inline
-	if (m_atomIdCounterSet) {
-		while (!m_atomIdCounterSet->empty()) {
+	if (m_atomSet) {
+		while (m_atomSet->size() != 0) {
 			// Pop each node and delete its value
-			MxAtomIdCounterSet::iterator begin = m_atomIdCounterSet->begin();
-			MxAtomIdCounter* value = *begin;
-			m_atomIdCounterSet->erase(begin);
+			MxAtomSet::iterator begin = m_atomSet->begin();
+			MxAtom* value = *begin;
+			m_atomSet->erase(begin);
 			delete value;
 		}
-		delete m_atomIdCounterSet;
+		delete m_atomSet;
 	}
 	Init();
 }