From 47c1c09cd22a36ee2fa06a72497b541b0240f9ed Mon Sep 17 00:00:00 2001
From: jadamcrain <jadamcrain@gmail.com>
Date: Wed, 22 May 2024 19:28:41 -0700
Subject: [PATCH 1/3] first pass at way to update flags on database

---
 .../outstation/database/details/database.rs   | 57 ++++++++++++++++++-
 .../database/details/range/static_db.rs       | 52 +++++++++++++++++
 dnp3/src/outstation/database/mod.rs           | 49 ++++++++++++++++
 3 files changed, 156 insertions(+), 2 deletions(-)

diff --git a/dnp3/src/outstation/database/details/database.rs b/dnp3/src/outstation/database/details/database.rs
index 31d73d80..f90e8165 100644
--- a/dnp3/src/outstation/database/details/database.rs
+++ b/dnp3/src/outstation/database/details/database.rs
@@ -2,13 +2,17 @@ use crate::app::Iin2;
 use crate::master::EventClasses;
 use crate::outstation::database::details::event::buffer::{EventBuffer, InsertError};
 use crate::outstation::database::details::range::static_db::{
-    PointConfig, StaticDatabase, Updatable,
+    PointConfig, StaticDatabase, Updatable, UpdatableFlags,
 };
 use crate::outstation::database::read::ReadHeader;
 use crate::outstation::database::{
-    ClassZeroConfig, EventBufferConfig, ResponseInfo, UpdateInfo, UpdateOptions,
+    ClassZeroConfig, EventBufferConfig, ResponseInfo, UpdateFlagsType, UpdateInfo, UpdateOptions,
 };
 
+use crate::app::measurement::{
+    AnalogInput, AnalogOutputStatus, BinaryInput, BinaryOutputStatus, Counter,
+    DoubleBitBinaryInput, Flags, FrozenCounter, Time,
+};
 use crate::outstation::database::details::attrs::map::SetMap;
 use crate::outstation::{BufferState, OutstationApplication};
 use scursor::WriteCursor;
@@ -98,6 +102,55 @@ impl Database {
         self.static_db.get::<T>(index)
     }
 
+    pub(crate) fn update_flags(
+        &mut self,
+        index: u16,
+        flags_type: UpdateFlagsType,
+        flags: Flags,
+        time: Time,
+        options: UpdateOptions,
+    ) -> UpdateInfo {
+        match flags_type {
+            UpdateFlagsType::BinaryInput => {
+                self.update_flags_by_type::<BinaryInput>(index, flags, time, options)
+            }
+            UpdateFlagsType::DoubleBitBinaryInput => {
+                self.update_flags_by_type::<DoubleBitBinaryInput>(index, flags, time, options)
+            }
+            UpdateFlagsType::BinaryOutputStatus => {
+                self.update_flags_by_type::<BinaryOutputStatus>(index, flags, time, options)
+            }
+            UpdateFlagsType::Counter => {
+                self.update_flags_by_type::<Counter>(index, flags, time, options)
+            }
+            UpdateFlagsType::FrozenCounter => {
+                self.update_flags_by_type::<FrozenCounter>(index, flags, time, options)
+            }
+            UpdateFlagsType::AnalogInput => {
+                self.update_flags_by_type::<AnalogInput>(index, flags, time, options)
+            }
+            UpdateFlagsType::AnalogOutputStatus => {
+                self.update_flags_by_type::<AnalogOutputStatus>(index, flags, time, options)
+            }
+        }
+    }
+
+    pub(crate) fn update_flags_by_type<T: UpdatableFlags>(
+        &mut self,
+        index: u16,
+        flags: Flags,
+        timestamp: Time,
+        options: UpdateOptions,
+    ) -> UpdateInfo {
+        match self.static_db.get::<T>(index) {
+            None => UpdateInfo::NoPoint,
+            Some(mut x) => {
+                x.update_flags(flags, timestamp);
+                self.update::<T>(&x, index, options)
+            }
+        }
+    }
+
     pub(crate) fn update<T>(&mut self, value: &T, index: u16, options: UpdateOptions) -> UpdateInfo
     where
         T: Updatable,
diff --git a/dnp3/src/outstation/database/details/range/static_db.rs b/dnp3/src/outstation/database/details/range/static_db.rs
index 23e86c91..ccb53779 100644
--- a/dnp3/src/outstation/database/details/range/static_db.rs
+++ b/dnp3/src/outstation/database/details/range/static_db.rs
@@ -32,6 +32,10 @@ pub(crate) trait Updatable: Insertable + Clone + Default {
     fn enabled_class_zero(config: &ClassZeroConfig) -> bool;
 }
 
+pub(crate) trait UpdatableFlags: Updatable {
+    fn update_flags(&mut self, flags: Flags, time: Time);
+}
+
 #[derive(Copy, Clone)]
 pub(crate) struct IndexRange {
     start: u16,
@@ -743,6 +747,13 @@ impl Updatable for BinaryInput {
     }
 }
 
+impl UpdatableFlags for BinaryInput {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for DoubleBitBinaryInput {
     type StaticVariation = StaticDoubleBitBinaryInputVariation;
     type Detector = FlagsDetector;
@@ -764,6 +775,13 @@ impl Updatable for DoubleBitBinaryInput {
     }
 }
 
+impl UpdatableFlags for DoubleBitBinaryInput {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for BinaryOutputStatus {
     type StaticVariation = StaticBinaryOutputStatusVariation;
     type Detector = FlagsDetector;
@@ -785,6 +803,12 @@ impl Updatable for BinaryOutputStatus {
     }
 }
 
+impl UpdatableFlags for BinaryOutputStatus {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
 impl Updatable for Counter {
     type StaticVariation = StaticCounterVariation;
     type Detector = Deadband<u32>;
@@ -806,6 +830,13 @@ impl Updatable for Counter {
     }
 }
 
+impl UpdatableFlags for Counter {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for FrozenCounter {
     type StaticVariation = StaticFrozenCounterVariation;
     type Detector = Deadband<u32>;
@@ -827,6 +858,13 @@ impl Updatable for FrozenCounter {
     }
 }
 
+impl UpdatableFlags for FrozenCounter {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for AnalogInput {
     type StaticVariation = StaticAnalogInputVariation;
     type Detector = Deadband<f64>;
@@ -848,6 +886,13 @@ impl Updatable for AnalogInput {
     }
 }
 
+impl UpdatableFlags for AnalogInput {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for AnalogOutputStatus {
     type StaticVariation = StaticAnalogOutputStatusVariation;
     type Detector = Deadband<f64>;
@@ -869,6 +914,13 @@ impl Updatable for AnalogOutputStatus {
     }
 }
 
+impl UpdatableFlags for AnalogOutputStatus {
+    fn update_flags(&mut self, flags: Flags, time: Time) {
+        self.flags = flags;
+        self.time = Some(time);
+    }
+}
+
 impl Updatable for OctetString {
     type StaticVariation = StaticOctetStringVariation;
     type Detector = OctetStringDetector;
diff --git a/dnp3/src/outstation/database/mod.rs b/dnp3/src/outstation/database/mod.rs
index 913736b2..fca36482 100644
--- a/dnp3/src/outstation/database/mod.rs
+++ b/dnp3/src/outstation/database/mod.rs
@@ -307,6 +307,41 @@ pub trait Update<T> {
     fn update2(&mut self, index: u16, value: &T, options: UpdateOptions) -> UpdateInfo;
 }
 
+/// Point on which to update the flags
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum UpdateFlagsType {
+    /// Binary input
+    BinaryInput,
+    /// Double-bit binary input
+    DoubleBitBinaryInput,
+    /// Binary output status
+    BinaryOutputStatus,
+    /// Counter
+    Counter,
+    /// Frozen counter
+    FrozenCounter,
+    /// Analog input
+    AnalogInput,
+    /// Analog output status
+    AnalogOutputStatus,
+}
+
+/// Trait for updating flags on a point without changing the current value of the point
+pub trait UpdateFlags {
+    /// Update the flags for the specified point without changing the value
+    ///
+    /// This is equivalent to getting the current value, changing the flags and the value, then updating
+    fn update_flags(
+        &mut self,
+        index: u16,
+        flags_type: UpdateFlagsType,
+        flags: Flags,
+        time: Time,
+        options: UpdateOptions,
+    ) -> UpdateInfo;
+}
+
 /// Trait for getting the current value in the database
 pub trait Get<T> {
     /// retrieve the current value off the database.
@@ -477,6 +512,20 @@ impl DatabaseHandle {
     }
 }
 
+impl UpdateFlags for Database {
+    fn update_flags(
+        &mut self,
+        index: u16,
+        flags_type: UpdateFlagsType,
+        flags: Flags,
+        time: Time,
+        options: UpdateOptions,
+    ) -> UpdateInfo {
+        self.inner
+            .update_flags(index, flags_type, flags, time, options)
+    }
+}
+
 impl Update<BinaryInput> for Database {
     fn update2(&mut self, index: u16, value: &BinaryInput, options: UpdateOptions) -> UpdateInfo {
         self.inner.update(value, index, options)

From 4f47e993810b12c81319794b9214991a4946c83d Mon Sep 17 00:00:00 2001
From: jadamcrain <jadamcrain@gmail.com>
Date: Wed, 22 May 2024 19:35:56 -0700
Subject: [PATCH 2/3] demonstrate how to update flags in the rust example

---
 dnp3/examples/outstation.rs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/dnp3/examples/outstation.rs b/dnp3/examples/outstation.rs
index 6f1b6491..591e65d2 100644
--- a/dnp3/examples/outstation.rs
+++ b/dnp3/examples/outstation.rs
@@ -491,6 +491,15 @@ async fn run_outstation(
                     );
                 })
             }
+            "aif" => outstation.transaction(|db| {
+                db.update_flags(
+                    7,
+                    UpdateFlagsType::AnalogInput,
+                    Flags::COMM_LOST,
+                    get_current_time(),
+                    UpdateOptions::detect_event(),
+                );
+            }),
             "aos" => {
                 analog_output_status_value += 1.0;
                 outstation.transaction(|db| {

From 61f78f1451fdae2b1e2eb6e74b4bf59412c2c135 Mon Sep 17 00:00:00 2001
From: jadamcrain <jadamcrain@gmail.com>
Date: Thu, 23 May 2024 15:31:56 -0700
Subject: [PATCH 3/3] UpdateFlags(..) in the FFI

---
 dnp3/examples/outstation.rs                   |  2 +-
 .../outstation/database/details/database.rs   |  4 +-
 .../database/details/range/static_db.rs       | 30 +++++++--------
 dnp3/src/outstation/database/mod.rs           |  8 ++--
 .../dotnet/examples/outstation/Program.cs     |  8 ++++
 ffi/dnp3-ffi/src/outstation/database.rs       | 37 +++++++++++++++++++
 ffi/dnp3-schema/src/database.rs               | 35 +++++++++++++++++-
 ffi/dnp3-schema/src/shared.rs                 |  4 ++
 8 files changed, 105 insertions(+), 23 deletions(-)

diff --git a/dnp3/examples/outstation.rs b/dnp3/examples/outstation.rs
index 591e65d2..7b4b9a69 100644
--- a/dnp3/examples/outstation.rs
+++ b/dnp3/examples/outstation.rs
@@ -496,7 +496,7 @@ async fn run_outstation(
                     7,
                     UpdateFlagsType::AnalogInput,
                     Flags::COMM_LOST,
-                    get_current_time(),
+                    Some(get_current_time()),
                     UpdateOptions::detect_event(),
                 );
             }),
diff --git a/dnp3/src/outstation/database/details/database.rs b/dnp3/src/outstation/database/details/database.rs
index f90e8165..41308893 100644
--- a/dnp3/src/outstation/database/details/database.rs
+++ b/dnp3/src/outstation/database/details/database.rs
@@ -107,7 +107,7 @@ impl Database {
         index: u16,
         flags_type: UpdateFlagsType,
         flags: Flags,
-        time: Time,
+        time: Option<Time>,
         options: UpdateOptions,
     ) -> UpdateInfo {
         match flags_type {
@@ -139,7 +139,7 @@ impl Database {
         &mut self,
         index: u16,
         flags: Flags,
-        timestamp: Time,
+        timestamp: Option<Time>,
         options: UpdateOptions,
     ) -> UpdateInfo {
         match self.static_db.get::<T>(index) {
diff --git a/dnp3/src/outstation/database/details/range/static_db.rs b/dnp3/src/outstation/database/details/range/static_db.rs
index ccb53779..ad3b891f 100644
--- a/dnp3/src/outstation/database/details/range/static_db.rs
+++ b/dnp3/src/outstation/database/details/range/static_db.rs
@@ -33,7 +33,7 @@ pub(crate) trait Updatable: Insertable + Clone + Default {
 }
 
 pub(crate) trait UpdatableFlags: Updatable {
-    fn update_flags(&mut self, flags: Flags, time: Time);
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>);
 }
 
 #[derive(Copy, Clone)]
@@ -748,9 +748,9 @@ impl Updatable for BinaryInput {
 }
 
 impl UpdatableFlags for BinaryInput {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
@@ -776,9 +776,9 @@ impl Updatable for DoubleBitBinaryInput {
 }
 
 impl UpdatableFlags for DoubleBitBinaryInput {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
@@ -804,9 +804,9 @@ impl Updatable for BinaryOutputStatus {
 }
 
 impl UpdatableFlags for BinaryOutputStatus {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 impl Updatable for Counter {
@@ -831,9 +831,9 @@ impl Updatable for Counter {
 }
 
 impl UpdatableFlags for Counter {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
@@ -859,9 +859,9 @@ impl Updatable for FrozenCounter {
 }
 
 impl UpdatableFlags for FrozenCounter {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
@@ -887,9 +887,9 @@ impl Updatable for AnalogInput {
 }
 
 impl UpdatableFlags for AnalogInput {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
@@ -915,9 +915,9 @@ impl Updatable for AnalogOutputStatus {
 }
 
 impl UpdatableFlags for AnalogOutputStatus {
-    fn update_flags(&mut self, flags: Flags, time: Time) {
+    fn update_flags(&mut self, flags: Flags, time: Option<Time>) {
         self.flags = flags;
-        self.time = Some(time);
+        self.time = time;
     }
 }
 
diff --git a/dnp3/src/outstation/database/mod.rs b/dnp3/src/outstation/database/mod.rs
index fca36482..e5e05802 100644
--- a/dnp3/src/outstation/database/mod.rs
+++ b/dnp3/src/outstation/database/mod.rs
@@ -307,7 +307,7 @@ pub trait Update<T> {
     fn update2(&mut self, index: u16, value: &T, options: UpdateOptions) -> UpdateInfo;
 }
 
-/// Point on which to update the flags
+/// Point type on which to update the flags
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum UpdateFlagsType {
@@ -331,13 +331,13 @@ pub enum UpdateFlagsType {
 pub trait UpdateFlags {
     /// Update the flags for the specified point without changing the value
     ///
-    /// This is equivalent to getting the current value, changing the flags and the value, then updating
+    /// This is equivalent to getting the current value, changing the flags and the timestamp, then calling update
     fn update_flags(
         &mut self,
         index: u16,
         flags_type: UpdateFlagsType,
         flags: Flags,
-        time: Time,
+        time: Option<Time>,
         options: UpdateOptions,
     ) -> UpdateInfo;
 }
@@ -518,7 +518,7 @@ impl UpdateFlags for Database {
         index: u16,
         flags_type: UpdateFlagsType,
         flags: Flags,
-        time: Time,
+        time: Option<Time>,
         options: UpdateOptions,
     ) -> UpdateInfo {
         self.inner
diff --git a/ffi/bindings/dotnet/examples/outstation/Program.cs b/ffi/bindings/dotnet/examples/outstation/Program.cs
index ae97f496..984dfd74 100644
--- a/ffi/bindings/dotnet/examples/outstation/Program.cs
+++ b/ffi/bindings/dotnet/examples/outstation/Program.cs
@@ -575,6 +575,14 @@ private static void RunOutstation(Outstation outstation)
                         });
                         break;
                     }
+                case "aif":
+                    {
+                        outstation.Transaction(db =>
+                        {
+                            db.UpdateFlags(7, UpdateFlagsType.AnalogInput, new Flags(Flag.CommLost), Now(), detectEvent);
+                        });
+                        break;
+                    }                    
                 case "aos":
                     {
                         outstation.Transaction(db =>
diff --git a/ffi/dnp3-ffi/src/outstation/database.rs b/ffi/dnp3-ffi/src/outstation/database.rs
index ffeda348..fa7b1763 100644
--- a/ffi/dnp3-ffi/src/outstation/database.rs
+++ b/ffi/dnp3-ffi/src/outstation/database.rs
@@ -115,6 +115,43 @@ macro_rules! implement_database_point_operations {
     };
 }
 
+pub(crate) unsafe fn database_update_flags(
+    instance: *mut crate::Database,
+    index: u16,
+    flags_type: ffi::UpdateFlagsType,
+    flags: ffi::Flags,
+    time: ffi::Timestamp,
+    options: ffi::UpdateOptions,
+) -> ffi::UpdateInfo {
+    let db = match instance.as_mut() {
+        None => return ffi::UpdateInfoFields::default().into(),
+        Some(db) => db,
+    };
+
+    db.update_flags(
+        index,
+        flags_type.into(),
+        (&flags).into(),
+        (&time).into(),
+        options.into(),
+    )
+    .into()
+}
+
+impl From<ffi::UpdateFlagsType> for UpdateFlagsType {
+    fn from(value: ffi::UpdateFlagsType) -> Self {
+        match value {
+            ffi::UpdateFlagsType::BinaryInput => Self::BinaryInput,
+            ffi::UpdateFlagsType::DoubleBitBinaryInput => Self::DoubleBitBinaryInput,
+            ffi::UpdateFlagsType::BinaryOutputStatus => Self::BinaryOutputStatus,
+            ffi::UpdateFlagsType::Counter => Self::Counter,
+            ffi::UpdateFlagsType::FrozenCounter => Self::FrozenCounter,
+            ffi::UpdateFlagsType::AnalogInput => Self::AnalogInput,
+            ffi::UpdateFlagsType::AnalogOutputStatus => Self::AnalogOutputStatus,
+        }
+    }
+}
+
 implement_database_point_operations!(
     database_add_binary_input,
     database_remove_binary_input,
diff --git a/ffi/dnp3-schema/src/database.rs b/ffi/dnp3-schema/src/database.rs
index 2ac3f85a..52800e48 100644
--- a/ffi/dnp3-schema/src/database.rs
+++ b/ffi/dnp3-schema/src/database.rs
@@ -60,6 +60,22 @@ fn define_update_options(lib: &mut LibraryBuilder) -> BackTraced<FunctionArgStru
     Ok(update_options)
 }
 
+fn define_update_flags_type(lib: &mut LibraryBuilder) -> BackTraced<EnumHandle> {
+    let x = lib
+        .define_enum("update_flags_type")?
+        .doc("Point type on which to update the flags")?
+        .push("binary_input", "Binary input")?
+        .push("double_bit_binary_input", "Doubl-bit binary input ")?
+        .push("binary_output_status", "Binary output status")?
+        .push("counter", "Counter")?
+        .push("frozen_counter", "Frozen counter")?
+        .push("analog_input", "Analog input")?
+        .push("analog_output_status", "Analog output status")?
+        .build()?;
+
+    Ok(x)
+}
+
 fn define_binary_config(lib: &mut LibraryBuilder) -> BackTraced<FunctionArgStructHandle> {
     let binary_static_variation = lib
         .define_enum("static_binary_input_variation")?
@@ -543,9 +559,24 @@ pub(crate) fn define_database(
         .build()?;
 
     let update_info = define_update_info(lib)?;
-
     let update_options = define_update_options(lib)?;
 
+    let update_flags_type = define_update_flags_type(lib)?;
+
+    let update_flags = lib
+        .define_method("update_flags", database.clone())?
+        .doc(
+            doc("Update the flags for the specified point without changing the value")
+                .details("This is equivalent to getting the current value, changing the flags and the timestamp, then calling update")
+        )?
+        .param("index", Primitive::U16, "Index on which to perform the operation")?
+        .param("flags_type", update_flags_type, "Point type on which to perform the operation")?
+        .param("flags", shared_def.flags.clone(), "New flags applied to the point")?
+        .param("time", shared_def.timestamp.clone(), "New timestamp applied to the point")?
+        .param("options", update_options.clone(), "Options that control how events and static values are handled")?
+        .returns(update_info.clone(), "Provides detailed information about what occurred during the update operation")?
+        .build()?;
+
     // Binary Input
     let binary_config = define_binary_config(lib)?;
 
@@ -1220,6 +1251,8 @@ pub(crate) fn define_database(
 
     let database = lib
         .define_class(&database)?
+        // works on all types
+        .method(update_flags)?
         // binary methods
         .method(add_binary)?
         .method(remove_binary)?
diff --git a/ffi/dnp3-schema/src/shared.rs b/ffi/dnp3-schema/src/shared.rs
index a5bade2a..920c4f17 100644
--- a/ffi/dnp3-schema/src/shared.rs
+++ b/ffi/dnp3-schema/src/shared.rs
@@ -24,6 +24,8 @@ pub(crate) struct SharedDefinitions {
     pub control_field_struct: CallbackArgStructHandle,
     pub g12v1_struct: UniversalStructHandle,
     pub function_code: EnumHandle,
+    pub flags: UniversalStructHandle,
+    pub timestamp: UniversalStructHandle,
     pub binary_point: UniversalStructHandle,
     pub binary_it: AbstractIteratorHandle,
     pub double_bit_binary_point: UniversalStructHandle,
@@ -335,6 +337,8 @@ pub(crate) fn define(lib: &mut LibraryBuilder) -> BackTraced<SharedDefinitions>
         control_field_struct,
         g12v1_struct,
         function_code: define_function_code(lib)?,
+        flags: flags_struct,
+        timestamp: timestamp_struct,
         binary_point,
         binary_it,
         double_bit_binary_point,