FM / util

/srv/osrm/osrm-backend/include/util

Name	Size	Mode	Actions
guidance/	-	0755	rm
alias.hpp	6870	0644	edit dl rm
assert.hpp	1964	0644	edit dl rm
attributes.hpp	357	0644	edit dl rm
bearing.hpp	3964	0644	edit dl rm
bit_range.hpp	2950	0644	edit dl rm
cheap_ruler.hpp	2124	0644	edit dl rm
concurrent_id_map.hpp	2148	0644	edit dl rm
conditional_restrictions.hpp	627	0644	edit dl rm
connectivity_checksum.hpp	1931	0644	edit dl rm
coordinate.hpp	9244	0644	edit dl rm
coordinate_calculation.hpp	16297	0644	edit dl rm
deallocating_vector.hpp	11205	0644	edit dl rm
debug.hpp	5958	0644	edit dl rm
dist_table_wrapper.hpp	2299	0644	edit dl rm
dynamic_graph.hpp	15951	0644	edit dl rm
exception.hpp	5126	0644	edit dl rm
exception_utils.hpp	609	0644	edit dl rm
exclude_flag.hpp	975	0644	edit dl rm
filtered_graph.hpp	5402	0644	edit dl rm
filtered_integer_range.hpp	3097	0644	edit dl rm
fingerprint.hpp	1166	0644	edit dl rm
for_each_indexed.hpp	634	0644	edit dl rm
for_each_pair.hpp	990	0644	edit dl rm
for_each_range.hpp	477	0644	edit dl rm
geojson_debug_logger.hpp	6330	0644	edit dl rm
geojson_debug_policies.hpp	1810	0644	edit dl rm
geojson_debug_policy_toolkit.hpp	3258	0644	edit dl rm
geojson_validation.hpp	2899	0644	edit dl rm
graph_traits.hpp	1245	0644	edit dl rm
graph_utils.hpp	3141	0644	edit dl rm
group_by.hpp	722	0644	edit dl rm
hilbert_value.hpp	3010	0644	edit dl rm
indexed_data.hpp	15039	0644	edit dl rm
integer_range.hpp	3286	0644	edit dl rm
isatty.hpp	610	0644	edit dl rm
json_container.hpp	3181	0644	edit dl rm
json_deep_compare.hpp	4732	0644	edit dl rm
json_renderer.hpp	4160	0644	edit dl rm
json_util.hpp	544	0644	edit dl rm
log.hpp	2187	0644	edit dl rm
lua_util.hpp	891	0644	edit dl rm
matrix_graph_wrapper.hpp	1294	0644	edit dl rm
meminfo.hpp	660	0644	edit dl rm
mmap_file.hpp	2776	0644	edit dl rm
mmap_tar.hpp	1007	0644	edit dl rm
msb.hpp	1178	0644	edit dl rm
node_based_graph.hpp	3530	0644	edit dl rm
opening_hours.hpp	8338	0644	edit dl rm
packed_vector.hpp	21691	0644	edit dl rm
percent.hpp	2106	0644	edit dl rm
permutation.hpp	1991	0644	edit dl rm
query_heap.hpp	10205	0644	edit dl rm
range_table.hpp	7119	0644	edit dl rm
rectangle.hpp	5900	0644	edit dl rm
serialization.hpp	5902	0644	edit dl rm
static_assert.hpp	640	0644	edit dl rm
static_graph.hpp	10702	0644	edit dl rm
static_rtree.hpp	34147	0644	edit dl rm
std_hash.hpp	1035	0644	edit dl rm
string_util.hpp	3400	0644	edit dl rm
tarjan_scc.hpp	6646	0644	edit dl rm
timed_histogram.hpp	2576	0644	edit dl rm
timezones.hpp	1417	0644	edit dl rm
timing_util.hpp	1485	0644	edit dl rm
to_osm_link.hpp	694	0644	edit dl rm
trigonometry_table.hpp	35906	0644	edit dl rm
typedefs.hpp	7627	0644	edit dl rm
vector_tile.hpp	303	0644	edit dl rm
vector_view.hpp	8000	0644	edit dl rm
version.hpp.in	406	0644	edit dl rm
viewport.hpp	1579	0644	edit dl rm
web_mercator.hpp	6480	0644	edit dl rm
xor_fast_hash.hpp	1797	0644	edit dl rm
xor_fast_hash_storage.hpp	2195	0644	edit dl rm

Edit: /srv/osrm/osrm-backend/include/util/geojson_debug_logger.hpp (6330B)

#ifndef OSRM_GEOJSON_DEBUG_LOGGER_HPP
#define OSRM_GEOJSON_DEBUG_LOGGER_HPP

#include <fstream>
#include <iomanip>
#include <mutex>
#include <string>

#include "util/exception.hpp"
#include "util/json_container.hpp"
#include "util/json_renderer.hpp"
#include "util/log.hpp"

namespace osrm::util
{

// in case we want to do scenario-based logging, we can specify a dedicated logging scenario to be
// able to use multiple files for the same converter
enum class LoggingScenario
{
    eDefault = 0
};

// forward declaration to become friends
template <class geojson_conversion_policy, LoggingScenario scenario> class ScopedGeojsonLoggerGuard;

// a geojson logger requires a conversion policy to transfer arbitrary input into viable geojson.
// features of the same kind are stored in the same geojson file
template <class geojson_conversion_policy, LoggingScenario scenario = LoggingScenario::eDefault>
class GeojsonLogger
{
    // become friends with the guard
    friend class ScopedGeojsonLoggerGuard<geojson_conversion_policy, scenario>;

// having these private enforces the guard to be used to initialise/close/write
  private:
    // cannot lock, is tooling for locked function
    static void output(bool first, const util::json::Object &object)
    {
        if (!first)
            ofs << ",\n\t\t";
        // objects are simply forwarded
        util::json::render(ofs, object);
    }

// cannot lock, is tooling for locked function
    static void output(bool first, const util::json::Array &array)
    {
        for (const auto &object : array.values)
        {
            if (!first)
                ofs << ",\n\t\t";

util::json::render(ofs, object.get<util::json::Object>());

first = false;
        }
    }

// writes a single feature into the Geojson file
    template <typename... Args> static bool Write(Args &&... args)
    {
        // make sure to syncronize logging output, our writing should be sequential
        std::lock_guard<std::mutex> guard(lock);

// if there is no logfile, we cannot write (possible reason: the guard might be out of scope
        // (e.g. if it is anonymous))
        if (!ofs.is_open() || (nullptr == policy))
        {
            throw util::exception("Trying to use the geojson printer without an open logger.");
        }

// use our policy to convert the arguments into geojson, this can be done in parallel
        const auto json_object = (*policy)(std::forward<Args>(args)...);

// different features are separated by `,`
        // since we are not building a full json collection of features, we have to do some of the
        // bookeeping ourselves. This prevens us from doing one huge json object, if we are
        // processing larger results
        output(first, json_object);
        first = false;

return static_cast<bool>(ofs);
    }

// Opening a logger, we initialize a geojson feature collection
    // to be later filled with additional data
    static bool Open(const std::string &logfile)
    {
        // if a file is open, close it off. When this function returns, there should be an open
        // logfile. However, there is a brief period between closing and openen where we could miss
        // out on log output. Such a sad life
        if (ofs.is_open())
        {
            util::Log(logWARNING)
                << "Overwriting " << logfile
                << ". Is this desired behaviour? If this message occurs more than once rethink the "
                   "location of your Logger Guard.";
            Close();
        }

// make sure to syncronize logging output, cannot be locked earlier, since Close also locks
        // and we don't want deadlocks
        std::lock_guard<std::mutex> guard(lock);
        ofs.open(logfile, std::ios::binary);

ofs << std::setprecision(12);

// set up a feature collection
        ofs << "{\n\t\"type\": \"FeatureCollection\",\n\t\"features\": [\n\t";
        // remember whether we need to output a colon
        first = true;

return static_cast<bool>(ofs);
    }

// finalising touches on the GeoJson
    static bool Close()
    {
        // make sure to syncronize logging output
        std::lock_guard<std::mutex> guard(lock);

// finishe the geojson feature collection and close it all off
        if (ofs.is_open())
        {
            ofs << "\n\t]\n}";
            ofs.close();
        }

return static_cast<bool>(ofs);
    }

static void SetPolicy(geojson_conversion_policy *new_policy) { policy = new_policy; }

private:
    static bool first;
    static std::mutex lock;
    static std::ofstream ofs;

static geojson_conversion_policy *policy;
};

// make sure to do opening and closing of our guard
template <class geojson_conversion_policy, LoggingScenario scenario = LoggingScenario::eDefault>
class ScopedGeojsonLoggerGuard
{
  public:
    template <typename... Args>
    ScopedGeojsonLoggerGuard(const std::string &logfile, Args &&... args)
        : policy(std::forward<Args>(args)...)
    {
        GeojsonLogger<geojson_conversion_policy, scenario>::Open(logfile);
        GeojsonLogger<geojson_conversion_policy, scenario>::SetPolicy(&policy);
    }

~ScopedGeojsonLoggerGuard()
    {
        GeojsonLogger<geojson_conversion_policy, scenario>::Close();
        GeojsonLogger<geojson_conversion_policy, scenario>::SetPolicy(nullptr);
    }

template <typename... Args> static bool Write(Args &&... args)
    {
        return GeojsonLogger<geojson_conversion_policy, scenario>::Write(
            std::forward<Args>(args)...);
    }

private:
    geojson_conversion_policy policy;
};

template <class geojson_conversion_policy, LoggingScenario scenario>
bool GeojsonLogger<geojson_conversion_policy, scenario>::first;

template <class geojson_conversion_policy, LoggingScenario scenario>
std::mutex GeojsonLogger<geojson_conversion_policy, scenario>::lock;

template <class geojson_conversion_policy, LoggingScenario scenario>
std::ofstream GeojsonLogger<geojson_conversion_policy, scenario>::ofs;

template <class geojson_conversion_policy, LoggingScenario scenario>
geojson_conversion_policy *GeojsonLogger<geojson_conversion_policy, scenario>::policy;

} // namespace osrm::util

#endif /* OSRM_GEOJSON_DEBUG_LOGGER_HPP */

cmd: