lob.hpp

Go to the documentation of this file.

// Copyright (c) 2025  Joel Benway
// SPDX-License-Identifier: GPL-3.0-or-later
// Please see end of file for extended copyright information
 
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
 
#include "lob/lob.h"
 
namespace lob {

constexpr size_t kLobBuilderBufferSize = LOB_BUILDER_BUFFER_SIZE;
constexpr size_t kLobCoeffsSize = LOB_SPLINE_SEGMENTS * static_cast<size_t>(4);
constexpr size_t kLobWindPoints = LOB_WIND_POINTS;

enum class DragFunctionT : LobDragFunctionT {
  kG1 = ::kLobDragFunctionG1,  
  kG2 = ::kLobDragFunctionG2,  
  kG5 = ::kLobDragFunctionG5,  
  kG6 = ::kLobDragFunctionG6,  
  kG7 = ::kLobDragFunctionG7,  
  kG8 = ::kLobDragFunctionG8   
};

enum class AtmosphereReferenceT : LobAtmosphereReferenceT {
  kArmyStandardMetro =
      ::kLobAtmosphereReferenceArmyStandardMetro,  
  kIcao = ::kLobAtmosphereReferenceIcao  
};

enum class ClockAngleT : LobClockAngleT {
  kI = ::kLobClockAngleI,        
  kII = ::kLobClockAngleII,      
  kIII = ::kLobClockAngleIII,    
  kIV = ::kLobClockAngleIV,      
  kV = ::kLobClockAngleV,        
  kVI = ::kLobClockAngleVI,      
  kVII = ::kLobClockAngleVII,    
  kVIII = ::kLobClockAngleVIII,  
  kIX = ::kLobClockAngleIX,      
  kX = ::kLobClockAngleX,        
  kXI = ::kLobClockAngleXI,      
  kXII = ::kLobClockAngleXII     
};

enum class ErrorT : LobErrorT {
  kNone = ::kLobErrorNone,
  kAirPressureOOR = ::kLobErrorAirPressureOOR,
  kAltitudeOfBarometerOOR = ::kLobErrorAltitudeOfBarometerOOR,
  kAltitudeOfFiringSiteOOR = ::kLobErrorAltitudeOfFiringSiteOOR,
  kAltitudeOfThermometerOOR = ::kLobErrorAltitudeOfThermometerOOR,
  kAzimuthOOR = ::kLobErrorAzimuthOOR,
  kBallisticCoefficientOOR = ::kLobErrorBallisticCoefficientOOR,
  kBallisticCoefficientRequired = ::kLobErrorBallisticCoefficientRequired,
  kBaseDiameterOOR = ::kLobErrorBaseDiameterOOR,
  kBcBandsInvalid = ::kLobErrorBcBandsInvalid,
  kBcBandsNotMonotonic = ::kLobErrorBcBandsNotMonotonic,
  kBcBandsTooShort = ::kLobErrorBcBandsTooShort,
  kDiameterOOR = ::kLobErrorDiameterOOR,
  kHumidityOOR = ::kLobErrorHumidityOOR,
  kInitialVelocityRequired = ::kLobErrorInitialVelocityRequired,
  kInternalError = ::kLobErrorInternalError,
  kLatitudeOOR = ::kLobErrorLatitudeOOR,
  kLengthOOR = ::kLobErrorLengthOOR,
  kMachDragTableInvalid = ::kLobErrorMachDragTableInvalid,
  kMachDragTableNotMonotonic = ::kLobErrorMachDragTableNotMonotonic,
  kMachDragTableTooShort = ::kLobErrorMachDragTableTooShort,
  kMassOOR = ::kLobErrorMassOOR,
  kMaximumTimeOOR = ::kLobErrorMaximumTimeOOR,
  kMeplatDiameterOOR = ::kLobErrorMeplatDiameterOOR,
  kNoseLengthOOR = ::kLobErrorNoseLengthOOR,
  kNotFormed = ::kLobErrorNotFormed,
  kOgiveRtROOR = ::kLobErrorOgiveRtROOR,
  kRangeAngleOOR = ::kLobErrorRangeAngleOOR,
  kSplineCoefsInvalid = ::kLobErrorSplineCoefsInvalid,
  kTailLengthOOR = ::kLobErrorTailLengthOOR,
  kWindHeadingOOR = ::kLobErrorWindHeadingOOR,
  kWindProfileInvalid = ::kLobErrorWindProfileInvalid,
  kWindProfileNotMonotonic = ::kLobErrorWindProfileNotMonotonic,
  kWindProfileTooLong = ::kLobErrorWindProfileTooLong,
  kZeroAngleOOR = ::kLobErrorZeroAngleOOR,
  kZeroDataRequired = ::kLobErrorZeroDataRequired,
  kZeroDistanceOOR = ::kLobErrorZeroDistanceOOR,
  kZeroUnreachable = ::kLobErrorZeroUnreachable,
};

using Gravity = ::LobGravity;
using WindPoint = ::LobWindPoint;
using WindNode = ::LobWindNode;
using Coriolis = ::LobCoriolis;
struct Context {
  double drag_coeff;        
  double speed_of_sound;    
  double mass;              
  double optic_height;      
  Gravity gravity;          
  Coriolis coriolis;        
  double zero_angle;        
  double stability_factor;  
  double aerodynamic_jump;  
  double spindrift_factor;  
  double k_lapse;           
  double max_time;          
  std::array<float, kLobCoeffsSize> drags;  
  std::array<WindNode, LOB_WIND_POINTS>
      wind_nodes;              
  double wind_shear_exponent;  
  uint16_t velocity;       
  uint16_t minimum_speed;  
  uint16_t step_size;      
  ErrorT error;            
  uint8_t wind_count;      
};
 
static_assert(sizeof(Context) == sizeof(::LobContext),
              "Context vs LobContext size mismatch");
static_assert(alignof(Context) == alignof(::LobContext),
              "Context vs LobContext alignment mismatch");
static_assert(offsetof(Context, drag_coeff) ==
                  offsetof(::LobContext, drag_coeff),
              "drag_coeff offset drift");
static_assert(offsetof(Context, speed_of_sound) ==
                  offsetof(::LobContext, speed_of_sound),
              "speed_of_sound offset drift");
static_assert(offsetof(Context, mass) == offsetof(::LobContext, mass),
              "mass offset drift");
static_assert(offsetof(Context, optic_height) ==
                  offsetof(::LobContext, optic_height),
              "optic_height offset drift");
static_assert(offsetof(Context, gravity) == offsetof(::LobContext, gravity),
              "gravity offset drift");
static_assert(offsetof(Context, coriolis) == offsetof(::LobContext, coriolis),
              "coriolis offset drift");
static_assert(offsetof(Context, zero_angle) ==
                  offsetof(::LobContext, zero_angle),
              "zero_angle offset drift");
static_assert(offsetof(Context, stability_factor) ==
                  offsetof(::LobContext, stability_factor),
              "stability_factor offset drift");
static_assert(offsetof(Context, aerodynamic_jump) ==
                  offsetof(::LobContext, aerodynamic_jump),
              "aerodynamic_jump offset drift");
static_assert(offsetof(Context, spindrift_factor) ==
                  offsetof(::LobContext, spindrift_factor),
              "spindrift_factor offset drift");
static_assert(offsetof(Context, max_time) == offsetof(::LobContext, max_time),
              "max_time offset drift");
static_assert(offsetof(Context, drags) == offsetof(::LobContext, drags),
              "drags offset drift");
static_assert(offsetof(Context, wind_nodes) ==
                  offsetof(::LobContext, wind_nodes),
              "wind_nodes offset drift");
static_assert(offsetof(Context, wind_shear_exponent) ==
                  offsetof(::LobContext, wind_shear_exponent),
              "wind_shear_exponent offset drift");
static_assert(offsetof(Context, velocity) == offsetof(::LobContext, velocity),
              "velocity offset drift");
static_assert(offsetof(Context, minimum_speed) ==
                  offsetof(::LobContext, minimum_speed),
              "minimum_speed offset drift");
static_assert(offsetof(Context, step_size) == offsetof(::LobContext, step_size),
              "step_size offset drift");
static_assert(offsetof(Context, error) == offsetof(::LobContext, error),
              "error offset drift");
static_assert(offsetof(Context, wind_count) ==
                  offsetof(::LobContext, wind_count),
              "wind_count offset drift");
static_assert(static_cast<::LobErrorT>(ErrorT::kNone) == ::kLobErrorNone,
              "ErrorT kNone value drift");
static_assert(static_cast<::LobErrorT>(ErrorT::kNotFormed) ==
                  ::kLobErrorNotFormed,
              "ErrorT kNotFormed value drift");

using Output = ::LobOutput;
 
inline bool operator==(::LobErrorT a, ErrorT b) noexcept {
  return a == static_cast<::LobErrorT>(b);
}
inline bool operator!=(::LobErrorT a, ErrorT b) noexcept {
  return a != static_cast<::LobErrorT>(b);
}
inline bool operator==(ErrorT a, ::LobErrorT b) noexcept {
  return static_cast<::LobErrorT>(a) == b;
}
inline bool operator!=(ErrorT a, ::LobErrorT b) noexcept {
  return static_cast<::LobErrorT>(a) != b;
}

class Builder {
 public:
  Builder() : builder_{} {
    ::LobBuilderInit(&builder_);
  }  
  ~Builder() { ::LobBuilderDestroy(&builder_); }  
 
