survey.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once

 
#include <array>
#include <cstddef>
#include <cstdint>
#include <map>
#include <optional>
#include <stdexcept>
#include <string>
#include <string_view>
#include <vector>
 
namespace reusex::core {
 
enum class Treatment {
  bevaring,
  genbrug,
  genanvendelse,
  nyttiggoerelse,
  bortskaffelse
};
inline constexpr std::size_t kTreatmentCount = 5;
inline constexpr int kManualSemanticClass = -2;
inline constexpr std::string_view kDefaultInstanceCloud = "instances";
enum class ReviewStatus { queue, approved, rejected };
enum class SampleStage { planlagt, udtaget, sendt, svar };
enum class SampleResult { none, ren, forurenet };
enum class EnvironmentStatus {
  ren_screening,
  afventer,
  forurenet,
  ren_proevesvar
};
 
std::string_view to_string(Treatment);
std::string_view to_string(ReviewStatus);
std::string_view to_string(SampleStage);
std::string_view to_string(SampleResult); // none -> ""
std::string_view to_string(EnvironmentStatus);
std::string_view treatment_label_da(Treatment);
std::string_view environment_label_da(EnvironmentStatus);
std::optional<Treatment> treatment_from_string(std::string_view);
std::optional<ReviewStatus> review_status_from_string(std::string_view);
std::optional<SampleStage> sample_stage_from_string(std::string_view);
std::optional<SampleResult>
    sample_result_from_string(std::string_view); // "" -> none
 
struct SampleState {
  SampleStage stage = SampleStage::planlagt;
  SampleResult result = SampleResult::none;
};
void validate_sample_state(const SampleState &); // throws std::invalid_argument
EnvironmentStatus environment_status(const std::vector<SampleState> &linked);
 
class SamplePendingError : public std::runtime_error {
    public:
  using std::runtime_error::runtime_error;
};

class NameConflictError : public std::runtime_error {
    public:
  using std::runtime_error::runtime_error;
};
 
struct TypeTotals {
  Treatment treatment = Treatment::genanvendelse;
  ReviewStatus status = ReviewStatus::queue;
  std::optional<double> mass_t;
  std::string eak_code;
  EnvironmentStatus environment = EnvironmentStatus::ren_screening;
  std::int64_t type_id = 0;
  std::string name{};
};
std::array<double, kTreatmentCount>
circularity_breakdown(const std::vector<TypeTotals> &);
struct Fraction {
  std::string eak_code;
  std::string name;
  Treatment treatment;
  double mass_t = 0.0;
  bool contaminated = false;
};

enum class BlockingReason { review, sample, mass };
std::string_view to_string(BlockingReason); // "review" | "sample" | "mass"
struct BlockingType {
  std::int64_t type_id = 0;
  std::string name;
  std::string eak_code;
  Treatment treatment = Treatment::genanvendelse;
  std::optional<double> mass_t;
  BlockingReason reason = BlockingReason::review;
};
struct FractionReport {
  std::vector<Fraction> fractions;
  double total_t = 0.0;
  std::size_t blocking_types = 0; // == blocking.size()
  std::vector<BlockingType> blocking;
};

bool reportable(ReviewStatus status, EnvironmentStatus environment);
FractionReport fractions_by_eak(const std::vector<TypeTotals> &);
std::string_view eak_fraction_name(std::string_view code); // "" when unknown
std::map<std::uint32_t, std::uint32_t>
majority_room(const std::vector<std::uint32_t> &instance_labels,
              const std::vector<std::uint32_t> &room_labels);
std::vector<double> redistribute_quantity(const std::vector<double> &current,
                                          double total);
std::string part_code(int number);   // 1 -> "RX-001"
std::string sample_code(int number); // 1 -> "P-01"
 
} // namespace reusex::core