mxatom.h

Go to the documentation of this file.

#ifndef MXATOM_H
#define MXATOM_H
 
#include "mxstl/stlcompat.h"
#include "mxstring.h"
#include "mxtypes.h"
 
// [AI] MxAtom, MxAtomId and supporting structures are used for efficient string-to-identifier mapping (atomization), 
// tracking the existence and use-counts of strings for reuse across the application.
 
// Counts the number of existing MxAtomId objects based
// on the matching char* string. A <map> seems fit for purpose here:
// We have an MxString as a key and MxU16 as the value.
// And yet a <set> is the best match. The malloc in MxOmni::Create
// for the _Nil node asks for more bytes than a regular node if a <map>
// is used, but all nodes are 20 bytes wide with a <set>.
// Also: the increment/decrement methods suggest a custom type was used
// for the combined key_value_pair, which doesn't seem possible with <map>.
 
// SIZE 0x14
class MxAtom {
public:
    // always inlined
    // FUNCTION: BETA10 0x10123720
    MxAtom(const char* p_str)
    {
        m_key = p_str;
        m_value = 0;
    }
 
    void Inc();
 
    void Dec();
 
    // FUNCTION: BETA10 0x101236d0
    MxString& GetKey() { return m_key; }
 
    // SYNTHETIC: BETA10 0x10124a50
    // MxAtom::`scalar deleting destructor'
 
private:
    MxString m_key; 
    MxU16 m_value;  
};
 
struct MxAtomCompare {
    // FUNCTION: LEGO1 0x100ad120
    // FUNCTION: BETA10 0x10123980
    int operator()(MxAtom* const& p_val0, MxAtom* const& p_val1) const
    {
        return strcmp(p_val0->GetKey().GetData(), p_val1->GetKey().GetData()) > 0;
    }
};
 
class MxAtomSet : public set<MxAtom*, MxAtomCompare> {};
 
enum LookupMode {
    e_exact = 0,      
    e_lowerCase,      
    e_upperCase,      
    e_lowerCase2,     
};
 
// SIZE 0x04
class MxAtomId {
public:
    MxAtomId(const char*, LookupMode);
 
    ~MxAtomId();
 
    MxAtomId& operator=(const MxAtomId& p_atomId);
 
    // FUNCTION: BETA10 0x100178d0
    MxBool operator==(const MxAtomId& p_atomId) const { return this->m_internal == p_atomId.m_internal; }
 
#ifdef COMPAT_MODE
    // Required for modern compilers.
    // MSVC 4.20 uses a synthetic function from INCLUDE/UTILITY that inverts operator==
    MxBool operator!=(const MxAtomId& p_atomId) const { return this->m_internal != p_atomId.m_internal; }
#endif
 
    // TODO:
    // BETA10 0x1007dc20 operator==
    // BETA10 0x10096970 operator!=
 
    // FUNCTION: BETA10 0x10146dd0
    MxBool operator==(const char* p_internal) const { return p_internal && !strcmp(m_internal, p_internal); }
 
    // FUNCTION: BETA10 0x10025d40
    MxAtomId() { this->m_internal = 0; }
 
    void Clear();
 
    // FUNCTION: BETA10 0x100735e0
    const char* GetInternal() const { return m_internal; }
 
private:
    // FUNCTION: BETA10 0x101236f0
    MxAtomId& operator=(const MxString& p_key)
    {
        m_internal = p_key.GetData();
        return *this;
    }
 
    MxAtom* GetAtom(const char*, LookupMode);
 
    void Destroy();
 
    const char* m_internal; 
};
 
#endif // MXATOM_H