LineOfSightRouter.cpp

浏览该文件的文档.

 
#include "sensing/LineOfSightRouter.h"
 
#include "common/Capability.h"
#include "common/Diagnostic.h"
 
#include <optional>
#include <utility>
 
namespace eve::sensing {
namespace {
 
template <typename T>
Result<T> failure(DiagnosticCode code, std::string message, std::string path) {
    return Result<T>::failure(Diagnostic::error(code, message, path));
}
 
std::string locationPath(const char* name) { return std::string("lineOfSight.") + name; }
 
LineOfSightRouter& routerHolder() {
    static LineOfSightRouter router;
    return router;
}
 
}  // namespace
 
Result<LineOfSightRouter*> ensureLineOfSightRouter() {
    LineOfSightRouter& router = routerHolder();
    ILineOfSightQuery* registered = cap::query<ILineOfSightQuery>();
    if (registered == &router) return Result<LineOfSightRouter*>::success(&router);
    if (registered != nullptr)
        // Respect an existing registration instead of replacing it, so a project that owns its
        // own implementation is never silently overridden by a backend claiming a space.
        return failure<LineOfSightRouter*>(DiagnosticCode::Conflict,
                                           "another line-of-sight provider is already registered",
                                           "lineOfSight.provider");
    cap::provide<ILineOfSightQuery>(&router);
    return Result<LineOfSightRouter*>::success(&router, Status::success(StatusCode::Applied));
}
 
std::optional<CoordinateSpace> LineOfSightRouter::spaceOf(const TargetLocation& location) noexcept {
    return std::visit(
        [](const auto& point) -> std::optional<CoordinateSpace> { return point.space(); }, location);
}
 
Result<void> LineOfSightRouter::addProvider(CoordinateSpace space, const ILineOfSightQuery* provider) {
    if (provider == nullptr)
        return failure<void>(DiagnosticCode::InvalidArgument,
                             "line-of-sight backend must not be null", "lineOfSight.provider");
    const auto index = static_cast<std::size_t>(space);
    if (index >= providers_.size())
        return failure<void>(DiagnosticCode::InvalidArgument,
                             "unknown line-of-sight coordinate space", "lineOfSight.space");
    if (providers_[index] != nullptr)
        // Replace would make the effective backend depend on registration order, which is the
        // problem this router exists to remove.
        return failure<void>(DiagnosticCode::Conflict,
                             "line-of-sight coordinate space already has a backend", "lineOfSight.space");
    providers_[index] = provider;
    return Result<void>::success(Status::success(StatusCode::Applied));
}
 
Result<void> LineOfSightRouter::removeProvider(CoordinateSpace space, const ILineOfSightQuery* provider) {
    const auto index = static_cast<std::size_t>(space);
    if (index >= providers_.size() || providers_[index] != provider)
        return Result<void>::success(Status::success(StatusCode::NoOp));
    providers_[index] = nullptr;
    return Result<void>::success(Status::success(StatusCode::Applied));
}
 
bool LineOfSightRouter::hasProvider(CoordinateSpace space) const noexcept {
    const auto index = static_cast<std::size_t>(space);
    return index < providers_.size() && providers_[index] != nullptr;
}
 
std::vector<CoordinateSpace> LineOfSightRouter::spaces() const {
    std::vector<CoordinateSpace> claimed;
    for (std::size_t index = 0; index < providers_.size(); ++index) {
        if (providers_[index] != nullptr) claimed.push_back(static_cast<CoordinateSpace>(index));
    }
    return claimed;
}
 
Result<LineOfSightResult> LineOfSightRouter::query(const TargetLocation& from,
                                                  const TargetLocation& to) const {
    const auto fromSpace = spaceOf(from);
    const auto toSpace   = spaceOf(to);
    if (!fromSpace || !toSpace)
        return failure<LineOfSightResult>(DiagnosticCode::InvalidArgument,
                                          "line-of-sight endpoints must be valid points",
                                          locationPath("from"));
    if (*fromSpace != *toSpace)
        // The interface forbids converting between spaces, so a mixed query is a caller error
        // rather than something to approximate.
        return failure<LineOfSightResult>(DiagnosticCode::InvalidArgument,
                                          "line-of-sight endpoints must share a coordinate space",
                                          locationPath("to"));
    const auto index = static_cast<std::size_t>(*fromSpace);
    if (index >= providers_.size() || providers_[index] == nullptr)
        return failure<LineOfSightResult>(DiagnosticCode::Unsupported,
                                          "no line-of-sight backend for coordinate space " +
                                              std::string(coordinateSpaceName(*fromSpace)),
                                          locationPath("from"));
    return providers_[index]->query(from, to);
}
 
}  // namespace eve::sensing