Struct SessionAsync

pub struct SessionAsync {
    pub socket_pool: HGTPPool,
}

Asynchronous AvesTerra client

This is not the recommended client to use. Unless you want to use you own asynchronous context, you should use crate::Session instead. The crate::Session client is easier to use, and also provide the ability to execute asynchronous code.

You need to create the SessionAsync with SessionAsync::initialize

Fields

socket_pool: HGTPPool

Implementations

impl SessionAsync

pub async fn initialize(config: SessionConfig) -> Result<Self>

pub async fn finalize(&self)

Cleanly closes all connections. This method will wait for all currently used connections to be returned to the pool. This might take a while depending on how long is the queue of calls waiting for a connection. In an ideal world this would have been implemented better and the queue of pending calls would have been cancelled, but it’s not the case, sorry.

impl SessionAsync

pub fn invoke_entity( &self, entity: Entity, method: Method, authorization: Token, ) -> InvokeEntity<Self>

impl SessionAsync

pub fn create_entity( &self, name: String255, authorization: Token, ) -> CreateEntity<Self>

impl SessionAsync

pub fn delete_entity( &self, entity: Entity, authorization: Token, ) -> DeleteEntity<Self>

impl SessionAsync

pub fn inquire_entity( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> InquireEntity<Self>

impl SessionAsync

pub fn reference_entity( &self, entity: Entity, authorization: Token, ) -> ReferenceEntity<Self>

impl SessionAsync

pub fn dereference_entity( &self, entity: Entity, authorization: Token, ) -> DereferenceEntity<Self>

impl SessionAsync

pub fn connect_method( &self, entity: Entity, outlet: Entity, authorization: Token, ) -> ConnectMethod<Self>

impl SessionAsync

pub fn disconnect_method( &self, entity: Entity, outlet: Entity, method: Method, authorization: Token, ) -> DisconnectMethod<Self>

impl SessionAsync

pub fn entity_connection( &self, entity: Entity, index: i64, authorization: Token, ) -> EntityConnection<Self>

impl SessionAsync

pub fn attach_attribute( &self, entity: Entity, outlet: Entity, authorization: Token, ) -> AttachAttribute<Self>

impl SessionAsync

pub fn detach_attribute( &self, entity: Entity, outlet: Entity, attribute: Attribute, authorization: Token, ) -> DetachAttribute<Self>

impl SessionAsync

pub fn entity_attachment( &self, entity: Entity, index: i64, authorization: Token, ) -> EntityAttachment<Self>

impl SessionAsync

pub fn activate_outlet( &self, outlet: Entity, authorization: Token, ) -> ActivateOutlet<Self>

impl SessionAsync

pub fn deactivate_outlet( &self, outlet: Entity, authorization: Token, ) -> DeactivateOutlet<Self>

impl SessionAsync

pub fn reset_outlet( &self, outlet: Entity, authorization: Token, ) -> ResetOutlet<Self>

impl SessionAsync

pub fn publish_event( &self, entity: Entity, event: Event, authorization: Token, ) -> PublishEvent<Self>

impl SessionAsync

pub fn subscribe_event( &self, entity: Entity, outlet: Entity, authorization: Token, ) -> SubscribeEvent<Self>

impl SessionAsync

pub fn unsubscribe_event( &self, entity: Entity, outlet: Entity, event: Event, authorization: Token, ) -> UnsubscribeEvent<Self>

impl SessionAsync

pub fn wait_event( &self, outlet: Entity, authorization: Token, ) -> WaitEvent<Self>

impl SessionAsync

pub fn subscribe_entity( &self, entity: Entity, outlet: Entity, event: Event, authorization: Token, ) -> SubscribeEntity<Self>

impl SessionAsync

pub fn lock_outlet( &self, outlet: Entity, authorization: Token, ) -> LockOutlet<Self>

impl SessionAsync

pub fn unlock_outlet( &self, outlet: Entity, authorization: Token, ) -> UnlockOutlet<Self>

impl SessionAsync

pub fn authorize_entity( &self, entity: Entity, authority: Token, authorization: Token, ) -> AuthorizeEntity<Self>

impl SessionAsync

pub fn deauthorize_entity( &self, entity: Entity, authority: Token, authorization: Token, ) -> DeauthorizeEntity<Self>

impl SessionAsync

pub fn entity_authorized( &self, entity: Entity, authority: Token, authorization: Token, ) -> EntityAuthorized<Self>

impl SessionAsync

pub fn entity_authority( &self, entity: Entity, authorization: Token, ) -> EntityAuthority<Self>

impl SessionAsync

pub fn entity_name( &self, entity: Entity, authorization: Token, ) -> EntityName<Self>

impl SessionAsync

pub fn entity_class( &self, entity: Entity, authorization: Token, ) -> EntityClass<Self>

impl SessionAsync

pub fn entity_category( &self, entity: Entity, authorization: Token, ) -> EntityCategory<Self>

impl SessionAsync

pub fn local_server(&self, authorization: Token) -> LocalServer<Self>

impl SessionAsync

pub fn local_version(&self) -> LocalVersion<Self>

impl SessionAsync

pub fn entity_redirection( &self, entity: Entity, authorization: Token, ) -> EntityRedirection<Self>

impl SessionAsync

pub fn entity_redirect( &self, auxiliary: Entity, ancillary: Entity, authorization: Token, ) -> EntityRedirect<Self>

impl SessionAsync

pub fn change_entity( &self, entity: Entity, authorization: Token, ) -> ChangeEntity<Self>

impl SessionAsync

pub fn entity_timestamp( &self, entity: Entity, authorization: Token, ) -> EntityTimestamp<Self>

impl SessionAsync

pub fn entity_available( &self, entity: Entity, authorization: Token, ) -> EntityAvailable<Self>

impl SessionAsync

pub fn entity_extinct( &self, entity: Entity, authorization: Token, ) -> EntityExtinct<Self>

impl SessionAsync

pub fn entity_activated( &self, entity: Entity, authorization: Token, ) -> EntityActivated<Self>

impl SessionAsync

pub fn entity_locked( &self, entity: Entity, authorization: Token, ) -> EntityLocked<Self>

impl SessionAsync

pub fn pending(&self, entity: Entity, authorization: Token) -> Pending<Self>

impl SessionAsync

pub fn entity_rendezvous( &self, entity: Entity, authorization: Token, ) -> EntityRendezvous<Self>

impl SessionAsync

pub fn entity_references( &self, entity: Entity, authorization: Token, ) -> EntityReferences<Self>

impl SessionAsync

pub fn connection_count( &self, entity: Entity, authorization: Token, ) -> ConnectionCount<Self>

impl SessionAsync

pub fn attachment_count( &self, entity: Entity, authorization: Token, ) -> AttachmentCount<Self>

impl SessionAsync

pub fn subscription_count( &self, entity: Entity, authorization: Token, ) -> SubscriptionCount<Self>

impl SessionAsync

pub fn entity_authorizations( &self, entity: Entity, authorization: Token, ) -> EntityAuthorizations<Self>

impl SessionAsync

pub fn fetch_entity( &self, entity: Entity, authorization: Token, ) -> FetchEntity<Self>

impl SessionAsync

pub fn insert_element( &self, entity: Entity, value: &Value, index: i64, authorization: Token, ) -> InsertElement<Self>

impl SessionAsync

pub fn remove_element( &self, entity: Entity, index: i64, authorization: Token, ) -> RemoveElement<Self>

impl SessionAsync

pub fn replace_element( &self, entity: Entity, value: &Value, index: i64, authorization: Token, ) -> ReplaceElement<Self>

impl SessionAsync

pub fn erase_element( &self, entity: Entity, authorization: Token, ) -> EraseElement<Self>

impl SessionAsync

pub fn find_element( &self, entity: Entity, value: &Value, index: i64, authorization: Token, ) -> FindElement<Self>

impl SessionAsync

pub fn entity_element( &self, entity: Entity, authorization: Token, ) -> EntityElement<Self>

impl SessionAsync

pub fn element_count( &self, entity: Entity, authorization: Token, ) -> ElementCount<Self>

impl SessionAsync

pub fn adapt_outlet( &self, outlet: Entity, authorization: Token, callback: <AdaptOutlet<SessionAsync> as AdaptOutletTrait>::CallbackType, ) -> AdaptOutlet<SessionAsync>

Example:

use orchestra_toolkit::*;

async fn callback(s: SessionAsync, args: AdapterArgs) -> Result<Value, AvesterraError> {
    println!("Adapting {:?}", args);
    Ok(Value::NULL)
}

let outlet = Entity::new(0, 0, 4200);
let auth = Token::NULL;
let session = Session::initialize(SessionConfig::default()).unwrap();
session.run_async(|s1| async {
    let s2 = s1.clone();
    s1.
      adapt_outlet(
          outlet,
          auth,
          Box::new(|args: AdapterArgs| Box::pin(callback(s2, args))),
    )
});

impl SessionAsync

pub fn insert_annotation( &self, entity: Entity, key: String255, index: i64, attribute: Attribute, value: Value, authorization: Token, ) -> InsertAnnotation<Self>

impl SessionAsync

pub fn remove_annotation( &self, entity: Entity, key: String255, authorization: Token, ) -> RemoveAnnotation<Self>

impl SessionAsync

pub fn replace_annotation( &self, entity: Entity, key: String255, attribute: Attribute, value: Value, authorization: Token, ) -> ReplaceAnnotation<Self>

impl SessionAsync

pub fn find_annotation( &self, entity: Entity, key: String255, value: Value, authorization: Token, ) -> FindAnnotation<Self>

impl SessionAsync

pub fn include_annotation( &self, entity: Entity, key: String255, attribute: Attribute, value: Value, authorization: Token, ) -> IncludeAnnotation<Self>

impl SessionAsync

pub fn exclude_annotation( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> ExcludeAnnotation<Self>

impl SessionAsync

pub fn set_annotation( &self, entity: Entity, key: String255, attribute: Attribute, value: Value, authorization: Token, ) -> SetAnnotation<Self>

impl SessionAsync

pub fn get_annotation( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> GetAnnotation<Self>

impl SessionAsync

pub fn clear_annotation( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> ClearAnnotation<Self>

impl SessionAsync

pub fn annotation_count( &self, entity: Entity, key: String255, authorization: Token, ) -> AnnotationCount<Self>

impl SessionAsync

pub fn annotation_member( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> AnnotationMember<Self>

impl SessionAsync

pub fn annotation_name( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> AnnotationName<Self>

impl SessionAsync

pub fn annotation_key( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> AnnotationKey<Self>

impl SessionAsync

pub fn annotation_value( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> AnnotationValue<Self>

impl SessionAsync

pub fn annotation_index( &self, entity: Entity, key: String255, attribute: Attribute, authorization: Token, ) -> AnnotationIndex<Self>

impl SessionAsync

pub fn annotation_attribute( &self, entity: Entity, key: String255, instance: i32, authorization: Token, ) -> AnnotationAttribute<Self>

impl SessionAsync

pub fn purge_annotations( &self, entity: Entity, key: String255, authorization: Token, ) -> PurgeAnnotations<Self>

impl SessionAsync

pub fn sort_annotations( &self, entity: Entity, key: String255, authorization: Token, ) -> SortAnnotations<Self>

impl SessionAsync

pub fn retrieve_annotations( &self, entity: Entity, key: String255, authorization: Token, ) -> RetrieveAnnotations<Self>

impl SessionAsync

pub fn insert_facet( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> InsertFacet<Self>

impl SessionAsync

pub fn remove_facet( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> RemoveFacet<Self>

impl SessionAsync

pub fn replace_facet( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> ReplaceFacet<Self>

impl SessionAsync

pub fn find_facet( &self, entity: Entity, attribute: Attribute, value: Value, authorization: Token, ) -> FindFacet<Self>

impl SessionAsync

pub fn include_facet( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> IncludeFacet<Self>

impl SessionAsync

pub fn exclude_facet( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> ExcludeFacet<Self>

impl SessionAsync

pub fn set_facet( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> SetFacet<Self>

impl SessionAsync

pub fn get_facet( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> GetFacet<Self>

impl SessionAsync

pub fn clear_facet( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> ClearFacet<Self>

impl SessionAsync

pub fn facet_count( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FacetCount<Self>

impl SessionAsync

pub fn facet_member( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FacetMember<Self>

impl SessionAsync

pub fn facet_name( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> FacetName<Self>

impl SessionAsync

pub fn facet_key( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FacetKey<Self>

impl SessionAsync

pub fn facet_value( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FacetValue<Self>

impl SessionAsync

pub fn facet_index( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FacetIndex<Self>

impl SessionAsync

pub fn facet_attribute( &self, entity: Entity, authorization: Token, ) -> FacetAttribute<Self>

impl SessionAsync

pub fn sort_facets( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> SortFacets<Self>

impl SessionAsync

pub fn purge_facets( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> PurgeFacets<Self>

impl SessionAsync

pub fn retrieve_facets( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> RetrieveFacets<Self>

impl SessionAsync

pub fn insert_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, value: Value, authorization: Token, ) -> InsertFactor<Self>

impl SessionAsync

pub fn remove_factor( &self, entity: Entity, attribute: Attribute, name: String255, index: i64, authorization: Token, ) -> RemoveFactor<Self>

impl SessionAsync

pub fn replace_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, value: Value, authorization: Token, ) -> ReplaceFactor<Self>

impl SessionAsync

pub fn find_factor( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> FindFactor<Self>

impl SessionAsync

pub fn include_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, value: Value, authorization: Token, ) -> IncludeFactor<Self>

impl SessionAsync

pub fn exclude_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> ExcludeFactor<Self>

impl SessionAsync

pub fn set_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, value: Value, authorization: Token, ) -> SetFactor<Self>

impl SessionAsync

pub fn get_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> GetFactor<Self>

impl SessionAsync

pub fn clear_factor( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> ClearFactor<Self>

impl SessionAsync

pub fn factor_count( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FactorCount<Self>

impl SessionAsync

pub fn factor_member( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> FactorMember<Self>

impl SessionAsync

pub fn factor_name( &self, entity: Entity, authorization: Token, ) -> FactorName<Self>

impl SessionAsync

pub fn factor_key( &self, entity: Entity, attribute: Attribute, name: String255, index: i64, authorization: Token, ) -> FactorKey<Self>

impl SessionAsync

pub fn factor_value( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> FactorValue<Self>

impl SessionAsync

pub fn factor_index( &self, entity: Entity, attribute: Attribute, name: String255, key: String255, authorization: Token, ) -> FactorIndex<Self>

impl SessionAsync

pub fn factor_attribute( &self, entity: Entity, authorization: Token, ) -> FactorAttribute<Self>

impl SessionAsync

pub fn sort_factors( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> SortFactors<Self>

impl SessionAsync

pub fn purge_factors( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> PurgeFactors<Self>

impl SessionAsync

pub fn retrieve_factors( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> RetrieveFactors<Self>

impl SessionAsync

pub fn insert_fact( &self, entity: Entity, attribute: Attribute, value: Value, authorization: Token, ) -> InsertFact<Self>

impl SessionAsync

pub fn remove_fact( &self, entity: Entity, index: i64, authorization: Token, ) -> RemoveFact<Self>

impl SessionAsync

pub fn replace_fact( &self, entity: Entity, index: i64, attribute: Attribute, value: Value, authorization: Token, ) -> ReplaceFact<Self>

impl SessionAsync

pub fn find_fact( &self, entity: Entity, value: Value, authorization: Token, ) -> FindFact<Self>

impl SessionAsync

pub fn include_fact( &self, entity: Entity, attribute: Attribute, value: Value, authorization: Token, ) -> IncludeFact<Self>

impl SessionAsync

pub fn exclude_fact( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> ExcludeFact<Self>

impl SessionAsync

pub fn set_fact( &self, entity: Entity, attribute: Attribute, value: Value, authorization: Token, ) -> SetFact<Self>

impl SessionAsync

pub fn get_fact( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> GetFact<Self>

impl SessionAsync

pub fn clear_fact( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> ClearFact<Self>

impl SessionAsync

pub fn fact_count( &self, entity: Entity, authorization: Token, ) -> FactCount<Self>

impl SessionAsync

pub fn fact_member( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FactMember<Self>

impl SessionAsync

pub fn fact_name( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FactName<Self>

impl SessionAsync

pub fn fact_key( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FactKey<Self>

impl SessionAsync

pub fn fact_value( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FactValue<Self>

impl SessionAsync

pub fn fact_index( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FactIndex<Self>

impl SessionAsync

pub fn fact_attribute( &self, entity: Entity, index: i64, authorization: Token, ) -> FactAttribute<Self>

impl SessionAsync

pub fn sort_facts( &self, entity: Entity, authorization: Token, ) -> SortFacts<Self>

impl SessionAsync

pub fn purge_facts( &self, entity: Entity, authorization: Token, ) -> PurgeFacts<Self>

impl SessionAsync

pub fn retrieve_facts( &self, entity: Entity, authorization: Token, ) -> RetrieveFacts<Self>

impl SessionAsync

pub fn insert_feature( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, value: Value, authorization: Token, ) -> InsertFeature<Self>

impl SessionAsync

pub fn remove_feature( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> RemoveFeature<Self>

impl SessionAsync

pub fn replace_feature( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, value: Value, authorization: Token, ) -> ReplaceFeature<Self>

impl SessionAsync

pub fn find_feature( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FindFeature<Self>

impl SessionAsync

pub fn include_feature( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, value: Value, authorization: Token, ) -> IncludeFeature<Self>

impl SessionAsync

pub fn exclude_feature( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> ExcludeFeature<Self>

impl SessionAsync

pub fn set_feature( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, value: Value, authorization: Token, ) -> SetFeature<Self>

impl SessionAsync

pub fn get_feature( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> GetFeature<Self>

impl SessionAsync

pub fn clear_feature( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> ClearFeature<Self>

impl SessionAsync

pub fn feature_count( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FeatureCount<Self>

impl SessionAsync

pub fn feature_member( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FeatureMember<Self>

impl SessionAsync

pub fn feature_name( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FeatureName<Self>

impl SessionAsync

pub fn feature_key( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> FeatureKey<Self>

impl SessionAsync

pub fn feature_value( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FeatureValue<Self>

impl SessionAsync

pub fn feature_index( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FeatureIndex<Self>

impl SessionAsync

pub fn feature_attribute( &self, entity: Entity, authorization: Token, ) -> FeatureAttribute<Self>

impl SessionAsync

pub fn sort_features( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> SortFeatures<Self>

impl SessionAsync

pub fn purge_features( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> PurgeFeatures<Self>

impl SessionAsync

pub fn retrieve_features( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> RetrieveFeatures<Self>

impl SessionAsync

pub fn insert_field( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> InsertField<Self>

impl SessionAsync

pub fn remove_field( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> RemoveField<Self>

impl SessionAsync

pub fn replace_field( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> ReplaceField<Self>

impl SessionAsync

pub fn find_field( &self, entity: Entity, attribute: Attribute, value: Value, authorization: Token, ) -> FindField<Self>

impl SessionAsync

pub fn include_field( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> IncludeField<Self>

impl SessionAsync

pub fn exclude_field( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> ExcludeField<Self>

impl SessionAsync

pub fn set_field( &self, entity: Entity, attribute: Attribute, name: String255, value: Value, authorization: Token, ) -> SetField<Self>

impl SessionAsync

pub fn get_field( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> GetField<Self>

impl SessionAsync

pub fn clear_field( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> ClearField<Self>

impl SessionAsync

pub fn field_count( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FieldCount<Self>

impl SessionAsync

pub fn field_member( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FieldMember<Self>

impl SessionAsync

pub fn field_name( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> FieldName<Self>

impl SessionAsync

pub fn field_key( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FieldKey<Self>

impl SessionAsync

pub fn field_value( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FieldValue<Self>

impl SessionAsync

pub fn field_index( &self, entity: Entity, attribute: Attribute, name: String255, authorization: Token, ) -> FieldIndex<Self>

impl SessionAsync

pub fn field_attribute( &self, entity: Entity, authorization: Token, ) -> FieldAttribute<Self>

impl SessionAsync

pub fn sort_fields( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> SortFields<Self>

impl SessionAsync

pub fn purge_fields( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> PurgeFields<Self>

impl SessionAsync

pub fn retrieve_fields( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> RetrieveFields<Self>

impl SessionAsync

pub fn insert_frame( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> InsertFrame<Self>

impl SessionAsync

pub fn remove_frame( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> RemoveFrame<Self>

impl SessionAsync

pub fn replace_frame( &self, entity: Entity, attribute: Attribute, index: i64, key: String255, authorization: Token, ) -> ReplaceFrame<Self>

impl SessionAsync

pub fn find_frame( &self, entity: Entity, authorization: Token, ) -> FindFrame<Self>

impl SessionAsync

pub fn include_frame( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> IncludeFrame<Self>

impl SessionAsync

pub fn exclude_frame( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> ExcludeFrame<Self>

impl SessionAsync

pub fn set_frame( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, value: Value, authorization: Token, ) -> SetFrame<Self>

impl SessionAsync

pub fn get_frame( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, authorization: Token, ) -> GetFrame<Self>

impl SessionAsync

pub fn clear_frame( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, authorization: Token, ) -> ClearFrame<Self>

impl SessionAsync

pub fn frame_count( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> FrameCount<Self>

impl SessionAsync

pub fn frame_member( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FrameMember<Self>

impl SessionAsync

pub fn frame_name( &self, entity: Entity, attribute: Attribute, offset: i32, authorization: Token, ) -> FrameName<Self>

impl SessionAsync

pub fn frame_key( &self, entity: Entity, attribute: Attribute, index: i64, authorization: Token, ) -> FrameKey<Self>

impl SessionAsync

pub fn frame_value( &self, entity: Entity, attribute: Attribute, key: String255, name: String255, authorization: Token, ) -> FrameValue<Self>

impl SessionAsync

pub fn frame_index( &self, entity: Entity, attribute: Attribute, key: String255, authorization: Token, ) -> FrameIndex<Self>

impl SessionAsync

pub fn frame_attribute( &self, entity: Entity, authorization: Token, ) -> FrameAttribute<Self>

impl SessionAsync

pub fn sort_frames( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> SortFrames<Self>

impl SessionAsync

pub fn purge_frames( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> PurgeFrames<Self>

impl SessionAsync

pub fn retrieve_frames( &self, entity: Entity, attribute: Attribute, authorization: Token, ) -> RetrieveFrames<Self>

impl SessionAsync

pub fn insert_property( &self, entity: Entity, key: String255, name: String255, value: Value, authorization: Token, ) -> InsertProperty<Self>

impl SessionAsync

pub fn remove_property( &self, entity: Entity, index: i64, authorization: Token, ) -> RemoveProperty<Self>

impl SessionAsync

pub fn replace_property( &self, entity: Entity, index: i64, key: String255, name: String255, value: Value, authorization: Token, ) -> ReplaceProperty<Self>

impl SessionAsync

pub fn find_property( &self, entity: Entity, name: String255, value: Value, authorization: Token, ) -> FindProperty<Self>

impl SessionAsync

pub fn include_property( &self, entity: Entity, key: String255, name: String255, value: Value, authorization: Token, ) -> IncludeProperty<Self>

impl SessionAsync

pub fn exclude_property( &self, entity: Entity, key: String255, authorization: Token, ) -> ExcludeProperty<Self>

impl SessionAsync

pub fn set_property( &self, entity: Entity, key: String255, name: String255, value: Value, authorization: Token, ) -> SetProperty<Self>

impl SessionAsync

pub fn get_property( &self, entity: Entity, key: String255, authorization: Token, ) -> GetProperty<Self>

impl SessionAsync

pub fn clear_property( &self, entity: Entity, key: String255, authorization: Token, ) -> ClearProperty<Self>

impl SessionAsync

pub fn property_count( &self, entity: Entity, authorization: Token, ) -> PropertyCount<Self>

impl SessionAsync

pub fn property_member( &self, entity: Entity, key: String255, authorization: Token, ) -> PropertyMember<Self>

impl SessionAsync

pub fn property_name( &self, entity: Entity, key: String255, authorization: Token, ) -> PropertyName<Self>

impl SessionAsync

pub fn property_key( &self, entity: Entity, index: i64, authorization: Token, ) -> PropertyKey<Self>

impl SessionAsync

pub fn property_value( &self, entity: Entity, key: String255, authorization: Token, ) -> PropertyValue<Self>

impl SessionAsync

pub fn property_index( &self, entity: Entity, key: String255, authorization: Token, ) -> PropertyIndex<Self>

impl SessionAsync

pub fn property_attribute( &self, entity: Entity, authorization: Token, ) -> PropertyAttribute<Self>

impl SessionAsync

pub fn sort_properties( &self, entity: Entity, authorization: Token, ) -> SortProperties<Self>

impl SessionAsync

pub fn purge_properties( &self, entity: Entity, authorization: Token, ) -> PurgeProperties<Self>

impl SessionAsync

pub fn retrieve_properties( &self, entity: Entity, authorization: Token, ) -> RetrieveProperties<Self>

impl SessionAsync

pub fn create_registry( &self, name: String255, authorization: Token, ) -> CreateRegistry<Self>

impl SessionAsync

pub fn delete_registry( &self, registry: Entity, authorization: Token, ) -> DeleteRegistry<Self>

impl SessionAsync

pub fn register_entity( &self, registry: Entity, key: String255, name: String255, entity: Entity, authorization: Token, ) -> RegisterEntity<Self>

impl SessionAsync

pub fn deregister_entity( &self, registry: Entity, key: String255, authorization: Token, ) -> DeregisterEntity<Self>

impl SessionAsync

pub fn purge_registry( &self, registry: Entity, authorization: Token, ) -> PurgeRegistry<Self>

impl SessionAsync

pub fn sort_registry( &self, registry: Entity, authorization: Token, ) -> SortRegistry<Self>

impl SessionAsync

pub fn lookup_registry( &self, registry: Entity, key: String255, authorization: Token, ) -> LookupRegistry<Self>

impl SessionAsync

pub fn registry_member( &self, registry: Entity, key: String255, authorization: Token, ) -> RegistryMember<Self>

impl SessionAsync

pub fn registry_item( &self, registry: Entity, index: i64, authorization: Token, ) -> RegistryItem<Self>

impl SessionAsync

pub fn registry_count( &self, registry: Entity, authorization: Token, ) -> RegistryCount<Self>

impl SessionAsync

pub fn retrieve_registry( &self, registry: Entity, authorization: Token, ) -> RetrieveRegistry<Self>

impl SessionAsync

pub fn save_entity( &self, entity: Entity, authorization: Token, ) -> SaveEntity<Self>

impl SessionAsync

pub fn restore_entity( &self, entity: Entity, authorization: Token, ) -> RestoreEntity<Self>

impl SessionAsync

pub fn retrieve_entity( &self, entity: Entity, authorization: Token, ) -> RetrieveEntity<Self>

impl SessionAsync

pub fn store_entity( &self, entity: Entity, model: AvialModel, authorization: Token, ) -> StoreEntity<Self>

impl SessionAsync

pub fn purge_entity( &self, entity: Entity, authorization: Token, ) -> PurgeEntity<Self>

impl SessionAsync

pub fn redirect( &self, from: Entity, to: Entity, authorization: Token, ) -> Redirect<Self>

impl SessionAsync

pub fn create_outlet( &self, name: String255, authorization: Token, ) -> CreateOutlet<Self>

impl SessionAsync

pub fn create_object( &self, name: String255, authorization: Token, ) -> CreateObject<Self>

impl SessionAsync

pub fn delete_object( &self, object: Entity, authorization: Token, ) -> DeleteObject<Self>

impl SessionAsync

pub fn create_general( &self, name: String255, authorization: Token, ) -> CreateGeneral<Self>

impl SessionAsync

pub fn delete_general( &self, general: Entity, authorization: Token, ) -> DeleteGeneral<Self>

impl SessionAsync

pub fn invoke_locutor(&self, locutor: Locutor) -> InvokeLocutor<Self>

impl SessionAsync

pub fn raw_message(&self, msg: HGTPMessage) -> RawMessage<Self>

Trait Implementations

impl Clone for SessionAsync

fn clone(&self) -> SessionAsync

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl SessionTrait for SessionAsync

fn get_async_session(&self) -> &SessionAsync

fn get_socket_pool(&self) -> &HGTPPool