Horizon::Tools::MapCache Class Reference

#include <MapCache.hpp>

Collaboration diagram for Horizon::Tools::MapCache:

Public Member Functions
	MapCache ()
	~MapCache ()
void	parse_exec_args (int argc, const char *argv[])
bool	ParseInitializeResult (mcache_error_type type)
bool	ParseGRFLoadResult (std::pair< uint8_t, grf_load_result_type > result)
bool	ParseMapCacheImportResult (mcache_import_error_type type)
Horizon::Libraries::MapCache &	getLibrary ()

Private Attributes
Horizon::Libraries::MapCache	_cache

Constructor & Destructor Documentation

MapCache()

Horizon::Tools::MapCache::MapCache

(

)

{
 
}

~MapCache()

Horizon::Tools::MapCache::~MapCache

(

)

{
 
}

Member Function Documentation

getLibrary()

Horizon::Libraries::MapCache & Horizon::Tools::MapCache::getLibrary ( )

inline

{ return _cache; }

References _cache.

Referenced by main().

Here is the caller graph for this function:

parse_exec_args()

void Horizon::Tools::MapCache::parse_exec_args	(	int	argc,
		const char *	argv[]
	)

{
    for (int i = 1; i < argc; ++i) {
        std::string arg(argv[i]);
        std::vector<std::string> separated_args;
        boost::split(separated_args, arg, boost::is_any_of("="));
 
        if (separated_args.at(0).compare("--grf-config") == 0) {
            getLibrary().setGRFListPath(separated_args.at(1));
        } else if (separated_args.at(0).compare("--config") == 0) {
            getLibrary().setMapListPath(separated_args.at(1));
        } else if (separated_args.at(0).compare("--compression-level") == 0) {
            int level = atoi(separated_args.at(1).c_str());
            if (level > 9 || level < 1) {
                printf("Error: Invalid compression level set, defaulting to 6.");
            } else {
                getLibrary().setCompressionLevel(level);
            }
        } else if (separated_args.at(0).compare("--verbose") == 0) {
            getLibrary().setVerbose();
        } else if (separated_args.at(0).compare("--output") == 0) {
            getLibrary().setMapCachePath(separated_args.at(1));
        } else {
            printf("Unrecognised argument '%s'\n", separated_args.at(0).c_str());
        }
    }
}

Referenced by main().

Here is the caller graph for this function:

ParseGRFLoadResult()

bool Horizon::Tools::MapCache::ParseGRFLoadResult

(

std::pair< uint8_t, grf_load_result_type >

result

)

{
    if (result.second != GRF_LOAD_OK) {
        GRF &problematic_grf = getLibrary().getGRF(result.first);
 
        switch (result.second)
        {
            case GRF_LOAD_HEADER_READ_ERROR:
                printf("GRF: Error reading grf header. aborting...\n");
                return true;
            case GRF_LOAD_FORMAT_ERROR:
                printf("GRF: Invalid or unknown grf header format. aborting...\n");
                printf("GRF: Possible over 2GB in size...\n");
                return true;
            case GRF_LOAD_INVALID_VERSION:
                printf("GRF: Invalid grf version %x. aborting...\n", problematic_grf.getGRFVersion());
                return true;
            case GRF_LOAD_READ_ERROR:
                printf("GRF: Read error while loading the grf. Aborting...\n");
                return true;
            case GRF_LOAD_MAGIC_ERROR:
                printf("GRF: Magic header was not 'Master of Magic'! Aborting...\n");
                return true;
            case GRF_LOAD_PATH_ERROR:
                printf("GRF: Incorrect path '%s' given for grf. Aborting...\n", problematic_grf.getGRFPath().c_str());
                return true;
            case GRF_LOAD_INCOMPLETE_HEADER:
                printf("GRF: Error reading header of the given grf '%s'. Aborting...\n", problematic_grf.getGRFPath().c_str());
                return true;
            case GRF_LOAD_ILLEGAL_DATA_FORMAT:
                printf("GRF: Illegal data format, compressed size is greater than expected.\n");
                return true;
            case GRF_LOAD_OK:
            default:
                break;
        }
    }
 
    for (auto &grf : getLibrary().getGRFs()) {
        int size = grf.second.getGRFSize();
        float kb_size = size / 1024;
        float mb_size = kb_size / 1024;
        float gb_size = mb_size / 1024;
 
        printf("Info: GRF Loaded from '%s'.\n", grf.second.getGRFPath().string().c_str());
        printf("Info: Total GRF Size - %d B (%0.2f KB or %0.2f MB or %0.2f GB).\n", size, kb_size, mb_size, gb_size);
        printf("Info: GRF has '%d' Total Compressed Files.\n", grf.second.getTotalFiles());
        printf("Info: GRF Version %x\n", grf.second.getGRFVersion());
        printf("Info: GRF file path: '%s'\n", grf.second.getGRFPath().c_str());
    }
 
    return false;
}