  Builder(const Builder& other) : builder_{} {  
    ::LobBuilderCopy(&builder_, &other.builder_);
  }
 
  Builder(Builder&& other) noexcept : builder_{} {  
    ::LobBuilderCopy(&builder_, &other.builder_);
    ::LobBuilderReset(&other.builder_);
  }

  Builder& operator=(const Builder& rhs) {
    if (this != &rhs) {
      ::LobBuilderCopy(&builder_, &rhs.builder_);
    }
    return *this;
  }

  Builder& operator=(Builder&& rhs) noexcept {
    if (this != &rhs) {
      ::LobBuilderCopy(&builder_, &rhs.builder_);
      ::LobBuilderReset(&rhs.builder_);
    }
    return *this;
  }

  Builder& BallisticCoefficientPsi(double value) {
    ::LobBuilderBallisticCoefficientPsi(&builder_, value);
    return *this;
  }

  Builder& BCAtmosphere(AtmosphereReferenceT type) {
    ::LobBuilderBCAtmosphere(&builder_,
                             static_cast<::LobAtmosphereReferenceT>(type));
    return *this;
  }

  Builder& BCAtmosphere(LobAtmosphereReferenceT type) {
    ::LobBuilderBCAtmosphere(&builder_, type);
    return *this;
  }

  Builder& BCDragFunction(DragFunctionT type) {
    ::LobBuilderBCDragFunction(&builder_,
                               static_cast<::LobDragFunctionT>(type));
    return *this;
  }

  Builder& BCDragFunction(LobDragFunctionT type) {
    ::LobBuilderBCDragFunction(&builder_, type);
    return *this;
  }

  Builder& DiameterInch(double value) {
    ::LobBuilderDiameterInch(&builder_, value);
    return *this;
  }

  Builder& MeplatDiameterInch(double value) {
    ::LobBuilderMeplatDiameterInch(&builder_, value);
    return *this;
  }

  Builder& BaseDiameterInch(double value) {
    ::LobBuilderBaseDiameterInch(&builder_, value);
    return *this;
  }

  Builder& LengthInch(double value) {
    ::LobBuilderLengthInch(&builder_, value);
    return *this;
  }

  Builder& NoseLengthInch(double value) {
    ::LobBuilderNoseLengthInch(&builder_, value);
    return *this;
  }

  Builder& TailLengthInch(double value) {
    ::LobBuilderTailLengthInch(&builder_, value);
    return *this;
  }

  Builder& OgiveRtR(double value) {
    ::LobBuilderOgiveRtR(&builder_, value);
    return *this;
  }

  Builder& MachVsDragTable(const float* pmachs, const float* pdrags,
                           size_t size) {
    ::LobBuilderSplineFitTable(&builder_, pmachs, pdrags, size);
    return *this;
  }

  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>& machs,
                           const std::array<float, N>& drags) {
    ::LobBuilderSplineFitTable(&builder_, machs.data(), drags.data(), N);
    return *this;
  }
  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>&& machs,
                           const std::array<float, N>& drags) = delete;
  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>& machs,
                           const std::array<float, N>&& drags) = delete;
  template <size_t N>
  Builder& MachVsDragTable(const std::array<float, N>&& machs,
                           const std::array<float, N>&& drags) = delete;

  Builder& BCVelocityBands(const float* pfps, const float* pbcvs, size_t size) {
    ::LobBuilderBCVelocityBands(&builder_, pfps, pbcvs, size);
    return *this;
  }

  template <size_t N>
  Builder& BCVelocityBands(const std::array<float, N>& fps,
                           const std::array<float, N>& bcvs) {
    ::LobBuilderBCVelocityBands(&builder_, fps.data(), bcvs.data(), N);
    return *this;
  }
  template <size_t N>
  Builder& BCVelocityBands(const std::array<float, N>&& fps,
                           const std::array<float, N>& bcvs) = delete;
  template <size_t N>
  Builder& BCVelocityBands(const std::array<float, N>& fps,
                           const std::array<float, N>&& bcvs) = delete;
  template <size_t N>
  Builder& BCVelocityBands(const std::array<float, N>&& fps,
                           const std::array<float, N>&& bcvs) = delete;

  Builder& SplineCoefficients(const float* pcoefs) {
    ::LobBuilderSplineCoefficients(&builder_, pcoefs);
    return *this;
  }

  Builder& SplineCoefficients(const std::array<float, kLobCoeffsSize>& coefs) {
    ::LobBuilderSplineCoefficients(&builder_, coefs.data());
    return *this;
  }
  Builder& SplineCoefficients(const std::array<float, kLobCoeffsSize>&& coefs) =
      delete;

  Builder& MassGrains(double value) {
    ::LobBuilderMassGrains(&builder_, value);
    return *this;
  }

  Builder& InitialVelocityFps(uint16_t value) {
    ::LobBuilderInitialVelocityFps(&builder_, value);
    return *this;
  }

  Builder& OpticHeightInches(double value) {
    ::LobBuilderOpticHeightInches(&builder_, value);
    return *this;
  }

  Builder& TwistInchesPerTurn(double value) {
    ::LobBuilderTwistInchesPerTurn(&builder_, value);
    return *this;
  }

  Builder& ZeroAngleMOA(double value) {
    ::LobBuilderZeroAngleMOA(&builder_, value);
    return *this;
  }

  Builder& ZeroDistanceYds(double value) {
    ::LobBuilderZeroDistanceYds(&builder_, value);
    return *this;
  }

  Builder& ZeroImpactHeightInches(double value) {
    ::LobBuilderZeroImpactHeightInches(&builder_, value);
    return *this;
  }

  Builder& AltitudeOfFiringSiteFt(double value) {
    ::LobBuilderAltitudeOfFiringSiteFt(&builder_, value);
    return *this;
  }

  Builder& AirPressureInHg(double value) {
    ::LobBuilderAirPressureInHg(&builder_, value);
    return *this;
  }

  Builder& AltitudeOfBarometerFt(double value) {
    ::LobBuilderAltitudeOfBarometerFt(&builder_, value);
    return *this;
  }

  Builder& TemperatureDegF(double value) {
    ::LobBuilderTemperatureDegF(&builder_, value);
    return *this;
  }

  Builder& AltitudeOfThermometerFt(double value) {
    ::LobBuilderAltitudeOfThermometerFt(&builder_, value);
    return *this;
  }

  Builder& RelativeHumidityPercent(double value) {
    ::LobBuilderRelativeHumidityPercent(&builder_, value);
    return *this;
  }

  Builder& WindHeading(ClockAngleT value) {
    ::LobBuilderWindHeading(&builder_, static_cast<::LobClockAngleT>(value));
    return *this;
  }

  Builder& WindHeading(LobClockAngleT value) {
    ::LobBuilderWindHeading(&builder_, value);
    return *this;
  }

  Builder& WindHeadingDeg(double value) {
    ::LobBuilderWindHeadingDeg(&builder_, value);
    return *this;
  }

  Builder& WindSpeedFps(double value) {
    ::LobBuilderWindSpeedFps(&builder_, value);
    return *this;
  }

  Builder& WindSpeedMph(double value) {
    ::LobBuilderWindSpeedMph(&builder_, value);
    return *this;
  }

  Builder& WindProfile(const LobWindPoint* ppoints, size_t count) {
    ::LobBuilderWindProfile(&builder_, ppoints, count);
    return *this;
  }

  template <size_t N>
  Builder& WindProfile(const std::array<LobWindPoint, N>& points) {
    ::LobBuilderWindProfile(&builder_, points.data(), points.size());
    return *this;
  }
  template <size_t N>
  Builder& WindProfile(const std::array<LobWindPoint, N>&& points) = delete;

  Builder& WindShearExponent(double value) {
    ::LobBuilderWindShearExponent(&builder_, value);
    return *this;
  }

  Builder& AzimuthDeg(double value) {
    ::LobBuilderAzimuthDeg(&builder_, value);
    return *this;
  }

  Builder& LatitudeDeg(double value) {
    ::LobBuilderLatitudeDeg(&builder_, value);
    return *this;
  }

  Builder& RangeAngleDeg(double value) {
    ::LobBuilderRangeAngleDeg(&builder_, value);
    return *this;
  }

  Builder& MinimumSpeed(uint16_t value) {
    ::LobBuilderMinimumSpeed(&builder_, value);
    return *this;
  }

  Builder& MinimumEnergy(uint16_t value) {
    ::LobBuilderMinimumEnergy(&builder_, value);
    return *this;
  }

  Builder& MaximumTime(double value) {
    ::LobBuilderMaximumTime(&builder_, value);
    return *this;
  }

  Builder& StepSize(uint16_t value) {
    ::LobBuilderStepSize(&builder_, value);
    return *this;
  }

  Builder& Reset() noexcept {
    ::LobBuilderReset(&builder_);
    return *this;
  }

  Context Build() {
    Context result{};
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    ::LobBuilderBuild(&builder_, reinterpret_cast<::LobContext*>(&result));
    return result;
  }
 
 private:
  ::LobBuilder builder_;
};

inline size_t Solve(const Context& ctx, const uint32_t* pranges, Output* pouts,
                    size_t size) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolve(reinterpret_cast<const ::LobContext*>(&ctx), pranges, pouts,
                    size);
}

template <size_t N>
inline size_t Solve(const Context& ctx, const std::array<uint32_t, N>& ranges,
                    std::array<Output, N>* pouts) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolve(reinterpret_cast<const ::LobContext*>(&ctx), ranges.data(),
                    pouts->data(), N);
}

inline size_t Solve(const Context& ctx, uint32_t range, Output* pout) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolve(reinterpret_cast<const ::LobContext*>(&ctx), &range, pout,
                    1);
}

inline size_t FastInverse(const Context& ctx, Output* pouts, size_t size) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobFastInverse(reinterpret_cast<const ::LobContext*>(&ctx), pouts,
                          size);
}

template <size_t N>
inline size_t FastInverse(const Context& ctx, std::array<Output, N>* pouts) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobFastInverse(reinterpret_cast<const ::LobContext*>(&ctx),
                          pouts->data(), N);
}

inline size_t FastInverse(const Context& ctx, Output* pout) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobFastInverse(reinterpret_cast<const ::LobContext*>(&ctx), pout, 1);
}

inline size_t SolveInverse(const Context& ctx, const uint32_t* pranges,
                           Output* pouts, size_t size) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolveInverse(reinterpret_cast<const ::LobContext*>(&ctx), pranges,
                           pouts, size);
}

template <size_t N>
inline size_t SolveInverse(const Context& ctx,
                           const std::array<uint32_t, N>& ranges,
                           std::array<Output, N>* pouts) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolveInverse(reinterpret_cast<const ::LobContext*>(&ctx),
                           ranges.data(), pouts->data(), N);
}

inline size_t SolveInverse(const Context& ctx, uint32_t range, Output* pout) {
  // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
  return ::LobSolveInverse(reinterpret_cast<const ::LobContext*>(&ctx), &range,
                           pout, 1);
}

inline const char* Version() { return ::LobVersion(); }

inline double MoaToMil(double value) { return ::LobMoaToMil(value); }
inline double MoaToDeg(double value) { return ::LobMoaToDeg(value); }
inline double MoaToIphy(double value) { return ::LobMoaToIphy(value); }
inline double MoaToInch(double value, double range_ft) {
  return ::LobMoaToInch(value, range_ft);
}

inline double MilToMoa(double value) { return ::LobMilToMoa(value); }
inline double MilToDeg(double value) { return ::LobMilToDeg(value); }
inline double MilToIphy(double value) { return ::LobMilToIphy(value); }
inline double MilToInch(double value, double range_ft) {
  return ::LobMilToInch(value, range_ft);
}

inline double DegToMoa(double value) { return ::LobDegToMoa(value); }
inline double DegToMil(double value) { return ::LobDegToMil(value); }

