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/alias.hpp (6870B)

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list
of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this
list of conditions and the following disclaimer in the documentation and/or
other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#ifndef OSRM_UTIL_ALIAS_HPP
#define OSRM_UTIL_ALIAS_HPP

#include <boost/numeric/conversion/cast.hpp>
#include <functional>
#include <iostream>
#include <type_traits>

namespace osrm
{

template <typename From, typename Tag> struct Alias;
template <typename From, typename Tag>
inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &inst);

template <typename From, typename Tag> struct Alias final
{
    using value_type = From;
    static_assert(std::is_arithmetic<From>::value, "Needs to be based on an arithmetic type");

From __value;
    friend std::ostream &operator<<<From, Tag>(std::ostream &stream, const Alias &inst);

explicit operator From &() { return __value; }
    explicit operator From() const { return __value; }
    inline Alias operator+(const Alias rhs_) const
    {
        return Alias{__value + static_cast<const From>(rhs_)};
    }
    inline Alias operator-(const Alias rhs_) const
    {
        return Alias{__value - static_cast<const From>(rhs_)};
    }
    inline Alias operator*(const Alias rhs_) const
    {
        return Alias{__value * static_cast<const From>(rhs_)};
    }
    inline Alias operator*(const double rhs_) const { return Alias{__value * rhs_}; }
    inline Alias operator/(const Alias rhs_) const
    {
        return Alias{__value / static_cast<const From>(rhs_)};
    }
    inline Alias operator/(const double rhs_) const { return Alias{__value / rhs_}; }
    inline Alias operator|(const Alias rhs_) const
    {
        return Alias{__value | static_cast<const From>(rhs_)};
    }
    inline Alias operator&(const Alias rhs_) const
    {
        return Alias{__value & static_cast<const From>(rhs_)};
    }
    inline bool operator<(const Alias z_) const { return __value < static_cast<const From>(z_); }
    inline bool operator>(const Alias z_) const { return __value > static_cast<const From>(z_); }
    inline bool operator<=(const Alias z_) const { return __value <= static_cast<const From>(z_); }
    inline bool operator>=(const Alias z_) const { return __value >= static_cast<const From>(z_); }
    inline bool operator==(const Alias z_) const { return __value == static_cast<const From>(z_); }
    inline bool operator!=(const Alias z_) const { return __value != static_cast<const From>(z_); }

inline Alias operator++()
    {
        __value++;
        return *this;
    }
    inline Alias operator--()
    {
        __value--;
        return *this;
    }

inline Alias operator+=(const Alias z_)
    {
        __value += static_cast<const From>(z_);
        return *this;
    }
    inline Alias operator-=(const Alias z_)
    {
        __value -= static_cast<const From>(z_);
        return *this;
    }
    inline Alias operator/=(const Alias z_)
    {
        __value /= static_cast<const From>(z_);
        return *this;
    }
    inline Alias operator*=(const Alias z_)
    {
        __value *= static_cast<const From>(z_);
        return *this;
    }
    inline Alias operator|=(const Alias z_)
    {
        __value |= static_cast<const From>(z_);
        return *this;
    }
    inline Alias operator&=(const Alias z_)
    {
        __value &= static_cast<const From>(z_);
        return *this;
    }
};

template <typename ToAlias, typename FromAlias> inline ToAlias alias_cast(const FromAlias &from)
{
    static_assert(std::is_arithmetic<typename FromAlias::value_type>::value,
                  "Alias From needs to be based on an arithmetic type");
    static_assert(std::is_arithmetic<typename ToAlias::value_type>::value,
                  "Alias Other needs to be based on an arithmetic type");
    return {static_cast<typename ToAlias::value_type>(
        static_cast<const typename FromAlias::value_type>(from))};
}

template <typename ToNumeric, typename FromAlias> inline ToNumeric from_alias(const FromAlias &from)
{
    static_assert(std::is_arithmetic<typename FromAlias::value_type>::value,
                  "Alias From needs to be based on an arithmetic type");
    static_assert(std::is_arithmetic<ToNumeric>::value, "Numeric needs to be an arithmetic type");
    return {static_cast<ToNumeric>(static_cast<const typename FromAlias::value_type>(from))};
}

template <typename ToAlias,
          typename FromNumeric,
          typename = std::enable_if_t<!std::is_same<ToAlias, FromNumeric>::value>>
inline ToAlias to_alias(const FromNumeric &from)
{
    static_assert(std::is_arithmetic<FromNumeric>::value, "Numeric needs to be an arithmetic type");
    static_assert(std::is_arithmetic<typename ToAlias::value_type>::value,
                  "Alias needs to be based on an arithmetic type");
    return {static_cast<typename ToAlias::value_type>(from)};
}

// Sometimes metrics are stored either as bitfields or the alias itself.
// So we'll try to convert to alias without knowing which is the case.
// Therefore, we need this no-op overload, otherwise it will fail on the arithmetic requirement.
template <typename ToAlias> inline ToAlias to_alias(const ToAlias &from) { return from; }

template <typename From, typename Tag>
inline std::ostream &operator<<(std::ostream &stream, const Alias<From, Tag> &inst)
{
    return stream << inst.__value;
}
} // namespace osrm

namespace std
{
template <typename From, typename Tag> struct hash<osrm::Alias<From, Tag>>
{
    using argument_type = osrm::Alias<From, Tag>;
    using result_type = std::size_t;
    result_type operator()(argument_type const &s) const
    {
        return std::hash<From>()(static_cast<const From>(s));
    }
};
} // namespace std

#endif // OSRM_ALIAS_HPP

cmd: