raphael
711ee1b40f
The god-class is gone. Each capability is now its own focused store:
StatusVariableStore, DataVariableStore, EquipmentConstantStore (with EAC
range validation), EventReportSubscriptions, AlarmRegistry, RecipeStore,
Clock, HostCommandRegistry. Each is independently testable.
EquipmentDataModel becomes a small composite that holds one of each store
as a public member, plus three convenience methods (vid_value, vid_exists,
compose_reports_for) that span SVIDs+DVIDs and inject the right callbacks
into the EventReportSubscriptions.
New under include/secsgem/gem/store/:
status_variables.hpp StatusVariable, StatusVariableStore,
DataVariable, DataVariableStore
equipment_constants.hpp EquipmentConstant, EquipmentConstantStore,
EquipmentAck. set_value() now validates
numeric values against min_str/max_str and
returns EAC=4 on out-of-range — closes the
COMPLIANCE.md gap about EC range validation.
event_reports.hpp CollectionEvent, Report, ReportData,
EventReportSubscriptions + DefineReportAck,
LinkEventAck, EnableEventAck. The store is
pure data; VidLookup / VidExists callbacks
are injected at define / emit time so the
service doesn't back-reference the SVID
store.
alarms.hpp Alarm, AlarmAck, AlarmRegistry.
Encapsulates the (enabled, active) sets and
ALCD byte computation.
recipes.hpp ProcessProgramAck, RecipeStore.
clock.hpp TimeAck, Clock. set_time_string applies an
offset so subsequent reads reflect the host
time without mutating system clock.
host_commands.hpp HostCmdAck, CommandParameter,
HostCommandRegistry with Spec/Result types.
include/secsgem/gem/data_model.hpp shrinks to a 50-line composite:
struct EquipmentDataModel {
StatusVariableStore svids;
DataVariableStore dvids;
EquipmentConstantStore ecids;
EventReportSubscriptions events;
AlarmRegistry alarms;
RecipeStore recipes;
Clock clock;
HostCommandRegistry commands;
/* + vid_value, vid_exists, compose_reports_for sugar */
};
src/gem/data_model.cpp is gone — every store is inline header-only.
include/secsgem/gem/messages_helpers.hpp picks up EventReportAck and
TerminalAck (S6F12 / S10F2-F4 ack enums that aren't tied to any one
store).
Call-site updates:
apps/secs_server.cpp model->status_variable(id) -> model->svids.get(id),
model->equipment_constant(id) -> model->ecids.get(id),
model->alarm_set(id) -> model->alarms.set_active(id),
model->dispatch_command(...) -> model->commands.dispatch(...),
and similar across every handler. Plus
model->current_time_string() -> model->clock....
src/config/loader.cpp model.add_status_variable(sv) -> model.svids.add(sv),
and similar. HostCommandRegistry::Spec replaces
EquipmentDataModel::CommandSpec.
apps/secs_client.cpp std::vector<EquipmentDataModel::CommandParam> ->
std::vector<CommandParameter>.
tests/test_data_model.cpp Rewritten around the individual stores;
each gets its own TEST_CASE block. Adds three
new cases covering EC range validation (in
range / out of range / non-numeric skipped).
tests/test_loader.cpp m.has_event(100) -> m.events.has_event(100),
etc.
Verified:
- Tests: 69 cases / 370 assertions pass (was 67 / 384; -14 stale
composite-API assertions + 16 new store-level assertions covering
EC range validation and the per-store add/get/list/delete paths).
- Demo: byte-identical behaviour across the full 17-step flow.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
79 lines
2.2 KiB
C++
79 lines
2.2 KiB
C++
#pragma once
|
|
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
#include <ctime>
|
|
#include <string>
|
|
|
|
namespace secsgem::gem {
|
|
|
|
enum class TimeAck : uint8_t {
|
|
Accept = 0,
|
|
Error = 1,
|
|
NotDoneNotEmpty = 2,
|
|
};
|
|
|
|
// The equipment clock. current_time_string() returns the 16-char SECS-II
|
|
// TIME format ("YYYYMMDDhhmmsscc"), with an offset applied if the host has
|
|
// previously set the time via S2F31.
|
|
class Clock {
|
|
public:
|
|
std::string current_time_string() const {
|
|
using namespace std::chrono;
|
|
const auto now = system_clock::now() + seconds(offset_seconds_);
|
|
const auto t = system_clock::to_time_t(now);
|
|
const auto ms = duration_cast<milliseconds>(now.time_since_epoch()) % 1000;
|
|
|
|
std::tm tm{};
|
|
gmtime_r(&t, &tm);
|
|
|
|
std::array<char, 64> buf{};
|
|
std::snprintf(buf.data(), buf.size(), "%04d%02d%02d%02d%02d%02d%02d",
|
|
tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
|
|
tm.tm_hour, tm.tm_min, tm.tm_sec,
|
|
static_cast<int>(ms.count() / 10));
|
|
return std::string(buf.data());
|
|
}
|
|
|
|
TimeAck set_time_string(const std::string& s) {
|
|
if (s.size() != 14 && s.size() != 16) return TimeAck::Error;
|
|
int y, mo, d, h, mi, se;
|
|
if (!parse_digits(s.data() + 0, 4, y) ||
|
|
!parse_digits(s.data() + 4, 2, mo) ||
|
|
!parse_digits(s.data() + 6, 2, d) ||
|
|
!parse_digits(s.data() + 8, 2, h) ||
|
|
!parse_digits(s.data() + 10, 2, mi) ||
|
|
!parse_digits(s.data() + 12, 2, se)) {
|
|
return TimeAck::Error;
|
|
}
|
|
std::tm tm{};
|
|
tm.tm_year = y - 1900;
|
|
tm.tm_mon = mo - 1;
|
|
tm.tm_mday = d;
|
|
tm.tm_hour = h;
|
|
tm.tm_min = mi;
|
|
tm.tm_sec = se;
|
|
const std::time_t target = timegm(&tm);
|
|
if (target == static_cast<std::time_t>(-1)) return TimeAck::Error;
|
|
offset_seconds_ = static_cast<std::int64_t>(target - std::time(nullptr));
|
|
return TimeAck::Accept;
|
|
}
|
|
|
|
private:
|
|
static bool parse_digits(const char* p, std::size_t n, int& out) {
|
|
int v = 0;
|
|
for (std::size_t i = 0; i < n; ++i) {
|
|
if (p[i] < '0' || p[i] > '9') return false;
|
|
v = v * 10 + (p[i] - '0');
|
|
}
|
|
out = v;
|
|
return true;
|
|
}
|
|
|
|
std::int64_t offset_seconds_ = 0;
|
|
};
|
|
|
|
} // namespace secsgem::gem
|