Horizon::Libraries::MapCache Class Reference

#include <MapCache.hpp>

Public Member Functions
	MapCache ()
	~MapCache ()
mcache_error_type	initialize ()
bool	Exists ()
mcache_import_error_type	ImportFromCacheFile ()
int	BuildInternalCache ()
bool	BuildExternalCache ()
bool	AppendHeader ()
bool	CreateNewCacheWithHeader ()
bool	AppendToCache (std::string const &name)
bool	GetMapFromGRF (GRF &grf, std::string const &name)
	Reads a map from GRF's GAT and RSW files. More...
bool	ParseGRFReadResult (GRF &grf, std::string const &filename, grf_read_error_type error)
mcache_config_error_type	ReadMapListConfig ()
mcache_grf_config_error_type	ReadGRFListConfig ()
std::pair< uint8_t, grf_load_result_type >	LoadGRFs ()
void	PrintCacheForMap (std::string const &map_name)
GRF &	getGRF (uint8_t id)
void	addGRF (uint8_t id, GRF &grf)
boost::filesystem::path &	getMapCachePath ()
void	setMapCachePath (std::string const &file)
int	getCompressionLevel ()
void	setCompressionLevel (int level)
const boost::filesystem::path &	getMapListPath () const
void	setMapListPath (std::string const &path)
const boost::filesystem::path &	getGRFListPath () const
void	setGRFListPath (std::string const &path)
void	addToMapList (std::string const &map)
const boost::filesystem::path &	getGRFPath (uint8_t id)
void	setGRFPath (uint8_t id, std::string const &path)
const boost::filesystem::path &	getResourcePath ()
void	setResourcePath (std::string const &path)
void	setVerbose ()
void	unsetVerbose ()
bool	getVerbose ()
std::shared_ptr< map_cache >	getMCache ()
const std::unordered_map< uint8_t, GRF > &	getGRFs ()

Private Attributes
boost::filesystem::path	_map_list_path
boost::filesystem::path	_grf_list_path
boost::filesystem::path	_resource_path
boost::filesystem::path	_map_cache_path
std::unordered_map< uint8_t, GRF >	_grfs
int	_compression_level {6}
std::map< std::string, map_data >	_map_cache_data
std::vector< std::string >	_map_list
std::shared_ptr< map_cache >	m_cache
bool	_verbose {false}

Constructor & Destructor Documentation

MapCache()

Horizon::Libraries::MapCache::MapCache

(

)

: m_cache(std::make_shared<map_cache>())
{
}

~MapCache()

Horizon::Libraries::MapCache::~MapCache

(

)

{
}

Member Function Documentation

addGRF()

void Horizon::Libraries::MapCache::addGRF ( uint8_t  id, GRF &  grf  )

inline

{ _grfs[id] = grf; }

References _grfs.

addToMapList()

void Horizon::Libraries::MapCache::addToMapList ( std::string const &  map )

inline

{ _map_list.push_back(map); }

References _map_list.

AppendHeader()

bool Horizon::Libraries::MapCache::AppendHeader

(

)

AppendToCache()

bool Horizon::Libraries::MapCache::AppendToCache

(

std::string const &

name

)

BuildExternalCache()

bool Horizon::Libraries::MapCache::BuildExternalCache

(

)

{
    std::ofstream ofs(getMapCachePath().c_str(), std::ios::out | std::ios::binary | std::ios::trunc);
    unsigned long file_size = 0, compressed_size = 0;
    uint8_t *uncompressed_buf, *compressed_buf;
    int version = m_cache->getHeader().getVersion();
    boost::crc_32_type crc_32;
 
    // Pre-determine the file size.
    for (auto m : m_cache->maps) {
        map_data data = m.second;
        file_size += sizeof(struct map_info) + data.info.length;
    }
 
    uncompressed_buf = new uint8_t[file_size];
    compressed_buf = new uint8_t[file_size];
    compressed_size = compressBound(file_size);
 
    int pos = 0;
    // Content
    for (auto m : m_cache->maps) {
        map_data data = m.second;
        memcpy(uncompressed_buf + pos, &data.info, sizeof(data.info));
        pos += sizeof(data.info);
        memcpy(uncompressed_buf + pos, data.cells.data(), data.cells.size());
        pos += data.cells.size();
        PrintCacheForMap(m.first);
    }
 
    compress2((Bytef *) compressed_buf, &compressed_size, (const Bytef *) uncompressed_buf, file_size, getCompressionLevel());
    crc_32.process_bytes(compressed_buf, compressed_size);
 
    // Header
    m_cache->getHeader().setMapCount(m_cache->maps.size());
    m_cache->getHeader().setFileSize(file_size);
    m_cache->getHeader().setVersion(++version);
    m_cache->getHeader().setChecksum(crc_32.checksum());
 
    ofs.write((char *) &m_cache->getHeader(), sizeof(mapcache_header));
    ofs.write((char *) compressed_buf, compressed_size);
 
    delete[] uncompressed_buf;
    delete[] compressed_buf;
    return true;
}

