Struct Tracker 

pub struct Tracker {
    pub our_key: Arc<PublicKey>,
    pub service: bool,
    pub only_clear_events: bool,
    pub hash: Option<HashAlgorithm>,
    pub subject_metadata: SubjectMetadata,
    pub governance_id: DigestIdentifier,
    pub namespace: Namespace,
    pub genesis_gov_version: u64,
    pub visibility_mode: TrackerVisibilityMode,
    pub properties: ValueWrapper,
}

Fields

our_key: Arc<PublicKey>

service: bool

only_clear_events: bool

hash: Option<HashAlgorithm>

subject_metadata: SubjectMetadata

governance_id: DigestIdentifier

namespace: Namespace

The namespace of the subject.

genesis_gov_version: u64

The version of the governance contract that created the subject.

visibility_mode: TrackerVisibilityMode

properties: ValueWrapper

The current status of the subject.

Trait Implementations

impl Actor for Tracker

type Event = Ledger

The type of events this actor can broadcast to subscribers.

type Message = TrackerMessage

The type of messages this actor accepts.

type Response = TrackerResponse

The type returned by the actor in response to each message.

fn get_span(id: &str, parent_span: Option<Span>) -> Span

Creates the tracing span for this actor instance.

fn pre_start<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called once before the actor begins processing messages.

fn drain_timeout() -> Duration

Maximum time to spend processing critical messages during shutdown before dropping them.

fn startup_timeout() -> Option<Duration>

Maximum time to wait for pre_start to complete; None disables the startup timeout.

fn stop_timeout() -> Option<Duration>

Maximum time a parent waits for this actor to acknowledge a stop request; None disables the stop timeout.

fn supervision_strategy() -> SupervisionStrategy

Returns the supervision strategy applied when this actor fails at startup.

fn pre_restart<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext<Self>, _error: Option<&'life2 Error>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: 'async_trait,

Called when the actor is about to be restarted after a failure.

fn pre_stop<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Called when the actor is about to stop, before children are stopped.

fn post_stop<'life0, 'life1, 'async_trait>( &'life0 mut self, _ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Called after all children have stopped and the actor is fully shut down. Override for final cleanup.

fn from_response(_response: Self::Response) -> Result<Self::Event, Error>

Maps a handler response to an event; call explicitly when you need that conversion.

impl BorshDeserialize for Tracker

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for Tracker

fn serialize<W: Write>(&self, writer: &mut W) -> Result<()>

impl Clone for Tracker

fn clone(&self) -> Tracker

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tracker

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Tracker

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Tracker> for Metadata

fn from(value: Tracker) -> Self

Converts to this type from the input type.

impl Handler<Tracker> for Tracker

fn handle_message<'life0, 'life1, 'async_trait>( &'life0 mut self, _sender: ActorPath, msg: TrackerMessage, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<TrackerResponse, ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Processes msg sent by sender and returns a response.

fn on_event<'life0, 'life1, 'async_trait>( &'life0 mut self, event: Ledger, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when the actor wants to apply an event to its own state; not invoked automatically by the runtime.

fn on_child_fault<'life0, 'life1, 'async_trait>( &'life0 mut self, error: ActorError, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = ChildAction> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when a child actor fails unrecoverably (panics or exhausts retries).

fn on_child_error<'life0, 'life1, 'async_trait>( &'life0 mut self, error: Error, _ctx: &'life1 mut ActorContext<A>, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: 'async_trait,

Called when a child actor reports an error via ActorContext::emit_error.

impl PersistentActor for Tracker

type Persistence = FullPersistence

The persistence strategy (LightPersistence or FullPersistence).

type InitParams = InitParamsTracker

Parameters passed to create_initial. Use () if no initialization data is needed.

fn update(&mut self, state: Self)

Replaces the current state with state, used during snapshot recovery.

fn create_initial(params: Self::InitParams) -> Self

Creates the actor in its default initial state from the given parameters.

fn apply(&mut self, event: &Self::Event) -> Result<(), ActorError>

Applies event to the actor’s in-memory state.

