Namespace SpiceQL::Memo

Namespace List > SpiceQL > Memo

Classes

Type	Name
class	Cache
class	Memory
struct	memoize <typename Cache, typename Function>

Public Functions

Type	Name
size_t	_hash_combine (std::size_t & seed, const T & v)
std::string	getCacheDir ()
std::vector< std::vector< std::string > >	getPathsFromRegex (std::string root, std::vector< std::string > regexes)
std::vector< std::pair< double, double > >	getTimeIntervals (std::string kpath) Get start and stop times a kernel.
std::string	globTimeIntervals (std::string mission) Get start and stop times for all kernels.
bool	has_cache_expired (time_t latest, std::vector< std::string > files)
size_t	hash_combine (std::size_t & seed)
size_t	hash_combine (std::size_t & seed, const T & t, const Params &... params)
std::vector< std::string >	ls (std::string const & root, bool recursive) ls, like in unix, kinda. Also it's a function. This is memoized so it'll load from cache if run multiple times with the same parameters.
memoize< Cache, Function >	make_memoized (Cache & fc, const std::string & id, Function f)
std::time_t	time_from_str (std::string time)
std::time_t	to_time_t (TP tp)

Public Functions Documentation

function _hash_combine

template<class T>
inline size_t SpiceQL::Memo::_hash_combine (
    std::size_t & seed,
    const T & v
)

function getCacheDir

inline std::string SpiceQL::Memo::getCacheDir ()

function getPathsFromRegex

std::vector< std::vector< std::string > > SpiceQL::Memo::getPathsFromRegex (
    std::string root,
    std::vector< std::string > regexes
)

function getTimeIntervals

Get start and stop times a kernel.

std::vector< std::pair< double, double > > SpiceQL::Memo::getTimeIntervals (
    std::string kpath
)

For each segment in the kernel, get all start and stop times as a vector of double pairs. This gets all start and stop times regardless of the frame associated with it.

Input kernel is assumed to be a binary kernel with time dependant external orientation data.

Parameters:

kpath Path to the kernel

Returns:

std::vector of start and stop times

function globTimeIntervals

Get start and stop times for all kernels.

std::string SpiceQL::Memo::globTimeIntervals (
    std::string mission
)

Returns:

string json map of kernel names to list of time segments

function has_cache_expired

inline bool SpiceQL::Memo::has_cache_expired (
    time_t latest,
    std::vector< std::string > files
)

function hash_combine

inline size_t SpiceQL::Memo::hash_combine (
    std::size_t & seed
)

function hash_combine

template<typename T, typename... Params>
inline size_t SpiceQL::Memo::hash_combine (
    std::size_t & seed,
    const T & t,
    const Params &... params
)

function ls

ls, like in unix, kinda. Also it's a function. This is memoized so it'll load from cache if run multiple times with the same parameters.

std::vector< std::string > SpiceQL::Memo::ls (
    std::string const & root,
    bool recursive
)

Iterates the input path and returning a list of files. Optionally, recursively.

Parameters:

root The root directory to search
recursive recursively iterates through directories if true

Returns:

list of paths

function make_memoized

template<typename Cache, typename Function>
memoize < Cache , Function > SpiceQL::Memo::make_memoized (
    Cache & fc,
    const std::string & id,
    Function f
)

function time_from_str

inline std::time_t SpiceQL::Memo::time_from_str (
    std::string time
)

function to_time_t

template<typename TP>
inline std::time_t SpiceQL::Memo::to_time_t (
    TP tp
)

The documentation for this class was generated from the following file SpiceQL/include/memo.h