PyLookupResolver Class Reference

#include "PyLookupDump.h"

Collaboration diagram for PyLookupResolver:

Public Member Functions
bool	LoadIntFile (const char *file)
bool	LoadStringFile (const char *file)
const char *	LookupInt (int64 value) const
const char *	LookupString (const char *value) const

Protected Attributes
std::map< uint32, std::string >	m_intRecords
std::map< std::string, std::string >	m_strRecords
std::string	m_dateBuffer

Detailed Description

Definition at line 31 of file PyLookupDump.h.

Member Function Documentation

bool PyLookupResolver::LoadIntFile

(

const char *

file

)

Definition at line 65 of file PyLookupDump.cpp.

References m_intRecords, and MIN_RESOLVABLE_INT.

Referenced by main().

                                                   {
    FILE *f = fopen(file, "r");
    if(f == NULL)
        return false;
    char *buf = new char[10240];
    while(fgets(buf, 10240, f)) {
        //kill empty lines
        if(*buf == '\n' || *buf == '\r' || *buf == '\0' || *buf == '|')
            continue;
        //find the first delimiter
        char *p = buf;
        while(*p != '|' && *p != '\0' && *p != '\n' && *p != '\r') {
            p++;
        }
        if(*p == '\0' || *p == '\n' || *p == '\r')
            continue;   //didnt find it
        *p = '\0';
        p++;
        if(*p == '\n' || *p == '\r' || *p == '\0')
            continue;   //skip empty values
        //strip newline
        char *e = p;
        while(*e != '\0' && *e != '\n' && *e != '\r') {
            e++;
        }
        *e = '\0';
        uint32 v = strtoul(buf, NULL, 10);
        if(v < MIN_RESOLVABLE_INT)
            continue;
        m_intRecords[v] = p;
    }
    delete[] buf;
    fclose(f);
    return true;
}

Here is the caller graph for this function:

bool PyLookupResolver::LoadStringFile

(

const char *

file

)

Definition at line 101 of file PyLookupDump.cpp.

References m_strRecords.

Referenced by main().

                                                      {
    FILE *f = fopen(file, "r");
    if(f == NULL)
        return false;
    char *buf = new char[10240];
    while(fgets(buf, 10240, f)) {
        //kill empty lines
        if(*buf == '\n' || *buf == '\r' || *buf == '\0' || *buf == '|')
            continue;
        //find the first delimiter
        char *p = buf;
        while(*p != '|' && *p != '\0' && *p != '\n' && *p != '\r') {
            p++;
        }
        if(*p == '\0' || *p == '\n' || *p == '\r')
            continue;   //didnt find it
        *p = '\0';
        p++;
        if(*p == '\n' || *p == '\r' || *p == '\0')
            continue;   //skip empty values
        //strip newline
        char *e = p;
        while(*e != '\0' && *e != '\n' && *e != '\r') {
            e++;
        }
        *e = '\0';

        m_strRecords[buf] = p;
    }
    delete[] buf;
    fclose(f);
    return true;
}

Here is the caller graph for this function:

const char * PyLookupResolver::LookupInt

(

int64

value

)

const

Definition at line 135 of file PyLookupDump.cpp.

References m_dateBuffer, m_intRecords, MIN_RESOLVABLE_INT, and Win32TimeToString().

Referenced by PyLookupDumpVisitor::VisitInteger().

                                                         {
    //hackish check for win32 time looking things...
    if(value > 127900000000000000LL && value < 130000000000000000LL) {
        //this is not thread safe or reentrant..
        m_dateBuffer = Win32TimeToString(value);
        return(m_dateBuffer.c_str());
    }

    if(value > 0xFFFFFFFFLL || value < MIN_RESOLVABLE_INT)
        return NULL;
    std::map<uint32, std::string>::const_iterator res;
    res = m_intRecords.find(uint32(value));
    if(res == m_intRecords.end())
        return NULL;
    return(res->second.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

const char * PyLookupResolver::LookupString

(

const char *

value

)

const

Definition at line 152 of file PyLookupDump.cpp.

References m_strRecords.

Referenced by PyLookupDumpVisitor::VisitString().

                                                                  {
    if(*value == '\0')
        return NULL;
    std::map<std::string, std::string>::const_iterator res;
    res = m_strRecords.find(value);
    if(res == m_strRecords.end())
        return NULL;
    return(res->second.c_str());
}

Here is the caller graph for this function:

Member Data Documentation

std::string PyLookupResolver::m_dateBuffer

mutableprotected

Definition at line 43 of file PyLookupDump.h.

Referenced by LookupInt().

std::map<uint32, std::string> PyLookupResolver::m_intRecords

protected

Definition at line 41 of file PyLookupDump.h.

Referenced by LoadIntFile(), and LookupInt().

std::map<std::string, std::string> PyLookupResolver::m_strRecords

protected

Definition at line 42 of file PyLookupDump.h.

Referenced by LoadStringFile(), and LookupString().

---

The documentation for this class was generated from the following files:

• /backups/local/src/eve/EvEmu_Crucible/src/eve-common/python/PyLookupDump.h
• /backups/local/src/eve/EvEmu_Crucible/src/eve-common/python/PyLookupDump.cpp