inline double InchToMoa(double value, double range_ft) {
  return ::LobInchToMoa(value, range_ft);
}

inline double InchToMil(double value, double range_ft) {
  return ::LobInchToMil(value, range_ft);
}

inline double InchToDeg(double value, double range_ft) {
  return ::LobInchToDeg(value, range_ft);
}

inline double JToFtLbs(double value) { return ::LobJToFtLbs(value); }
inline double FtLbsToJ(double value) { return ::LobFtLbsToJ(value); }

inline double MToYd(double value) { return ::LobMToYd(value); }

inline double YdToFt(double value) { return ::LobYdToFt(value); }
inline double MToFt(double value) { return ::LobMToFt(value); }
inline double FtToIn(double value) { return ::LobFtToIn(value); }
inline double MmToIn(double value) { return ::LobMmToIn(value); }
inline double CmToIn(double value) { return ::LobCmToIn(value); }
inline double YdToM(double value) { return ::LobYdToM(value); }
inline double FtToM(double value) { return ::LobFtToM(value); }
inline double FtToYd(double value) { return ::LobFtToYd(value); }
inline double InToMm(double value) { return ::LobInToMm(value); }
inline double InToCm(double value) { return ::LobInToCm(value); }
inline double InToFt(double value) { return ::LobInToFt(value); }

inline double PaToInHg(double value) { return ::LobPaToInHg(value); }
inline double MbarToInHg(double value) { return ::LobMbarToInHg(value); }
inline double PsiToInHg(double value) { return ::LobPsiToInHg(value); }

inline double LbsToGrain(double value) { return ::LobLbsToGrain(value); }
inline double GToGrain(double value) { return ::LobGToGrain(value); }
inline double KgToGrain(double value) { return ::LobKgToGrain(value); }

inline double KgSqMToPmsi(double value) { return ::LobKgSqMToPmsi(value); }

inline double FpsToMps(double value) { return ::LobFpsToMps(value); }
inline double MpsToFps(double value) { return ::LobMpsToFps(value); }
inline double KphToMph(double value) { return ::LobKphToMph(value); }
inline double KnToMph(double value) { return ::LobKnToMph(value); }

inline double MsToS(double value) { return ::LobMsToS(value); }
inline double UsToS(double value) { return ::LobUsToS(value); }
inline double SToMs(double value) { return ::LobSToMs(value); }
inline double SToUs(double value) { return ::LobSToUs(value); }

inline double DegCToDegF(double value) { return ::LobDegCToDegF(value); }
 
}  // namespace lob
 
// This file is part of lob.
//
// lob is free software: you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// lob is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
// A PARTICULAR PURPOSE. See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License along with
// lob. If not, see <https://www.gnu.org/licenses/>.