fn initial(params: Self::InitParams) -> InitializedActor<Self>

where Self: Sized,

Returns an InitializedActor wrapping the actor’s initial state.

fn snapshot_every() -> Option<u64>

Snapshot cadence for FullPersistence.

fn compact_on_snapshot() -> bool

Whether already snapshotted events should be compacted after a successful snapshot.

fn persist<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, event: &'life1 Self::Event, ctx: &'life2 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Send + 'async_trait,

Applies event to the in-memory state and durably persists it.

fn snapshot<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, Self: Sync + 'async_trait,

Sends the current state to the child store actor to be saved as a snapshot.

fn start_store<'life0, 'life1, 'life2, 'async_trait, C, S>( &'life0 mut self, name: &'life1 str, prefix: Option<String>, ctx: &'life2 mut ActorContext<Self>, manager: impl DbManager<C, S> + 'async_trait, key_box: Option<EncryptedKey>, ) -> Pin<Box<dyn Future<Output = Result<(), Error>> + Send + 'async_trait>>

where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, C: 'async_trait + Collection, S: 'async_trait + State, Self: Send + 'async_trait,

Creates the child store actor, opens the storage backend, and recovers any persisted state.

impl Serialize for Tracker

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Storable for Tracker

fn init_store<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, name: &'life1 str, prefix: Option<String>, encrypt: bool, ctx: &'life2 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

impl Subject for Tracker

fn update_sn<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn eol<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn reject<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, gov_version: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn confirm<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, new_owner: PublicKey, gov_version: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn transfer<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, new_owner: PublicKey, gov_version: u64, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_last_ledger<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, ) -> Pin<Box<dyn Future<Output = Result<Option<Ledger>, ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn apply_patch(&mut self, json_patch: ValueWrapper) -> Result<(), ActorError>

fn manager_new_ledger_events<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 mut ActorContext<Self>, events: Vec<Ledger>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn verify_new_ledger_event_args<'a>( new_ledger_event: &'a Ledger, subject_metadata: Metadata, actual_ledger_event_hash: DigestIdentifier, last_data: LastData, hash: &'a HashAlgorithm, full_view: bool, only_clear_events: bool, ) -> VerifyNewLedgerEvent<'a>

fn hash_viewpoints( hash: &HashAlgorithm, viewpoints: &BTreeSet<String>, ) -> Result<DigestIdentifier, SubjectError>

fn request_viewpoints(event_request: &EventRequest) -> BTreeSet<String>

fn apply_patch_verify( subject_properties: &mut ValueWrapper, json_patch: ValueWrapper, ) -> Result<(), SubjectError>

fn verify_new_ledger_event<'life0, 'life1, 'async_trait>( ctx: &'life0 mut ActorContext<Self>, args: VerifyNewLedgerEvent<'life1>, ) -> Pin<Box<dyn Future<Output = Result<bool, SubjectError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn verify_first_ledger_event<'life0, 'life1, 'life2, 'async_trait>( ctx: &'life0 mut ActorContext<Self>, ledger_event: &'life1 Ledger, hash: &'life2 HashAlgorithm, subject_metadata: Metadata, ) -> Pin<Box<dyn Future<Output = Result<(), SubjectError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn register<'life0, 'async_trait>( ctx: &'life0 mut ActorContext<Self>, message: RegisterMessage, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn event_to_sink<'life0, 'async_trait>( ctx: &'life0 mut ActorContext<Self>, data: DataForSink, event: Option<EventRequest>, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn publish_sink<'life0, 'async_trait>( ctx: &'life0 mut ActorContext<Self>, message: SinkDataMessage, ) -> Pin<Box<dyn Future<Output = Result<(), ActorError>> + Send + 'async_trait>>

where Self: Send + 'async_trait, 'life0: 'async_trait,

fn get_ledger<'life0, 'life1, 'async_trait>( &'life0 self, ctx: &'life1 mut ActorContext<Self>, lo_sn: Option<u64>, hi_sn: u64, ) -> Pin<Box<dyn Future<Output = Result<(Vec<<Self as Actor>::Event>, bool), ActorError>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,