RMSerialization.h

Go to the documentation of this file.

// RMSerialization.h — Non-intrusive Boost serialization for all ReasonMachine classes
// MUST be included AFTER ReasonMachine.h (needs full class definitions).
// All RM class members are public, so non-intrusive serialization works without friend access.
// Cross-reference pointers (that point into pools) are NOT serialized — only string IDs are.
// BuildTheConnectionsWithinRM() reconnects pointers from IDs after the copy step.
 
#pragma once
 
#include <boost/serialization/serialization.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/unique_ptr.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/base_object.hpp>
 
// All class definitions come from ReasonMachine.h include chain.
// Additional headers for types not in the main chain:
#include "MRValueSchema.h"
#include "MRStateSchema.h"
#include "TimeRange.h"
#include "SymptomCase.h"
#include "TimeValueNoteUnit.h"
#include "KBConceptBaseDataSetUnit.h"
#include "Label.h"
#include "Instantiation.h"
#include "EventSymptomUnit.h"
#include "RoutineMonitorUnit.h"
 
namespace boost { namespace serialization {
 
// ============================================================
// Leaf classes (no sub-objects needing serialization)
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, Activation & a, const unsigned int) {
    ar & a.m_change_ratio; ar & a.m_activation_baseline;
    ar & a.m_activation; ar & a.m_old_activation;
}
 
template<class Archive>
void serialize(Archive & ar, TimeRange & t, const unsigned int) {
    ar & t.m_time_after; ar & t.m_time_before;
    ar & t.m_end_time; ar & t.m_start_time;
}
 
template<class Archive>
void serialize(Archive & ar, IDElement & e, const unsigned int) {
    ar & e.m_ID_Type; ar & e.m_ID;
}
 
template<class Archive>
void serialize(Archive & ar, ValueTimeLineUnit & v, const unsigned int) {
    ar & v.m_type; ar & v.m_time; ar & v.m_fl; ar & v.m_int;
}
 
template<class Archive>
void serialize(Archive & ar, StringTimeIntervalUnit & s, const unsigned int) {
    ar & s.m_interrupted_bl; ar & s.m_name;
    ar & s.m_interval_start; ar & s.m_interval_end;
    ar & s.m_thought_line_list;
}
 
template<class Archive>
void serialize(Archive & ar, ProximityGroupUnit & p, const unsigned int) {
    ar & p.m_n_members; ar & p.indication_concept_ID_list;
}
 
template<class Archive>
void serialize(Archive & ar, ProximityModel & p, const unsigned int) {
    ar & p.m_prox_unit_list; ar & p.m_operator;
}
 
// ============================================================
// SentenceUnit (IDElement + Activation) — serialize string IDs, skip raw ptrs
// ============================================================
template<class Archive>
void serialize(Archive & ar, SentenceUnit & s, const unsigned int) {
    ar & base_object<IDElement>(s);
    ar & base_object<Activation>(s);
    ar & s.m_value; ar & s.m_Negation_bl;
    ar & s.m_delta_value; ar & s.m_sentence_type;
    // String IDs (pointers reconnected by BuildTheConnectionsWithinRM)
    ar & s.m_ID_state; ar & s.m_ID_subject;
    ar & s.m_ID_process; ar & s.m_ID_object;
    ar & s.m_ID_comparison; ar & s.m_ID_attribute;
}
 
// ============================================================
// KnowledgeElement (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, KnowledgeElement & k, const unsigned int) {
    ar & base_object<IDElement>(k);
    ar & k.m_operator; ar & k.m_negation; ar & k.m_satisfied;
    ar & k.m_ID_sent;
}
 
// ============================================================
// KnowledgeNode (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, KnowledgeNode & k, const unsigned int) {
    ar & base_object<IDElement>(k);
    ar & k.m_operator; ar & k.m_Node_Type;
    ar & k.m_ID_KE_list;
    // Skip M_KElement_list (raw ptrs) — rebuilt from IDs
}
 
// ============================================================
// KnowledgeUnit (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, KnowledgeUnit & k, const unsigned int) {
    ar & base_object<IDElement>(k);
    ar & k.m_ID_desscendant; ar & k.m_ID_anscestor; ar & k.m_ID_permission;
    ar & k.m_deltaT1; ar & k.m_deltaT2;
    ar & k.m_backward_retrieve_weight; ar & k.m_forward_retrieve_weight;
    ar & k.m_knowledge_strength;
    ar & k.m_operator; ar & k.m_accessable_bl;
    ar & k.m_inference_type; ar & k.m_causal_type; ar & k.m_mechanism_type;
}
 
// ============================================================
// Statement (IDElement + Activation)
// ============================================================
template<class Archive>
void serialize(Archive & ar, Statement & s, const unsigned int) {
    ar & base_object<IDElement>(s);
    ar & base_object<Activation>(s);
    ar & s.m_operator; ar & s.m_factual_type;
    ar & s.m_confidence; ar & s.m_state;
    ar & s.m_last_activated_time; ar & s.m_time_generated;
    ar & s.m_ongoing_bl; ar & s.m_tbi_bl;
    ar & s.m_time_range;
    ar & s.m_ID_investigator; ar & s.m_ID_sentence; ar & s.m_ID_DI;
    ar & s.m_ID_upperstream_statement_list;
    ar & s.m_ID_downstream_statement_list;
}
 
// ============================================================
// Investigator (IDElement) — many fields, serialize IDs not ptrs
// ============================================================
template<class Archive>
void serialize(Archive & ar, Investigator & inv, const unsigned int) {
    ar & base_object<IDElement>(inv);
    ar & inv.m_last_time_of_refreshing_inference_item;
    ar & inv.m_timer; ar & inv.m_probability_update_time;
    ar & inv.m_active_investigation;
    ar & inv.m_ID_has_move_to_link;
    ar & inv.m_pause_confidence_propagation_ID_list;
    ar & inv.m_paused_confidence_passing_list;
    ar & inv.m_Happen_incomplete; ar & inv.m_Explain_incomplete;
    ar & inv.m_thoughtline_roots_list;
    ar & inv.m_root_of_a_thought_line;
    ar & inv.m_last_active_time;
    ar & inv.m_investigation_closed; ar & inv.m_has_moved_to_an_upperstream;
    ar & inv.m_read_requested_bl; ar & inv.m_motivation;
    ar & inv.m_read_value_or_rate_bl;
    ar & inv.m_invest_dormant; ar & inv.m_invest_pause;
    ar & inv.m_phenomenon_onging; ar & inv.m_abort;
    ar & inv.m_operator; ar & inv.m_investigator_token;
    ar & inv.m_explained; ar & inv.m_Happen;
    ar & inv.m_investigation_cease_time; ar & inv.m_investigation_initiate_time;
    ar & inv.m_effective_end; ar & inv.m_effective_start;
    ar & inv.m_independent_probability;
    ar & inv.m_interest_from_SymptomInvestigator;
    ar & inv.m_note; ar & inv.m_abort_reason;
    // String IDs
    ar & inv.m_ID_inconsist_statement; ar & inv.m_ID_SI;
    ar & inv.m_ID_KE; ar & inv.m_ID_statement;
    ar & inv.m_ID_possible_statement;
    ar & inv.m_investigator_token_history;
    ar & inv.m_invest_token_endtime_history;
    // String ID vectors
    ar & inv.m_ID_read_indication_list;
    ar & inv.m_ID_feedback_list;
    ar & inv.m_ID_upperstream_list;
    ar & inv.m_ID_downstream_list;
    ar & inv.m_ID_explanation_link_list;
    ar & inv.m_ID_possible_explanation_link_list;
    ar & inv.m_ID_rejected_explanation_list;
    ar & inv.m_note_list;
}
 
// ============================================================
// InvestigatorLink (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, InvestigatorLink & il, const unsigned int) {
    ar & base_object<IDElement>(il);
    ar & il.m_has_feedback_to_downstream;
    ar & il.m_link_last_activated_time;
    ar & il.m_forgotten_bl;
    ar & il.m_ID_has_moved_to_invest;
    ar & il.m_is_a_strong_inference; ar & il.m_Happen_incomplete;
    ar & il.m_thoughtline_roots_list;
    ar & il.m_invest_link_dormant;
    ar & il.m_operator; ar & il.m_invest_link_Token;
    ar & il.m_invest_link_pause;
    ar & il.m_is_inference_path_bl; ar & il.m_is_causal_path_bl;
    ar & il.m_interest_from_SymptomInvestigator;
    ar & il.m_path_status; ar & il.m_link_type;
    ar & il.m_pause_confidence_propagation_ID_list;
    ar & il.m_paused_confidence_passing_list;
    // String IDs
    ar & il.m_ID_SI; ar & il.m_ID_KU;
    ar & il.m_ID_downstream; ar & il.m_ID_condition;
    ar & il.m_invest_link_Token_history;
    ar & il.m_link_token_endtime_history;
    ar & il.m_ID_upperstream_list;
    ar & il.m_ID_explanation_list;
    ar & il.m_ID_confirmed_invest_list;
    ar & il.m_ID_rejected_invest_list;
    ar & il.m_ID_possible_invest_list;
    ar & il.m_note_list;
}
 
// ============================================================
// EventSchemaUnit (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, EventSchemaUnit & esu, const unsigned int) {
    ar & base_object<IDElement>(esu);
    ar & esu.m_diagnose_claim_threshold; ar & esu.m_max_delay;
    ar & esu.m_operator;
    ar & esu.m_ID_KE;
    ar & esu.m_procedure_step_name; ar & esu.m_procedure_name;
    // Skip m_procedure_step_pt and m_event_KE_pt (cross-references)
    // Skip m_symptom_list (EventSymptomUnit — rebuilt during initialization)
}
 
// ============================================================
// DiagnoseInvestigator (IDElement) — the CRITICAL class for WhetherItIsNormalOperating
// ============================================================
template<class Archive>
void serialize(Archive & ar, DiagnoseInvestigator & di, const unsigned int) {
    ar & base_object<IDElement>(di);
    ar & di.m_wm_type; ar & di.m_wm_i; ar & di.m_operator;
    ar & di.m_contain_transfer_point_to_associate_procedure_bl;
    ar & di.m_claim_bl;  // THE critical field
    ar & di.m_procedure_entered_bl;
    ar & di.m_branching1_prob;
    ar & di.m_branching_2_1_prob; ar & di.m_branching_2_2_prob;
    ar & di.m_branching_3_1_prob; ar & di.m_branching_3_2_prob;
    ar & di.m_diagnose_claim_threshold;
    ar & di.m_claim_time; ar & di.m_attention_level;
    ar & di.m_confidence;
    ar & di.m_wm_i_list; ar & di.m_wm_type_list;
    ar & di.m_confidence_history; ar & di.m_confidence_timeline;
    ar & di.m_Integrated_prob_list; ar & di.m_coverage_list;
    ar & di.m_N_setback_list; ar & di.m_N_disabled_list; ar & di.m_N_voided_list;
    ar & di.m_symp_confidence_list;
    ar & di.m_n_hard_setback; ar & di.m_terminate_investigation;
    ar & di.m_confidence_from_others; ar & di.m_coverage_coefficient;
    // String IDs
    ar & di.m_wm_procedure_name; ar & di.m_wm_procedure_step_name;
    ar & di.m_procedure_name; ar & di.m_procedure_step_name;
    ar & di.m_ID_tbi_SI; ar & di.m_ID_ongoing_SI;
    ar & di.m_ID_label; ar & di.m_ID_KE;
    ar & di.m_ID_es; ar & di.m_ID_statement;
    // Skip pointer members — reconnected via BuildTheConnectionsWithinRM
    // Skip m_symptom_invest_list, m_branching_info_list, m_branching_history_list
    // Skip m_other_evidence_list — rebuilt during execution
}
 
// ============================================================
// SymptomInvestigator (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, SymptomInvestigator & si, const unsigned int) {
    ar & base_object<IDElement>(si);
    ar & si.m_can_not_explain_opposite_bl;
    ar & si.m_opposite_KE_ID;
    ar & si.m_need_to_invest_opposite_bl;
    ar & si.m_ID_DI; ar & si.m_operator;
    ar & si.m_independent_symptom_probability;
    ar & si.m_attention_level; ar & si.m_last_case_end_time;
    ar & si.m_ID_lable; ar & si.m_ID_esu; ar & si.m_ID_KE;
    ar & si.m_ID_ongoing_invest_list; ar & si.m_ID_ongoing_invest_link_list;
    // Skip pointer members and case lists — rebuilt during execution
}
 
// ============================================================
// EventSchemaBase (IDElement)
// ============================================================
template<class Archive>
void serialize(Archive & ar, EventSchemaBase & esb, const unsigned int) {
    ar & base_object<IDElement>(esb);
    ar & esb.m_operator;
    ar & esb.m_diagnose_claim_threshold; ar & esb.m_timing;
    ar & esb.m_ID_timed_DI;
    ar & esb.m_event_schema_list;
    ar & esb.m_diagnose_invest_list;
    ar & esb.m_debug_info;
    ar & esb.m_ID_interested_invest_list;
    ar & esb.m_ID_interested_invest_link_list;
    // Skip pointer cross-references — reconnected by BuildTheConnectionsWithinRM
}
 
// ============================================================
// KBConcept — complex, serialize owned sub-objects
// ============================================================
template<class Archive>
void serialize(Archive & ar, KBConcept & kb, const unsigned int) {
    ar & kb.m_operator;
    ar & kb.m_BasicConcept_list;
    ar & kb.m_ComposedConcept_list;
    ar & kb.m_data_array;
    // m_BasicConcept_updated_list and m_ComposedConcept_updated_list are runtime state
    // Pointer members (m_stable_pt, m_smaller_pt, etc.) point into concept lists — skip
}
 
// ============================================================
// InstantiationBase
// ============================================================
template<class Archive>
void serialize(Archive & ar, InstantiationBase & ib, const unsigned int) {
    ar & ib.m_operator;
    ar & ib.m_label_list;
    ar & ib.m_instantiation_list;
}
 
// ============================================================
// MentalRepresentation
// ============================================================
template<class Archive>
void serialize(Archive & ar, MentalRepresentation & mr, const unsigned int) {
    ar & mr.m_operator;
    ar & mr.m_check_value_or_rate; ar & mr.m_first_round_initiated_bl;
    ar & mr.m_MRParameter_list; ar & mr.m_MRComponent_list;
    ar & mr.m_MRSupportSystem_list; ar & mr.m_MRAlarm_list;
    // Skip iterators — runtime state
}
 
// ============================================================
// RoutineMonitor
// ============================================================
template<class Archive>
void serialize(Archive & ar, RoutineMonitor & rm, const unsigned int) {
    ar & rm.m_read_value_or_rate; ar & rm.m_operator;
    ar & rm.m_time_cost_for_C; ar & rm.m_time_cost_for_P;
    ar & rm.m_time_cost_for_A; ar & rm.m_time_cost_for_SS;
    ar & rm.m_routine_monitor_Token;
    ar & rm.m_monitor_list;
    // Skip m_workon_unit_pt — cross-reference into m_monitor_list
}
 
// ============================================================
// PassiveAlarmLoadUnit
// ============================================================
template<class Archive>
void serialize(Archive & ar, PassiveAlarmLoadUnit & pa, const unsigned int) {
    ar & pa.m_passive_alarm_load_timeline;
    ar & pa.m_alarm_capacity; ar & pa.m_alarm_load_value;
    ar & pa.m_operator; ar & pa.m_stack_size;
    ar & pa.m_No_of_alarms_history; ar & pa.m_alarm_time_history;
}
 
// ============================================================
// ReasonMachine — the top-level class
// Serializes exactly what CopyReasonMachineFromAnotherRM copies
// ============================================================
template<class Archive>
void serialize(Archive & ar, ReasonMachine & rm, const unsigned int) {
    // Primitive fields
    ar & rm.m_alarm_disruption_time_consumption;
    ar & rm.m_block_alarm_jam; ar & rm.m_consumed_time;
    ar & rm.m_decay_constant_lamda; ar & rm.m_decay_lamda;
    ar & rm.m_first_round_check_done;
    ar & rm.m_Interpretation_time_consumption;
    ar & rm.m_leisure_time; ar & rm.m_max_length_of_alarms_stack;
    ar & rm.m_operator; ar & rm.m_RM_Token;
    ar & rm.m_time_length; ar & rm.m_timer_RM;
    ar & rm.m_problem_solving_style;
    ar & rm.m_ability_of_integrating_evidence;
    ar & rm.m_attention_span; ar & rm.m_memory_span;
    ar & rm.m_interuptiveness; ar & rm.m_goofy_start_time;
    ar & rm.m_initial_fatigue_level; ar & rm.m_fatigue_level;
    ar & rm.m_diagnosis_complexity; ar & rm.m_expert_level;
    ar & rm.m_cognitive_load; ar & rm.m_overall_stress;
    ar & rm.m_routine_monitor_threshold;
    ar & rm.m_cognitive_resource_use; ar & rm.m_system_dynamic_level;
    ar & rm.m_load_stress_integration_of_time;
    ar & rm.m_attention_span_base_value; ar & rm.m_memory_span_base_value;
    ar & rm.m_decay_time_base_value;
    ar & rm.m_routine_monitor_interval_multiplier; ar & rm.m_decay_time;
    ar & rm.m_cognitive_time_cost_multiplier;
    ar & rm.m_cognitive_time_cost_base_multiplier;
    ar & rm.m_buffer_used_bl;
    ar & rm.m_investigator_link_number;
    ar & rm.m_statement_number; ar & rm.m_investigator_number;
 
    // Simple vectors
    ar & rm.m_RM_Token_history;
    ar & rm.m_RM_token_endtime_history;
    ar & rm.m_ongoing_item_stack;
 
    // String IDs for pointer reconstruction
    ar & rm.m_ID_working_on_invest;
    ar & rm.m_ID_working_on_invest_link;
    ar & rm.m_ID_reading_indication;
    ar & rm.m_ID_buffer_invest_pt;
 
    // String ID vectors for categorized pools
    ar & rm.m_ID_unresolved_invest_pool;
    ar & rm.m_ID_resolved_invest_pool;
    ar & rm.m_ID_succes_invest_pool;
    ar & rm.m_ID_failed_invest_pool;
    ar & rm.m_ID_undertermined_invest_pool;
    ar & rm.m_ID_discarded_invest_pool;
    ar & rm.m_ID_cause_undertermined_invest_pool;
    ar & rm.m_ID_feedback_stack;
    ar & rm.m_ID_invest_trace;
    ar & rm.m_decayed_item_ID_list;
    ar & rm.m_ID_temporary_statement_list;
    ar & rm.m_ID_new_statement_list;
 
    // Owned pointer objects (Boost handles allocation)
    ar & rm.m_current_thought_line_info;
    ar & rm.m_current_investigation_info;
    ar & rm.m_proximity;
    ar & rm.m_event_schema_base;
    ar & rm.m_IB;
    ar & rm.m_Concept_Base;
    ar & rm.m_routine_monitor;
    ar & rm.m_MR;
    ar & rm.m_passive_alarm_load;
    ar & rm.m_time_constraint;
 
    // Owned vector-of-pointers
    ar & rm.m_thought_line_history;
    ar & rm.m_investigation_history;
    ar & rm.m_time_load_history;
    ar & rm.m_fatigue_history;
    ar & rm.m_diagnosis_complexity_history;
    ar & rm.m_cognitive_load_history;
    ar & rm.m_stress_history;
    ar & rm.m_cognitive_resouse_use_history;
    ar & rm.m_routine_monitor_interval_multiplier_history;
    ar & rm.m_attention_span_history;
    ar & rm.m_memory_span_history;
    ar & rm.m_decay_time_history;
    ar & rm.m_cognitive_time_cost_multiplier_history;
    ar & rm.m_max_alarm_length_timeline;
    ar & rm.m_cognitive_time_cost_multiplier_timeline;
    ar & rm.m_KE_list;
    ar & rm.m_KN_list;
    ar & rm.m_Knowledge_list;
    ar & rm.m_Semantic_list;
    ar & rm.m_Statement_list;
    ar & rm.m_investigator_pool;
    ar & rm.m_investigator_link_pool;
}
 
// ============================================================
// Additional leaf types used by MR* and other RM sub-objects
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, MRValueSchema & v, const unsigned int) {
    ar & v.m_time_perceived; ar & v.m_perceived_value;
}
 
template<class Archive>
void serialize(Archive & ar, MRStateSchema & s, const unsigned int) {
    ar & s.m_time_perceived; ar & s.m_perceived_state;
}
 
template<class Archive>
void serialize(Archive & ar, TimeValueNoteUnit & t, const unsigned int) {
    ar & t.m_time; ar & t.m_value; ar & t.m_string; ar & t.m_note;
}
 
template<class Archive>
void serialize(Archive & ar, KBConceptBaseDataSetUnit & k, const unsigned int) {
    ar & k.m_data_time; ar & k.m_value_list;
}
 
template<class Archive>
void serialize(Archive & ar, SymptomCase & sc, const unsigned int) {
    ar & sc.m_invest_opposite_bl; ar & sc.m_initiating_time;
    ar & sc.m_consistant_bl; ar & sc.m_finished_bl;
    ar & sc.m_exception_time; ar & sc.m_confirmed_time;
    ar & sc.m_rejection_time; ar & sc.m_path_confidence;
    // String IDs only — pointers reconnected later
    ar & sc.m_ID_stuck_KU; ar & sc.m_ID_problem_permission_invest;
    ar & sc.m_ID_problem_invest; ar & sc.m_ID_invest;
    ar & sc.m_ID_unfinished_invest; ar & sc.m_ID_unfinished_invest_link;
}
 
// ============================================================
// Concept classes (IDElement + Activation)
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, ConceptBasicUnit & c, const unsigned int) {
    ar & base_object<IDElement>(c);
    ar & base_object<Activation>(c);
    ar & c.m_concept_type; ar & c.m_content;
    ar & c.m_antonym_ID_list;
}
 
template<class Archive>
void serialize(Archive & ar, ConceptComposedUnit & c, const unsigned int) {
    ar & base_object<IDElement>(c);
    ar & base_object<Activation>(c);
    ar & c.m_ID_core; ar & c.m_ID_indefinite; ar & c.m_ID_lable;
    ar & c.m_ID_spec_list; ar & c.m_ID_antonym_list;
}
 
// ============================================================
// InstantiationBase sub-objects
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, Label & l, const unsigned int) {
    ar & l.m_lable_name; ar & l.m_ID_option_list;
}
 
template<class Archive>
void serialize(Archive & ar, Instantiation & inst, const unsigned int) {
    ar & inst.m_ID_instance_list;
    ar & inst.m_ID_indefinite; ar & inst.m_ID_lable_group_name;
}
 
// ============================================================
// MentalRepresentation sub-objects (IDElement)
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, MRParameterUnit & p, const unsigned int) {
    ar & base_object<IDElement>(p);
    ar & p.m_operator;
    ar & p.m_decrease_rate_threshold; ar & p.m_increase_rate_threshold;
    ar & p.m_decrease_threshold; ar & p.m_increase_threshold;
    ar & p.m_parameter_concept_ID; ar & p.m_ID_recent_trend;
    ar & p.m_parameter_rate_indicator_ID; ar & p.m_parameter_indicator_ID;
    ar & p.m_parameter_history_value; ar & p.m_parameter_history_rate;
    ar & p.m_recent_parameter_value; ar & p.m_recent_parameter_rate;
}
 
template<class Archive>
void serialize(Archive & ar, MRComponentStateUnit & c, const unsigned int) {
    ar & base_object<IDElement>(c);
    ar & c.m_CS_type; ar & c.m_operator; ar & c.m_change_threshold;
    ar & c.m_recent_position_value; ar & c.m_recent_state;
    ar & c.m_history_state; ar & c.m_history_position_value;
    ar & c.m_concept_ID;
    ar & c.m_ID_recent_action_statement; ar & c.m_ID_recent_state_statement;
    ar & c.Control_Value_Indicator_ID; ar & c.Component_State_Indicator_ID;
}
 
template<class Archive>
void serialize(Archive & ar, MRSupportSystemStateUnit & s, const unsigned int) {
    ar & base_object<IDElement>(s);
    ar & s.m_operator;
    ar & s.m_recent_state; ar & s.m_history_state;
    ar & s.m_concept_ID;
    ar & s.m_ID_recent_action_statement; ar & s.m_ID_recent_state_statement;
    ar & s.Support_System_State_Indicator_ID;
}
 
template<class Archive>
void serialize(Archive & ar, MRAlarmUnit & a, const unsigned int) {
    ar & base_object<IDElement>(a);
    ar & a.m_alarm_indicator_name; ar & a.m_operator;
    ar & a.m_recent_state; ar & a.m_history_state_list;
    ar & a.m_Concept_ID;
    ar & a.m_ID_recent_state_statement; ar & a.m_ID_recent_action_statement;
}
 
// ============================================================
// RoutineMonitor sub-objects
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, RoutineMonitorUnit & r, const unsigned int) {
    ar & base_object<IDElement>(r);
    ar & r.m_desired_monitor_interval; ar & r.m_operator;
    ar & r.m_relevance; ar & r.m_last_update_time;
    ar & r.m_ID_MR_unit;
}
 
// ============================================================
// EventSymptomUnit (IDElement) — used in EventSchemaUnit
// ============================================================
 
template<class Archive>
void serialize(Archive & ar, EventSymptomUnit & esu, const unsigned int) {
    ar & base_object<IDElement>(esu);
    ar & esu.m_symptom_transient_bl;
    ar & esu.m_ID_KE; ar & esu.m_ID_KU_list;
}
 
}} // namespace boost::serialization