References map_data::cells, mapcache_header::file_size, map_data::info, map_info::length, and mapcache_header::version.

Referenced by main().

Here is the caller graph for this function:

BuildInternalCache()

int Horizon::Libraries::MapCache::BuildInternalCache

(

)

{
    int new_maps = 0;
 
    for (std::size_t i = 0; i < _map_list.size(); ++i) {
        std::string map_name = _map_list.at(i);
 
        if (!m_cache->getMap(map_name)) {
            for (auto &grf : _grfs) {
                if (GetMapFromGRF(grf.second, map_name)) {
                    new_maps++;
                    break;
                }
            }
        }
    }
 
    return new_maps;
}

Referenced by main().

Here is the caller graph for this function:

CreateNewCacheWithHeader()

bool Horizon::Libraries::MapCache::CreateNewCacheWithHeader

(

)

Exists()

bool Horizon::Libraries::MapCache::Exists

(

)

{
    std::ifstream ifs(getMapCachePath().c_str(), std::ios::in | std::ios::binary);
    return ifs.good();
}

Referenced by main().

Here is the caller graph for this function:

getCompressionLevel()

int Horizon::Libraries::MapCache::getCompressionLevel ( )

inline

{ return _compression_level; }

References _compression_level.

Referenced by main().

Here is the caller graph for this function:

getGRF()

GRF & Horizon::Libraries::MapCache::getGRF ( uint8_t  id )

inline

{ return _grfs.at(id); }

References _grfs.

getGRFListPath()

const boost::filesystem::path & Horizon::Libraries::MapCache::getGRFListPath ( ) const

inline

{ return _grf_list_path; }

References _grf_list_path.

getGRFPath()

const boost::filesystem::path & Horizon::Libraries::MapCache::getGRFPath ( uint8_t  id )

inline

{ return _grfs[id].getGRFPath(); }

References _grfs.

getGRFs()

const std::unordered_map< uint8_t, GRF > & Horizon::Libraries::MapCache::getGRFs ( )

inline

{ return _grfs; }

References _grfs.

getMapCachePath()

boost::filesystem::path & Horizon::Libraries::MapCache::getMapCachePath ( )

inline

{ return _map_cache_path; }

References _map_cache_path.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache(), and main().

Here is the caller graph for this function:

GetMapFromGRF()

bool Horizon::Libraries::MapCache::GetMapFromGRF	(	GRF &	grf,
		std::string const &	name
	)

Reads a map from GRF's GAT and RSW files.

Parameters

[in]

name

name of the map.

Returns

true on success, false on failure.

{
    char filename[256];
    std::pair<grf_read_error_type, uint8_t *> gat, rsw;
    int water_height;
    map_data m;
 
    // Set the Map Name.
    std::strncpy(m.info.name, name.c_str(), sizeof(m.info.name));
 
    // Search and retrieve the map's GAT file.
    std::sprintf(filename, "data\\%s.gat", name.c_str());
 
    gat = grf.read(filename, nullptr);
 
    if (!ParseGRFReadResult(grf, filename, gat.first))
        return false;
 
    // Search and retrieve the map's RSW file.
    std::sprintf(filename, "data\\%s.rsw", name.c_str());
 
    rsw = grf.read(filename, nullptr);
 
    if (!ParseGRFReadResult(grf, filename, rsw.first))
        return false;
 
    // Determine the water height of the map.
    if (rsw.second != nullptr) {
        water_height = GetULong((unsigned char *) rsw.second + 166);
        delete rsw.second;
    } else
        water_height = NO_WATER;
 
    // Determine the map size and allocate needed memory.
    m.info.total_x = (int16_t) GetULong((unsigned char *) (gat.second + 6));
    m.info.total_y = (int16_t) GetULong((unsigned char *) (gat.second + 10));
 
    if (m.info.total_x <= 0 || m.info.total_y <= 0) {
        delete gat.second;
        return false;
    }
 
    // Set the length of total map cell data as part of the each cache entry.
    m.info.length = m.info.total_x * m.info.total_y;
 
    // Set cell information.
    int offset = 14;
 
    for (std::size_t i = 0; i < m.info.length; ++i) {
        // Height of the bottom-left corner
        // The actual start of the map.
        float height = GetFloat((unsigned char *) (gat.second + offset));
        // Type of cell
        uint32_t type = GetULong((unsigned char *) (gat.second + offset + 16));
 
        if (type == 0 && water_height != NO_WATER && height > water_height)
            type = 3; // Cell is 0 (walkable) but under water level, set to 3 (walkable water)
 
        offset += 20;
 
        // Maps are stored starting (0, map_height), (1, map_height) ... (map_width, 0)
        m.cells.push_back(type);
    }
 
    // Push into our internal cache.
    m_cache->addMap(m);
 
    delete gat.second;
 
    return true;
}

References map_data::cells, GetFloat(), GetULong(), map_data::info, map_info::length, map_info::name, NO_WATER, GRF::read(), map_info::total_x, and map_info::total_y.

Here is the call graph for this function:

getMapListPath()

const boost::filesystem::path & Horizon::Libraries::MapCache::getMapListPath ( ) const

inline

{ return _map_list_path; }

References _map_list_path.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache(), and main().

Here is the caller graph for this function:

getMCache()

std::shared_ptr< map_cache > Horizon::Libraries::MapCache::getMCache ( )

inline

{ return m_cache; }

References m_cache.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache(), and main().

Here is the caller graph for this function:

getResourcePath()

const boost::filesystem::path & Horizon::Libraries::MapCache::getResourcePath ( )

inline

{ return _resource_path; }

References _resource_path.

getVerbose()

bool Horizon::Libraries::MapCache::getVerbose ( )

inline

{ return _verbose; }

References _verbose.

ImportFromCacheFile()

mcache_import_error_type Horizon::Libraries::MapCache::ImportFromCacheFile

(

)

{
    std::ifstream ifs(getMapCachePath().c_str(), std::ios::in | std::ios::binary);
    struct mapcache_header header;
    uint8_t *compressed_buf, *uncompressed_buf;
    unsigned long compressed_size = 0, uncompressed_size = 0;
    boost::crc_32_type crc_32;
 
    if (!ifs.good())
        return MCACHE_IMPORT_NONEXISTENT_FILE;
 
    // Determine the File Size.
    ifs.seekg(0, ifs.end);
    compressed_size = ifs.tellg();
    compressed_size -= sizeof(mapcache_header);
    ifs.seekg(0, ifs.beg);
 
    // Read Header.
    if (!ifs.read((char *) &header, sizeof(mapcache_header)))
        return MCACHE_IMPORT_READ_ERROR;
 
    m_cache->setHeader(header);
 
    // Compressed Size.
    compressed_buf = new uint8_t[compressed_size];
    memset(compressed_buf, '\0', compressed_size);
 
    // Uncompressed Size.
    uncompressed_size = header.getFileSize();
    uncompressed_buf = new uint8_t[uncompressed_size];
    memset(uncompressed_buf, '\0', uncompressed_size);
 
    // Read the remaining size.
    if (!ifs.read((char *) compressed_buf, compressed_size)) {
        delete[] uncompressed_buf;
        delete[] compressed_buf;
        return MCACHE_IMPORT_READ_ERROR;
    }
 
    crc_32.process_bytes(compressed_buf, compressed_size);
 
    if (crc_32.checksum() != m_cache->getHeader().getChecksum()) {
        delete[] uncompressed_buf;
        delete[] compressed_buf;
        return MCACHE_IMPORT_INVALID_CHECKSUM;
    }
 
    // Unpack the file.
    if (uncompress((Bytef *) uncompressed_buf, &uncompressed_size, (const Bytef *) compressed_buf, compressed_size) != Z_OK) {
        delete[] uncompressed_buf;
        delete[] compressed_buf;
        return MCACHE_IMPORT_DECOMPRESS_ERROR;
    }
 
    for (int i = 0, pos = 0; i < m_cache->getHeader().getMapCount(); ++i) {
        map_data m{};
        uint8_t *cells = nullptr;
 
        if (memcpy(&m.info, uncompressed_buf + pos, sizeof(map_info)) == nullptr) {
            delete[] uncompressed_buf;
            delete[] compressed_buf;
            return MCACHE_IMPORT_MAPINFO_ERROR;
        }
 
        cells = new uint8_t[m.info.length];
        pos += sizeof(map_info);
 
        if (memcpy(cells, uncompressed_buf + pos, m.info.length) == nullptr) {
            delete[] cells;
            delete[] uncompressed_buf;
            delete[] compressed_buf;
            return MCACHE_IMPORT_CELLINFO_ERROR;
        }
 
        for (uint32_t c = 0; c < m.info.length; ++c)
            m.cells.push_back(cells[c]);
 
        delete[] cells;
 
        pos += m.info.length;
 
        m_cache->addMap(m);
    }
 
    delete[] compressed_buf;
    delete[] uncompressed_buf;
 
    return MCACHE_IMPORT_OK;
}

References mapcache_header::getFileSize(), mapcache_header::getMapCount(), MCACHE_IMPORT_CELLINFO_ERROR, MCACHE_IMPORT_DECOMPRESS_ERROR, MCACHE_IMPORT_INVALID_CHECKSUM, MCACHE_IMPORT_MAPINFO_ERROR, MCACHE_IMPORT_NONEXISTENT_FILE, MCACHE_IMPORT_OK, and MCACHE_IMPORT_READ_ERROR.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize()

mcache_error_type Horizon::Libraries::MapCache::initialize

(

)

{
    if (getGRFListPath().empty())
        return MCACHE_INVALID_GRF_PATH;
 
    if (getMapListPath().empty())
        return MCACHE_INVALID_CONFIG_PATH;
 
    if (getMapCachePath().empty())
        return MCACHE_INVALID_OUTPUT_PATH;
 
    if (ReadMapListConfig() != MCACHE_CONFIG_OK)
        return MCACHE_CONFIG_READ_ERROR;
 
    if (ReadGRFListConfig() != MCACHE_GRF_CONF_OK)
        return MCACHE_GRF_CONFIG_READ_ERROR;
 
    return MCACHE_OK;
}

References MCACHE_CONFIG_OK, MCACHE_CONFIG_READ_ERROR, MCACHE_GRF_CONF_OK, MCACHE_GRF_CONFIG_READ_ERROR, MCACHE_INVALID_CONFIG_PATH, MCACHE_INVALID_GRF_PATH, MCACHE_INVALID_OUTPUT_PATH, and MCACHE_OK.

Referenced by main().

Here is the caller graph for this function:

LoadGRFs()

std::pair< uint8_t, grf_load_result_type > Horizon::Libraries::MapCache::LoadGRFs

(

)

{
    grf_load_result_type res;
 
    for (auto &grf : _grfs)
        if ((res = grf.second.load()) != GRF_LOAD_OK)
            return std::make_pair(grf.second.get_id(), res);
 
    return std::pair<uint8_t, grf_load_result_type>(-1, GRF_LOAD_OK);
}

References GRF_LOAD_OK.

Referenced by main().

Here is the caller graph for this function:

ParseGRFReadResult()

bool Horizon::Libraries::MapCache::ParseGRFReadResult	(	GRF &	grf,
		std::string const &	filename,
		grf_read_error_type	error
	)

{
    std::string grf_name =  grf.getGRFPath().filename().string();
 
    switch (error)
    {
    case GRE_OK:
    default:
        break;
    case GRE_NOT_FOUND:
        printf("Warning: File '%s' could not be located in GRF '%s'.\n", filename.c_str(), grf_name.c_str());
        return false;
    case GRE_DECOMPRESS_SIZE_MISMATCH:
        printf("Warning: File '%s' decompressed size mismatch in GRF '%s'.\n", filename.c_str(), grf_name.c_str());
        return false;
    case GRE_READ_ERROR:
        printf("Warning: File '%s' could not be read in GRF '%s'.\n", filename.c_str(), grf_name.c_str());
        return false;
    }
 
    return true;
}

References GRF::getGRFPath(), GRE_DECOMPRESS_SIZE_MISMATCH, GRE_NOT_FOUND, GRE_OK, and GRE_READ_ERROR.

Here is the call graph for this function:

PrintCacheForMap()

void Horizon::Libraries::MapCache::PrintCacheForMap

(

std::string const &

map_name

)

{
    boost::optional<map_data> data;
    std::ofstream ofs("../../../maps/"+map_name+".txt", std::ios::out);
 
    if (!(data = m_cache->getMap(map_name))) {
        printf("map not found\n");
        return;
    }
 
    int **cells = (int **) std::malloc(sizeof(int *) * data->width());
    cells[0] = (int *) std::malloc(sizeof(int) * data->width() * data->height());
 
    for (int i = 0; i < data->width(); i++)
        cells[i] = (*cells) + data->height() * i;
 
    for (int y = 0, idx = 0; y < data->height(); y++) {
        for (int x = 0; x < data->width(); x++) {
            cells[x][y] = data->getCells().at(idx++);
        }
    }
 
    for (int y = data->height() - 1; y >= 0; --y) {
        for (int x = 0; x < data->width(); x++) {
            int type = cells[x][y];
            //          char s;
            //          switch (type)
            //          {
            //          case 3: s = '~'; break; // walkable water
            //          case 0: // walkable ground
            //          case 2: // ???
            //          case 4: // ???
            //          case 6: s = '.'; break; // ???
            //          case 5: s = 'O'; break; // gap (snipable)
            //          case 1: s = '#'; break; // non-walkable ground
            //          }
            ofs.write(std::string("%d,", type).c_str(), 1);
        }
        ofs.write("\n", 1);
    }
 
    std::free(cells[0]);
    std::free(cells);
}

ReadGRFListConfig()

mcache_grf_config_error_type Horizon::Libraries::MapCache::ReadGRFListConfig

(

)

{
    sol::state lua;
    sol::table grf_tbl;
    if (getGRFListPath().empty())
        return MCACHE_GRF_CONF_INVALID_FILE;
 
    // Read the file. If there is an error, report it and exit.
    try {
        sol::load_result fx = lua.load_file(getGRFListPath().string());
        
        if (!fx.valid()) {
            sol::error err = fx;
            printf("GRFList Parse error at %s.\n", err.what());
            return MCACHE_GRF_CONF_PARSE_ERROR;
        }
 
        sol::protected_function_result result = fx();
 
        if (!result.valid()) {
            sol::error err = result;
            printf("GRFList Parse error at %s.\n", err.what());
            return MCACHE_GRF_CONF_PARSE_ERROR;
        }
 
        grf_tbl = result;
 
    } catch(const std::exception &e) {
        printf("Error: GRFList Parse error at %s.\n", e.what());
        return MCACHE_GRF_CONF_PARSE_ERROR;
    }
 
    setResourcePath(grf_tbl.get_or("grf_resource_path", std::string("./")));
 
    sol::table grf_list = grf_tbl.get<sol::table>("grf_list");
 
    grf_list.for_each([this](sol::object const &key, sol::object const &value) {
        int id = key.as<int>();
        std::string path = value.as<std::string>();
 
        if (path.empty())
            return;
 
        GRF grf;
        grf.set_id(id);
        grf.setGRFPath(getGRFListPath().parent_path().string() + "/" + path);
        addGRF(id, grf);
    });
 
    return MCACHE_GRF_CONF_OK;
}

References MCACHE_GRF_CONF_INVALID_FILE, MCACHE_GRF_CONF_OK, MCACHE_GRF_CONF_PARSE_ERROR, GRF::set_id(), and GRF::setGRFPath().

Here is the call graph for this function:

ReadMapListConfig()

mcache_config_error_type Horizon::Libraries::MapCache::ReadMapListConfig

(

)