References GRF::getGRFPath(), GRF::getGRFVersion(), GRF_LOAD_FORMAT_ERROR, GRF_LOAD_HEADER_READ_ERROR, GRF_LOAD_ILLEGAL_DATA_FORMAT, GRF_LOAD_INCOMPLETE_HEADER, GRF_LOAD_INVALID_VERSION, GRF_LOAD_MAGIC_ERROR, GRF_LOAD_OK, GRF_LOAD_PATH_ERROR, and GRF_LOAD_READ_ERROR.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseInitializeResult()

bool Horizon::Tools::MapCache::ParseInitializeResult

(

mcache_error_type

type

)

{
    switch (type)
    {
    case MCACHE_INVALID_GRF_PATH:
        printf("Invalid GRF config path '%s' provided.\n", getLibrary().getGRFListPath().c_str());
        return false;
    case MCACHE_INVALID_CONFIG_PATH:
        printf("Invalid config path '%s' provided.\n", getLibrary().getMapListPath().c_str());
        return false;
    case MCACHE_INVALID_OUTPUT_PATH:
        printf("Invalid output path '%s' provided.\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_CONFIG_READ_ERROR:
        printf("There was an error reading the configuration.\n");
        return false;
    case MCACHE_GRF_LOAD_ERROR:
        printf("There was an error loading the GRF.\n");
        return false;
    default:
        break;
    }
    return true;
}

References MCACHE_CONFIG_READ_ERROR, MCACHE_GRF_LOAD_ERROR, MCACHE_INVALID_CONFIG_PATH, MCACHE_INVALID_GRF_PATH, and MCACHE_INVALID_OUTPUT_PATH.

Referenced by main().

Here is the caller graph for this function:

ParseMapCacheImportResult()

bool Horizon::Tools::MapCache::ParseMapCacheImportResult

(

mcache_import_error_type

type

)

{
    switch (type)
    {
    default:
        printf("Info: Import of %lu maps was successful.\n", getLibrary().getMCache()->maps.size());
        break;
    case MCACHE_IMPORT_NONEXISTENT_FILE:
        printf("Error: Could not open file '%s'.\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_IMPORT_READ_ERROR:
        printf("Error: Could not read file '%s', rebuilding...\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_IMPORT_INVALID_CHECKSUM:
        printf("Error: File cache file '%s' is corrupted (invalid checksum), rebuilding...\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_IMPORT_DECOMPRESS_ERROR:
        printf("Error: File cache file '%s' could not be decompressed, rebuilding...\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_IMPORT_MAPINFO_ERROR:
        printf("Error: Could not read map information for a map while importing file '%s', rebuilding...\n", getLibrary().getMapCachePath().c_str());
        return false;
    case MCACHE_IMPORT_CELLINFO_ERROR:
        printf("Error: Could not read cell information for a map while importing file '%s', rebuilding...\n", getLibrary().getMapCachePath().c_str());
        return false;
    }
 
    return true;
}

References MCACHE_IMPORT_CELLINFO_ERROR, MCACHE_IMPORT_DECOMPRESS_ERROR, MCACHE_IMPORT_INVALID_CHECKSUM, MCACHE_IMPORT_MAPINFO_ERROR, MCACHE_IMPORT_NONEXISTENT_FILE, and MCACHE_IMPORT_READ_ERROR.

Referenced by main().

Here is the caller graph for this function:

Member Data Documentation

_cache

Horizon::Libraries::MapCache Horizon::Tools::MapCache::_cache

private

Referenced by getLibrary().

---

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

• src/Tools/mapcache/MapCache.hpp
• src/Tools/mapcache/MapCache.cpp