{
    sol::state lua;
    sol::table map_tbl;
 
    // Read the file. If there is an error, report it and exit.
    try {
        sol::load_result fx = lua.load_file(getMapListPath().string());
        // Check if the load result is valid
        if (!fx.valid()) {
            sol::error err = fx;
            printf("MapList Config Error: Parse error at %s.\n", err.what());
            return MCACHE_CONFIG_PARSE_ERROR;
        }
        
        sol::protected_function_result result = fx();
        
        if (!result.valid()) {
            sol::error err = result;
            printf("MapList Config Error: Result parse error at %s.\n", err.what());
            return MCACHE_CONFIG_PARSE_ERROR;
        }
 
        map_tbl = result;
        // Check if map_tbl is a table
        if (!map_tbl.valid() || map_tbl.get_type() != sol::type::table) {
            printf("MapList Config Error: Expected a table but received a different type.\n");
            return MCACHE_CONFIG_PARSE_ERROR;
        }
    } catch(const sol::error &e) {
        printf("MapList Config Error: Parse error at %s.\n", e.what());
        return MCACHE_CONFIG_PARSE_ERROR;
    } catch(const std::exception &e) {
        printf("MapList Config Error: Parse error at %s.\n", e.what());
        return MCACHE_CONFIG_PARSE_ERROR;
    } catch(...) {
        printf("MapList Config Error: Parse error.\n");
        return MCACHE_CONFIG_PARSE_ERROR;
    }
 
    map_tbl.for_each([this](sol::object const &key, sol::object const &value) {
        if (key.get_type() != sol::type::number)
            return;
        addToMapList(value.as<std::string>());
    });
 
    return MCACHE_CONFIG_OK;
}

References MCACHE_CONFIG_OK, and MCACHE_CONFIG_PARSE_ERROR.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache().

Here is the caller graph for this function:

setCompressionLevel()

void Horizon::Libraries::MapCache::setCompressionLevel ( int  level )

inline

{ _compression_level = level; }

References _compression_level.

setGRFListPath()

void Horizon::Libraries::MapCache::setGRFListPath ( std::string const &  path )

inline

{ _grf_list_path = path; }

References _grf_list_path.

setGRFPath()

void Horizon::Libraries::MapCache::setGRFPath ( uint8_t  id, std::string const &  path  )

inline

{ _grfs[id].setGRFPath(path); }

References _grfs.

setMapCachePath()

void Horizon::Libraries::MapCache::setMapCachePath ( std::string const &  file )

inline

{ _map_cache_path = file; }

References _map_cache_path.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache().

Here is the caller graph for this function:

setMapListPath()

void Horizon::Libraries::MapCache::setMapListPath ( std::string const &  path )

inline

{ _map_list_path = path; }

References _map_list_path.

Referenced by Horizon::Zone::GameLogicProcess::load_map_cache().

Here is the caller graph for this function:

setResourcePath()

void Horizon::Libraries::MapCache::setResourcePath ( std::string const &  path )

inline

{ _resource_path = path; }

References _resource_path.

setVerbose()

void Horizon::Libraries::MapCache::setVerbose ( )

inline

{ _verbose = true; }

References _verbose.

unsetVerbose()

void Horizon::Libraries::MapCache::unsetVerbose ( )

inline

{ _verbose = false; }

References _verbose.

Member Data Documentation

_compression_level

int Horizon::Libraries::MapCache::_compression_level {6}

private

Referenced by getCompressionLevel(), and setCompressionLevel().

_grf_list_path

boost::filesystem::path Horizon::Libraries::MapCache::_grf_list_path

private

Referenced by getGRFListPath(), and setGRFListPath().

_grfs

std::unordered_map<uint8_t, GRF> Horizon::Libraries::MapCache::_grfs

private

Referenced by addGRF(), getGRF(), getGRFPath(), getGRFs(), and setGRFPath().

_map_cache_data

std::map<std::string, map_data> Horizon::Libraries::MapCache::_map_cache_data

private

_map_cache_path

boost::filesystem::path Horizon::Libraries::MapCache::_map_cache_path

private

Referenced by getMapCachePath(), and setMapCachePath().

_map_list

std::vector<std::string> Horizon::Libraries::MapCache::_map_list

private

Referenced by addToMapList().

_map_list_path

boost::filesystem::path Horizon::Libraries::MapCache::_map_list_path

private

Referenced by getMapListPath(), and setMapListPath().

_resource_path

boost::filesystem::path Horizon::Libraries::MapCache::_resource_path

private

Referenced by getResourcePath(), and setResourcePath().

_verbose

bool Horizon::Libraries::MapCache::_verbose {false}

private

Referenced by getVerbose(), setVerbose(), and unsetVerbose().

m_cache

std::shared_ptr<map_cache> Horizon::Libraries::MapCache::m_cache

private

Referenced by getMCache().

---

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

• src/Libraries/MapCache/MapCache.hpp
• src/Libraries/MapCache/MapCache.cpp