Method List
Search:
- #<< Concurrent::ImmediateExecutor
- #<< Concurrent::Agent
- #<< Concurrent::SimpleExecutorService
- #<< Concurrent::JavaExecutorService
- #<< Concurrent::JavaSingleThreadExecutor
- #<< Concurrent::ExecutorService
- #<< Concurrent::AbstractExecutorService
- #<< Concurrent::RubyExecutorService
- #<< Concurrent::RubySingleThreadExecutor
- #<< Concurrent::Edge::LockFreeLinkedSet
- #<< Concurrent::SingleThreadExecutor
- #<< Concurrent::RubyThreadPoolExecutor::Worker
- << Concurrent::SimpleExecutorService
- #<< Concurrent::ThreadPoolExecutor
- #<=> Concurrent::Edge::LockFreeLinkedSet::Node
- #<=> Concurrent::Maybe
- #<=> Concurrent::Edge::LockFreeLinkedSet::Head
- #<=> Concurrent::Edge::LockFreeLinkedSet::Tail
- #<=> Concurrent::Channel::Tick
- #== Concurrent::Actor::Reference
- #== Concurrent::MutableStruct
- #== Concurrent::ImmutableStruct
- #== Concurrent::SettableStruct
- #Child! Concurrent::Actor::TypeCheck
- #Child? Concurrent::Actor::TypeCheck
- #Match! Concurrent::Actor::TypeCheck
- #Match? Concurrent::Actor::TypeCheck
- #Type! Concurrent::Actor::TypeCheck
- #Type? Concurrent::Actor::TypeCheck
- #[] Concurrent::Collection::AtomicReferenceMapBackend
- #[] Concurrent::SettableStruct
- #[] Concurrent::ImmutableStruct
- #[] Concurrent::LazyRegister
- #[] Concurrent::MutableStruct
- #[] Concurrent::Collection::NonConcurrentMapBackend
- #[] Concurrent::Map
- #[] Concurrent::Collection::SynchronizedMapBackend
- #[]= Concurrent::Collection::AtomicReferenceMapBackend
- #[]= Concurrent::MutableStruct
- #[]= Concurrent::Collection::MriMapBackend
- #[]= Concurrent::Collection::NonConcurrentMapBackend
- #[]= Concurrent::SettableStruct
- #[]= Concurrent::Collection::SynchronizedMapBackend
- #_compare_and_set Concurrent::CAtomicReference
- #_compare_and_set Concurrent::MutexAtomicReference
- #abort Concurrent::Transaction
- abort_transaction Concurrent
- #acquire Concurrent::Semaphore
- #acquire Concurrent::MutexSemaphore
- #acquire_read_lock Concurrent::ReentrantReadWriteLock
- #acquire_read_lock Concurrent::ReadWriteLock
- #acquire_write_lock Concurrent::ReentrantReadWriteLock
- #acquire_write_lock Concurrent::ReadWriteLock
- act Concurrent::ProcessingActor
- act_listening Concurrent::ProcessingActor
- #action Concurrent::Agent::Job
- #actor_class Concurrent::Actor::Core
- #add Concurrent::Edge::LockFreeLinkedSet
- #add Concurrent::AtExitImplementation
- #add Concurrent::ThreadSafe::Util::Adder
- #add_callback_notify_blocked Concurrent::Promises::AbstractEventFuture
- #add_child Concurrent::Actor::Core
- add_delayed Concurrent::Promises::BlockedPromise
- #add_observer Concurrent::IVar
- #add_observer Concurrent::Concern::Observable
- #add_observer Concurrent::Collection::CopyOnWriteObserverSet
- #add_observer Concurrent::Collection::CopyOnNotifyObserverSet
- #address Concurrent::Actor::Envelope
- #address_path Concurrent::Actor::Envelope
- #after Concurrent::Channel::Selector
- all? Concurrent::Promise
- #allocate_context Concurrent::Actor::Core
- #allow_c_extensions? Concurrent::Utility::NativeExtensionLoader
- #any Concurrent::Promises::Future
- #any Concurrent::Promises::Event
- any? Concurrent::Promise
- #any_event Concurrent::Promises::FactoryMethods
- #any_event_on Concurrent::Promises::FactoryMethods
- #any_fulfilled_future Concurrent::Promises::FactoryMethods
- #any_fulfilled_future_on Concurrent::Promises::FactoryMethods
- #any_resolved_future Concurrent::Promises::FactoryMethods
- #any_resolved_future_on Concurrent::Promises::FactoryMethods
- #args Concurrent::Agent::Job
- #args Concurrent::SerializedExecution::Job
- #ask Concurrent::Actor::Reference
- #ask Concurrent::Actor::AbstractContext
- #ask Concurrent::ProcessingActor
- #ask! Concurrent::Actor::Reference
- #async Concurrent::Async
- atomically Concurrent
- attr_atomic Concurrent::Synchronization::Object
- #attr_volatile Concurrent::Synchronization::RbxAttrVolatile::ClassMethods
- attr_volatile Concurrent::Synchronization::AbstractObject
- attr_volatile Concurrent::Synchronization::Object
- #attr_volatile Concurrent::Synchronization::TruffleAttrVolatile::ClassMethods
- #attr_volatile Concurrent::ThreadSafe::Util::Volatile
- #attr_volatile Concurrent::Synchronization::JRubyAttrVolatile::ClassMethods
- #attr_volatile Concurrent::Synchronization::MriAttrVolatile::ClassMethods
- #auto_terminate= Concurrent::JavaSingleThreadExecutor
- #auto_terminate= Concurrent::AbstractExecutorService
- #auto_terminate= Concurrent::SingleThreadExecutor
- #auto_terminate= Concurrent::RubySingleThreadExecutor
- #auto_terminate= Concurrent::RubyExecutorService
- #auto_terminate= Concurrent::JavaExecutorService
- #auto_terminate= Concurrent::ThreadPoolExecutor
- #auto_terminate? Concurrent::RubyExecutorService
- #auto_terminate? Concurrent::JavaExecutorService
- #auto_terminate? Concurrent::JavaSingleThreadExecutor
- #auto_terminate? Concurrent::ThreadPoolExecutor
- #auto_terminate? Concurrent::AbstractExecutorService
- #auto_terminate? Concurrent::SingleThreadExecutor
- #auto_terminate? Concurrent::RubySingleThreadExecutor
- #available_permits Concurrent::MutexSemaphore
- #available_permits Concurrent::Semaphore
- #await Concurrent::Agent
- await Concurrent::Agent
- #await Concurrent::Async
- await_for Concurrent::Agent
- #await_for Concurrent::Agent
- await_for! Concurrent::Agent
- #await_for! Concurrent::Agent
- base Concurrent::Actor::Behaviour
- basic_behaviour_definition Concurrent::Actor::Behaviour
- #behaviour Concurrent::Actor::InternalDelegations
- #behaviour Concurrent::Actor::Core
- #behaviour! Concurrent::Actor::Core
- #behaviour! Concurrent::Actor::InternalDelegations
- #behaviour_definition Concurrent::Actor::Context
- #behaviour_definition Concurrent::Actor::Root
- #behaviour_definition Concurrent::Actor::Core
- #behaviour_definition Concurrent::Actor::RestartingContext
- #behaviour_definition Concurrent::Actor::AbstractContext
- #bind Concurrent::AbstractThreadLocalVar
- #bind Concurrent::ThreadLocalVar
- #block Concurrent::SerializedExecution::Job
- #blocked_by Concurrent::Promises::BlockedPromise
- #blocking? Concurrent::Channel::Buffer::Dropping
- #blocking? Concurrent::Channel::Buffer::Sliding
- #blocking? Concurrent::Channel::Buffer::Base
- #borrow Concurrent::MVar
- #broadcast Concurrent::Synchronization::Condition
- #broadcast Concurrent::Synchronization::Lock
- #broadcast Concurrent::Actor::Behaviour::Abstract
- #broadcast Concurrent::Actor::Core
- #broadcast Concurrent::Synchronization::LockableObject
- #broken? Concurrent::CyclicBarrier
- #build_context Concurrent::Actor::Core
- #c_extensions_loaded? Concurrent::Utility::NativeExtensionLoader
- call_dataflow Concurrent
- #caller Concurrent::Agent::Job
- #can_overflow? Concurrent::JavaThreadPoolExecutor
- #can_overflow? Concurrent::JavaSingleThreadExecutor
- #can_overflow? Concurrent::RubyExecutorService
- #can_overflow? Concurrent::RubySingleThreadExecutor
- #can_overflow? Concurrent::AbstractExecutorService
- #can_overflow? Concurrent::JavaExecutorService
- #can_overflow? Concurrent::RubyThreadPoolExecutor
- #can_overflow? Concurrent::ExecutorService
- #can_overflow? Concurrent::SingleThreadExecutor
- #can_overflow? Concurrent::ThreadPoolExecutor
- #cancel Concurrent::ScheduledTask
- #cancel Concurrent::Cancellation
- #cancel Concurrent::Future
- #canceled? Concurrent::Cancellation
- #canceled? Concurrent::Cancellation::Token
- #cancelled? Concurrent::Future
- #cancelled? Concurrent::ScheduledTask
- #capacity Concurrent::Channel::Buffer::Base
- #cas_computed Concurrent::ThreadSafe::Util::Striped64::Cell
- #cas_new_node Concurrent::Collection::AtomicReferenceMapBackend::Table
- #case Concurrent::Channel::Selector
- #chain Concurrent::Promises::AbstractEventFuture
- #chain_on Concurrent::Promises::AbstractEventFuture
- #chain_resolvable Concurrent::Promises::AbstractEventFuture
- #chain_throttled_by Concurrent::Promises::AbstractEventFuture::ThrottleIntegration
- #children Concurrent::Actor::InternalDelegations
- #children Concurrent::Actor::Core
- #clear Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #clear Concurrent::LockFreeStack
- #clear Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #clear Concurrent::Collection::NonConcurrentPriorityQueue
- #clear Concurrent::Collection::SynchronizedMapBackend
- #clear Concurrent::Collection::MriMapBackend
- #clear Concurrent::Collection::NonConcurrentMapBackend
- #clear Concurrent::Collection::AtomicReferenceMapBackend
- #clear_each Concurrent::LockFreeStack
- #clear_if Concurrent::LockFreeStack
- #close Concurrent::Channel::Buffer::Base
- #closed? Concurrent::Channel::Buffer::Base
- #commit Concurrent::Transaction
- #compare_and_clear Concurrent::LockFreeStack
- #compare_and_pop Concurrent::LockFreeStack
- #compare_and_push Concurrent::LockFreeStack
- #compare_and_set Concurrent::CAtomicReference
- #compare_and_set Concurrent::Edge::AtomicMarkableReference
- #compare_and_set Concurrent::RbxAtomicReference
- #compare_and_set Concurrent::Tuple
- #compare_and_set Concurrent::AtomicReference
- #compare_and_set Concurrent::AtomicFixnum
- #compare_and_set Concurrent::MutexAtomicReference
- #compare_and_set Top Level Namespace
- #compare_and_set Concurrent::JavaAtomicReference
- #compare_and_set Concurrent::ConcurrentUpdateError
- #compare_and_set Concurrent::AtomicNumericCompareAndSetWrapper
- #compare_and_set Concurrent::MutexAtomicFixnum
- #compare_and_set Concurrent::Atom
- #complete? Concurrent::Concern::Obligation
- #completed_task_count Concurrent::RubyThreadPoolExecutor
- #completed_task_count Concurrent::ThreadPoolExecutor
- #completed_task_count Concurrent::JavaThreadPoolExecutor
- #compute Concurrent::Collection::AtomicReferenceMapBackend
- #compute Concurrent::Collection::MriMapBackend
- #compute Concurrent::Collection::NonConcurrentMapBackend
- #compute Concurrent::Map
- #compute Concurrent::Collection::SynchronizedMapBackend
- #compute_if_absent Concurrent::Collection::NonConcurrentMapBackend
- #compute_if_absent Concurrent::Collection::MriMapBackend
- #compute_if_absent Concurrent::Collection::SynchronizedMapBackend
- #compute_if_absent Concurrent::Map
- #compute_if_absent Concurrent::Collection::AtomicReferenceMapBackend
- #compute_if_present Concurrent::Collection::NonConcurrentMapBackend
- #compute_if_present Concurrent::Map
- #compute_if_present Concurrent::Collection::SynchronizedMapBackend
- #compute_if_present Concurrent::Collection::MriMapBackend
- #compute_if_present Concurrent::Collection::AtomicReferenceMapBackend
- #contains? Concurrent::Edge::LockFreeLinkedSet
- #context Concurrent::Actor::Core
- #context Concurrent::Actor::InternalDelegations
- #context_class Concurrent::Actor::PublicDelegations
- #context_class Concurrent::Actor::Core
- #core Concurrent::Actor::AbstractContext
- #core Concurrent::Actor::Behaviour::Abstract
- #count Concurrent::JavaCountDownLatch
- #count Concurrent::CountDownLatch
- #count Concurrent::MutexCountDownLatch
- #count_down Concurrent::JavaCountDownLatch
- #count_down Concurrent::CountDownLatch
- #count_down Concurrent::MutexCountDownLatch
- #count_observers Concurrent::Collection::CopyOnNotifyObserverSet
- #count_observers Concurrent::Collection::CopyOnWriteObserverSet
- #count_observers Concurrent::Concern::Observable
- #create Concurrent::Promises::FactoryMethods
- create Concurrent::Cancellation
- create_simple_logger Concurrent
- create_stdlib_logger Concurrent
- #curr Concurrent::Edge::LockFreeLinkedSet::Window
- current Concurrent::Actor
- current Concurrent::Transaction
- current= Concurrent::Transaction
- #data Concurrent::Edge::LockFreeLinkedSet::Node
- dataflow Concurrent
- dataflow! Concurrent
- dataflow_with Concurrent
- dataflow_with! Concurrent
- #dead_letter_routing Concurrent::Actor::Core
- #dead_letter_routing Concurrent::Actor::Reference
- #dead_letter_routing Concurrent::Actor::AbstractContext
- #dead_letter_routing Concurrent::Actor::Root
- #dead_letter_routing Concurrent::Actor::InternalDelegations
- #decrement Concurrent::ThreadSafe::Util::Adder
- #decrement Concurrent::AtomicFixnum
- #decrement Concurrent::MutexAtomicFixnum
- #default Concurrent::Channel::Selector
- #default_executor Concurrent::Promises::AbstractEventFuture
- #default_executor Concurrent::Actor::AbstractContext
- #default_executor Concurrent::Promises::FactoryMethods::Configuration
- #default_reference_class Concurrent::Actor::AbstractContext
- #delay Concurrent::Promises::FactoryMethods
- #delay Concurrent::Promises::Future
- #delay Concurrent::Promises::Event
- #delay_on Concurrent::Promises::FactoryMethods
- #delayed_because Concurrent::Promises::BlockedPromise
- #delayed_because Concurrent::Promises::DelayPromise
- #delete Concurrent::Collection::SynchronizedMapBackend
- #delete Concurrent::Map
- #delete Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #delete Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #delete Concurrent::Collection::AtomicReferenceMapBackend
- #delete Concurrent::Collection::NonConcurrentMapBackend
- #delete Concurrent::Collection::NonConcurrentPriorityQueue
- #delete Concurrent::Collection::MriMapBackend
- #delete Concurrent::AtExitImplementation
- #delete_node_at Concurrent::Collection::AtomicReferenceMapBackend::Table
- #delete_observer Concurrent::Collection::CopyOnWriteObserverSet
- #delete_observer Concurrent::Concern::Observable
- #delete_observer Concurrent::Collection::CopyOnNotifyObserverSet
- #delete_observers Concurrent::Collection::CopyOnNotifyObserverSet
- #delete_observers Concurrent::Collection::CopyOnWriteObserverSet
- #delete_observers Concurrent::Concern::Observable
- #delete_pair Concurrent::Collection::SynchronizedMapBackend
- #delete_pair Concurrent::Collection::AtomicReferenceMapBackend
- #delete_pair Concurrent::Collection::NonConcurrentMapBackend
- #delete_pair Concurrent::Map
- #delete_pair Concurrent::Collection::MriMapBackend
- #deprecated Concurrent::Concern::Deprecation
- #deprecated_method Concurrent::Concern::Deprecation
- disable_at_exit_handlers! Concurrent
- #distribute Concurrent::Actor::Utils::Balancer
- #drain_permits Concurrent::Semaphore
- #drain_permits Concurrent::MutexSemaphore
- #each Concurrent::MutableStruct
- #each Concurrent::ImmutableStruct
- #each Concurrent::Edge::LockFreeLinkedSet
- #each Concurrent::SettableStruct
- #each Concurrent::Tuple
- #each Concurrent::LockFreeStack
- #each Concurrent::Channel
- #each_key Concurrent::Map
- #each_pair Concurrent::ImmutableStruct
- #each_pair Concurrent::MutableStruct
- #each_pair Concurrent::SettableStruct
- #each_pair Concurrent::Collection::NonConcurrentMapBackend
- #each_pair Concurrent::Collection::AtomicReferenceMapBackend
- #each_value Concurrent::Map
- #empty? Concurrent::Channel::Buffer::Unbuffered
- #empty? Concurrent::Map
- #empty? Concurrent::Collection::AtomicReferenceMapBackend
- #empty? Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #empty? Concurrent::LockFreeStack
- #empty? Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #empty? Concurrent::MVar
- #empty? Concurrent::Collection::NonConcurrentPriorityQueue
- #empty? Concurrent::Channel::Buffer::Base
- #enabled= Concurrent::AtExitImplementation
- #enabled? Concurrent::AtExitImplementation
- ensure_safe_initialization_when_final_fields_are_present Concurrent::Synchronization::Object
- #envelope Concurrent::Actor::AbstractContext
- #envelope Concurrent::Actor::UnknownMessage
- #epoch Concurrent::Channel::Tick
- #error Concurrent::Agent
- #error Concurrent::Channel::Selector
- #error_mode Concurrent::Agent
- #error_strategy Concurrent::Actor::Behaviour::SetResults
- #errors Concurrent::MultipleErrors
- #evaluate_to Concurrent::Promises::ResolvableFuture
- #evaluate_to Concurrent::Promises::ResolvableFuturePromise
- #evaluate_to! Concurrent::Promises::ResolvableFuture
- #evaluate_to! Concurrent::Promises::ResolvableFuturePromise
- #exception Concurrent::Concern::Obligation
- #exception Concurrent::Promises::Future
- #exchange Concurrent::Exchanger
- #exchange Concurrent::AbstractExchanger
- #exchange! Concurrent::AbstractExchanger
- #exchange! Concurrent::Exchanger
- #execute Concurrent::Channel::Selector
- execute Concurrent::Promise
- #execute Concurrent::Promise
- #execute Concurrent::Channel::Selector::DefaultClause
- #execute Concurrent::ScheduledTask
- execute Concurrent::ScheduledTask
- #execute Concurrent::Channel::Selector::PutClause
- #execute Concurrent::SafeTaskExecutor
- execute Concurrent::Future
- #execute Concurrent::Future
- #execute Concurrent::TimerTask
- execute Concurrent::TimerTask
- #execute Concurrent::Channel::Selector::TakeClause
- #execute Concurrent::Channel::Selector::AfterClause
- #execute Concurrent::Channel::Selector::ErrorClause
- #execution_interval Concurrent::TimerTask
- #executor Concurrent::Actor::PublicDelegations
- #executor Concurrent::SerializedExecution::Job
- #executor Concurrent::Agent::Job
- #executor Concurrent::Actor::Core
- executor Concurrent
- #executor Concurrent::Promises::BlockedTaskPromise
- executor Concurrent::Options
- #extended Concurrent::Promises::ReInclude
- #fail Concurrent::Promise
- #fail Concurrent::IVar
- #failed? Concurrent::Agent
- #fallback_policy Concurrent::JavaExecutorService
- #fallback_policy Concurrent::AbstractExecutorService
- #fallback_policy Concurrent::JavaSingleThreadExecutor
- #fallback_policy Concurrent::SingleThreadExecutor
- #fallback_policy Concurrent::RubyExecutorService
- #fallback_policy Concurrent::RubySingleThreadExecutor
- #fallback_policy Concurrent::ThreadPoolExecutor
- #false? Concurrent::MutexAtomicBoolean
- #false? Concurrent::AtomicBoolean
- #fetch Concurrent::Map
- #fetch_or_store Concurrent::Map
- #filtered_receivers Concurrent::Actor::Utils::Broadcast
- find Concurrent::Edge::LockFreeLinkedSet::Window
- #flat_event Concurrent::Promises::Future
- #flat_future Concurrent::Promises::Future
- #flat_map Concurrent::Promise
- from Concurrent::Maybe
- from_list Concurrent::Collection::NonConcurrentPriorityQueue
- from_list Concurrent::Collection::RubyNonConcurrentPriorityQueue
- from_list Concurrent::Collection::JavaNonConcurrentPriorityQueue
- fulfill Concurrent::Promise
- #fulfill Concurrent::Promises::ResolvableFuture
- #fulfill Concurrent::Promises::ResolvableFuturePromise
- #fulfilled? Concurrent::Concern::Obligation
- #fulfilled? Concurrent::Promises::Future
- #fulfilled_future Concurrent::Promises::FactoryMethods
- #full? Concurrent::Channel::Buffer::Dropping
- #full? Concurrent::Channel::Buffer::Base
- #full? Concurrent::Channel::Buffer::Unbuffered
- #full? Concurrent::Channel::Buffer::Sliding
- #full? Concurrent::MVar
- #full_memory_barrier Concurrent::Synchronization::MriAttrVolatile
- #full_memory_barrier Concurrent::Synchronization::RbxAttrVolatile
- #full_memory_barrier Concurrent::Synchronization::TruffleAttrVolatile
- #future Concurrent::Actor::Envelope
- #future Concurrent::Promises::FactoryMethods
- #future_on Concurrent::Promises::FactoryMethods
- #get Concurrent::CAtomicReference
- #get Concurrent::AtomicReference
- #get Concurrent::RbxAtomicReference
- #get Concurrent::JavaAtomicReference
- #get Top Level Namespace
- #get Concurrent::ThreadSafe::Util::XorShiftRandom
- #get Concurrent::MutexAtomicReference
- #get Concurrent::Tuple
- #get Concurrent::Edge::AtomicMarkableReference
- #get Concurrent::ConcurrentUpdateError
- #get_and_set Concurrent::AtomicReference
- #get_and_set Concurrent::Map
- #get_and_set Top Level Namespace
- #get_and_set Concurrent::RbxAtomicReference
- #get_and_set Concurrent::CAtomicReference
- #get_and_set Concurrent::JavaAtomicReference
- #get_and_set Concurrent::MutexAtomicReference
- #get_and_set Concurrent::Collection::MriMapBackend
- #get_and_set Concurrent::Collection::SynchronizedMapBackend
- #get_and_set Concurrent::ConcurrentUpdateError
- #get_and_set Concurrent::Collection::NonConcurrentMapBackend
- #get_and_set Concurrent::Collection::AtomicReferenceMapBackend
- #get_or_default Concurrent::Collection::AtomicReferenceMapBackend
- #get_or_default Concurrent::Collection::SynchronizedMapBackend
- #get_or_default Concurrent::Collection::NonConcurrentMapBackend
- global_fast_executor Concurrent
- global_immediate_executor Concurrent
- global_io_executor Concurrent
- global_logger Concurrent
- global_logger= Concurrent
- global_timer_set Concurrent
- go Concurrent::Channel
- go_loop Concurrent::Channel
- go_loop_via Concurrent::Channel
- go_via Concurrent::Channel
- #guard! Concurrent::Actor::Core
- #handler? Concurrent::AtExitImplementation
- #handlers Concurrent::AtExitImplementation
- #has_waiters? Concurrent::ReadWriteLock
- #hash_to_index Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #idletime Concurrent::RubyThreadPoolExecutor
- #idletime Concurrent::ThreadPoolExecutor
- #idletime Concurrent::JavaThreadPoolExecutor
- #include Concurrent::Promises::ReInclude
- #include? Concurrent::Collection::NonConcurrentPriorityQueue
- #include? Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #include? Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #included Concurrent::Promises::ReInclude
- #incomplete? Concurrent::Concern::Obligation
- #increment Concurrent::MutexAtomicFixnum
- #increment Concurrent::ThreadSafe::Util::Adder
- #increment Concurrent::AtomicFixnum
- #initial_delay Concurrent::ScheduledTask
- #initialize Concurrent::Promises::ImmediateFuturePromise
- #initialize Concurrent::Promises::ImmediateEventPromise
- #initialize Concurrent::LockFreeQueue::Node
- #initialize Concurrent::LockFreeQueue
- #initialize Concurrent::Future
- #initialize Concurrent::Promises::BlockedTaskPromise
- #initialize Concurrent::Actor::ActorTerminated
- #initialize Concurrent::Promises::BlockedPromise
- #initialize Concurrent::Channel::Selector::AfterClause
- #initialize Concurrent::Actor::UnknownMessage
- #initialize Concurrent::RbxAtomicReference
- #initialize Concurrent::Tuple
- #initialize Concurrent::MutexAtomicReference
- #initialize Concurrent::Channel::Tick
- #initialize Concurrent::MutexCountDownLatch
- #initialize Concurrent::ThreadPoolExecutor
- #initialize Concurrent::Actor::Utils::Balancer
- #initialize Concurrent::Collection::NonConcurrentPriorityQueue
- #initialize Concurrent::Throttle
- #initialize Concurrent::LockFreeStack::Node
- #initialize Concurrent::Actor::Core
- #initialize Concurrent::LockFreeStack
- #initialize Concurrent::Promises::ResolvableFuturePromise
- #initialize Concurrent::JavaThreadPoolExecutor
- #initialize Concurrent::Collection::AtomicReferenceMapBackend::Node
- #initialize Concurrent::RubyExecutorService
- #initialize Concurrent::Map
- #initialize Concurrent::AbstractExecutorService
- #initialize Concurrent::Synchronization::RbxLockableObject
- #initialize Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #initialize Concurrent::Actor::Utils::AsAdHoc
- #initialize Concurrent::Actor::Utils::Pool
- #initialize Concurrent::Edge::LockFreeLinkedSet::Node
- #initialize Concurrent::Edge::LockFreeLinkedSet::Tail
- #initialize Concurrent::Agent
- #initialize Concurrent::ConcurrentUpdateError
- #initialize Concurrent::Channel::Selector
- #initialize Concurrent::Semaphore
- #initialize Concurrent::Synchronization::MriMutexLockableObject
- #initialize Concurrent::Synchronization::MriMonitorLockableObject
- #initialize Concurrent::Promises::Channel
- #initialize Concurrent::Agent::ValidationError
- #initialize Concurrent::Event
- #initialize Concurrent::Channel::Buffer::Base
- #initialize Concurrent::Agent::Error
- #initialize Concurrent::Promises::DelayPromise
- #initialize Concurrent::Edge::AtomicMarkableReference
- #initialize Concurrent::JavaExecutorService::Job
- #initialize Concurrent::Promises::FutureWrapperPromise
- #initialize Concurrent::JavaExecutorService
- #initialize Concurrent::Collection::NonConcurrentMapBackend
- #initialize Concurrent::Promises::EventWrapperPromise
- #initialize Concurrent::Promises::ZipFutureEventPromise
- #initialize Concurrent::AtomicFixnum
- #initialize Concurrent::Promises::ZipEventEventPromise
- #initialize Concurrent::Promises::AbstractFlatPromise
- #initialize Concurrent::TimerSet
- #initialize Concurrent::Synchronization::Object
- #initialize Concurrent::Channel::Selector::PutClause
- #initialize Concurrent::CachedThreadPool
- #initialize Concurrent::FixedThreadPool
- #initialize Concurrent::ThreadSafe::Util::Striped64
- #initialize Concurrent::ReentrantReadWriteLock
- #initialize Concurrent::Transaction
- #initialize Concurrent::JavaSingleThreadExecutor
- #initialize Concurrent::Actor::Behaviour::Pausing
- #initialize Concurrent::MutexAtomicFixnum
- #initialize Concurrent::MultipleAssignmentError
- #initialize Concurrent::JavaExchanger
- #initialize Concurrent::Collection::CopyOnWriteObserverSet
- #initialize Concurrent::Channel
- #initialize Concurrent::Synchronization::RbxObject
- #initialize Concurrent::Channel::ValidationError
- #initialize Concurrent::Synchronization::Condition
- #initialize Concurrent::AbstractThreadLocalVar
- #initialize Concurrent::Synchronization::AbstractObject
- #initialize Concurrent::Synchronization::MriObject
- #initialize Concurrent::MVar
- #initialize Concurrent::RubyExchanger
- #initialize Concurrent::ThreadLocalVar
- #initialize Concurrent::SerializedExecutionDelegator
- #initialize Concurrent::AtomicReference
- #initialize Concurrent::RubyExchanger::Node
- #initialize Concurrent::Utility::ProcessorCounter
- #initialize Concurrent::Collection::CopyOnNotifyObserverSet
- #initialize Concurrent::Actor::Behaviour::Linking
- #initialize Concurrent::MultipleErrors
- #initialize Concurrent::SingleThreadExecutor
- #initialize Concurrent::Edge::LockFreeLinkedSet
- #initialize Concurrent::Channel::Selector::DefaultClause
- #initialize Concurrent::CountDownLatch
- #initialize Concurrent::DependencyCounter
- #initialize Concurrent::LazyRegister
- #initialize Concurrent::Actor::Behaviour::Abstract
- #initialize Concurrent::TVar
- #initialize Concurrent::AbstractExchanger
- #initialize Concurrent::AtExitImplementation
- #initialize Concurrent::Promises::ResolvableEventPromise
- #initialize Concurrent::AtomicBoolean
- #initialize Concurrent::Synchronization::TruffleObject
- #initialize Concurrent::Collection::MriMapBackend
- #initialize Concurrent::RubyThreadPoolExecutor::Worker
- #initialize Concurrent::Collection::AtomicReferenceMapBackend
- #initialize Concurrent::SerializedExecution
- #initialize Top Level Namespace
- #initialize Concurrent::Delay
- #initialize Concurrent::Channel::Selector::ErrorClause
- #initialize Concurrent::Actor::Utils::Broadcast
- #initialize Concurrent::Actor::Behaviour::SetResults
- #initialize Concurrent::Async::AwaitDelegator
- #initialize Concurrent::CyclicBarrier
- #initialize Concurrent::JavaCountDownLatch
- #initialize Concurrent::Actor::Root
- #initialize Concurrent::Channel::Selector::TakeClause
- #initialize Concurrent::CAtomicReference
- #initialize Concurrent::Synchronization::JRubyObject
- #initialize Concurrent::Actor::Behaviour::Supervising
- #initialize Concurrent::Async::AsyncDelegator
- #initialize Concurrent::RubyThreadPoolExecutor
- #initialize Concurrent::MutexSemaphore
- #initialize Concurrent::Actor::Behaviour::Termination
- #initialize Concurrent::Actor::Envelope
- #initialize Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #initialize Concurrent::Atom
- #initialize Concurrent::Actor::Behaviour::Buffer
- #initialize Concurrent::MutexAtomicBoolean
- #initialize Concurrent::SafeTaskExecutor
- #initialize Concurrent::ReadWriteLock
- #initialize Concurrent::TimerTask
- #initialize Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #initialize Concurrent::Exchanger
- #initialize Concurrent::SynchronizedDelegator
- #initialize Concurrent::RubySingleThreadExecutor
- #initialize Concurrent::IVar
- #initialize Concurrent::JavaAtomicReference
- #initialize Concurrent::IndirectImmediateExecutor
- #initialize Concurrent::Synchronization::LockableObject
- #initialize Concurrent::ImmediateExecutor
- #initialize Concurrent::Promise
- #initialize Concurrent::Edge::LockFreeLinkedSet::Window
- #initialize Concurrent::ScheduledTask
- #inspect Concurrent::Promises::ScheduledPromise
- #inspect Concurrent::Map
- #inspect Concurrent::SettableStruct
- #inspect Concurrent::ProcessingActor
- #inspect Concurrent::ImmutableStruct
- #inspect Concurrent::MutableStruct
- #inspect Concurrent::MultipleAssignmentError
- #inspection_data Concurrent::MultipleAssignmentError
- #install Concurrent::AtExitImplementation
- #intended_time Concurrent::Promises::ScheduledPromise
- #item Concurrent::LockFreeQueue::Node
- #item Concurrent::RubyExchanger::Node
- #java_extensions_loaded? Concurrent::Utility::NativeExtensionLoader
- #join Concurrent::Cancellation::Token
- just Concurrent::Maybe
- #just Concurrent::Maybe
- #just? Concurrent::Maybe
- #key Concurrent::Map
- #key Concurrent::Edge::LockFreeLinkedSet::Node
- #key Concurrent::Collection::AtomicReferenceMapBackend::Node
- #key? Concurrent::Collection::AtomicReferenceMapBackend::Node
- #key? Concurrent::Collection::NonConcurrentMapBackend
- #key? Concurrent::Collection::AtomicReferenceMapBackend
- #key? Concurrent::Collection::SynchronizedMapBackend
- #key_for Concurrent::Edge::LockFreeLinkedSet::Node
- #keys Concurrent::Map
- #kill Concurrent::SingleThreadExecutor
- #kill Concurrent::TimerSet
- #kill Concurrent::RubyExecutorService
- #kill Concurrent::AbstractExecutorService
- #kill Concurrent::JavaSingleThreadExecutor
- #kill Concurrent::RubyThreadPoolExecutor::Worker
- #kill Concurrent::ThreadPoolExecutor
- #kill Concurrent::SimpleExecutorService
- #kill Concurrent::RubySingleThreadExecutor
- #kill Concurrent::JavaExecutorService
- #largest_length Concurrent::RubyThreadPoolExecutor
- #largest_length Concurrent::ThreadPoolExecutor
- #largest_length Concurrent::JavaThreadPoolExecutor
- #last? Concurrent::Edge::LockFreeLinkedSet::Node
- #latch Concurrent::RubyExchanger::Node
- leave_transaction Concurrent
- #length Concurrent::Collection::NonConcurrentPriorityQueue
- #length Concurrent::ThreadPoolExecutor
- #length Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #length Concurrent::JavaThreadPoolExecutor
- #length Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #length Concurrent::RubyThreadPoolExecutor
- #length Concurrent::Synchronization::AbstractStruct
- #limit Concurrent::Throttle
- #link Concurrent::Actor::Behaviour::Linking
- linking Concurrent::Actor::Behaviour
- #load_native_extensions Concurrent::Utility::NativeExtensionLoader
- #locked? Concurrent::Collection::AtomicReferenceMapBackend::Node
- locked_hash? Concurrent::Collection::AtomicReferenceMapBackend::Node
- #log Concurrent::Actor::Core
- #log Concurrent::Actor::InternalDelegations
- #log Concurrent::Concern::Logging
- #loop_until_canceled Concurrent::Cancellation::Token
- #mailbox Concurrent::ProcessingActor
- #make_false Concurrent::MutexAtomicBoolean
- #make_false Concurrent::AtomicBoolean
- make_synchronized_on_rbx Concurrent::ThreadSafe::Util
- #make_true Concurrent::MutexAtomicBoolean
- #make_true Concurrent::AtomicBoolean
- #map Concurrent::Actor::Reference
- #mark Concurrent::Edge::AtomicMarkableReference
- #marshal_dump Concurrent::Map
- #marshal_load Concurrent::Map
- #matches? Concurrent::Collection::AtomicReferenceMapBackend::Node
- #max_length Concurrent::ThreadPoolExecutor
- #max_length Concurrent::RubyThreadPoolExecutor
- #max_length Concurrent::JavaThreadPoolExecutor
- #max_queue Concurrent::ThreadPoolExecutor
- #max_queue Concurrent::RubyThreadPoolExecutor
- #max_queue Concurrent::JavaThreadPoolExecutor
- #members Concurrent::Synchronization::AbstractStruct
- #merge Concurrent::ImmutableStruct
- #merge Concurrent::SettableStruct
- #merge Concurrent::MutableStruct
- #merge_pair Concurrent::Collection::NonConcurrentMapBackend
- #merge_pair Concurrent::Collection::SynchronizedMapBackend
- #merge_pair Concurrent::Collection::AtomicReferenceMapBackend
- #merge_pair Concurrent::Collection::MriMapBackend
- #merge_pair Concurrent::Map
- #message Concurrent::Actor::Envelope
- #message Concurrent::Actor::Reference
- #method_missing Concurrent::SynchronizedDelegator
- #method_missing Concurrent::Async::AsyncDelegator
- #method_missing Concurrent::Async::AwaitDelegator
- #min_length Concurrent::RubyThreadPoolExecutor
- #min_length Concurrent::JavaThreadPoolExecutor
- #min_length Concurrent::ThreadPoolExecutor
- #modify Concurrent::MVar
- #modify! Concurrent::MVar
- #monotonic Concurrent::Channel::Tick
- monotonic_time Concurrent
- #name Concurrent::Actor::Core
- #name Concurrent::Actor::PublicDelegations
- new Concurrent::Synchronization::Object
- #new Concurrent::Synchronization::TruffleLockableObject
- new Concurrent::Async
- new Concurrent::MutableStruct
- new Concurrent::SettableStruct
- #new Concurrent::Async::ClassMethods
- new Concurrent::ImmutableStruct
- new Concurrent::Edge::AtomicMarkableReference::ImmutableArray
- new_blocked_by Concurrent::Promises::BlockedPromise
- new_blocked_by1 Concurrent::Promises::BlockedPromise
- new_blocked_by2 Concurrent::Promises::BlockedPromise
- #new_condition Concurrent::Synchronization::LockableObject
- new_fast_executor Concurrent
- new_io_executor Concurrent
- #next Concurrent::Channel::Buffer::Unbuffered
- #next Concurrent::Channel::Buffer::Base
- #next Concurrent::Channel
- #next Concurrent::Channel::Buffer::Timer
- #next Concurrent::Channel::Buffer::Buffered
- #next? Concurrent::Channel
- #next_in_size_table Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #next_node Concurrent::LockFreeStack::Node
- #next_node Concurrent::Edge::LockFreeLinkedSet::Node
- #next_node Concurrent::LockFreeStack::Empty
- #nothing Concurrent::Maybe
- nothing Concurrent::Maybe
- #nothing? Concurrent::Maybe
- #notify_and_delete_observers Concurrent::Collection::CopyOnNotifyObserverSet
- #notify_and_delete_observers Concurrent::Collection::CopyOnWriteObserverSet
- #notify_observers Concurrent::Collection::CopyOnWriteObserverSet
- #notify_observers Concurrent::Collection::CopyOnNotifyObserverSet
- #ns_broadcast Concurrent::Synchronization::Condition
- #ns_broadcast Concurrent::Synchronization::Lock
- #ns_signal Concurrent::Synchronization::Condition
- #ns_signal Concurrent::Synchronization::Lock
- #ns_wait Concurrent::Synchronization::Lock
- #ns_wait Concurrent::Synchronization::Condition
- #ns_wait_until Concurrent::Synchronization::Lock
- #ns_wait_until Concurrent::Synchronization::Condition
- #number_waiting Concurrent::CyclicBarrier
- of1 Concurrent::LockFreeStack
- of2 Concurrent::LockFreeStack
- #offer Concurrent::Channel::Buffer::Unbuffered
- #offer Concurrent::Channel::Buffer::Timer
- #offer Concurrent::Channel::Buffer::Buffered
- #offer Concurrent::Channel::Buffer::Base
- #offer Concurrent::Channel::Buffer::Sliding
- #offer Concurrent::Channel
- #offer Concurrent::Channel::Buffer::Dropping
- #offer! Concurrent::Channel
- #offer? Concurrent::Channel
- #on_blocker_resolution Concurrent::Promises::BlockedPromise
- #on_cruby? Concurrent::Utility::EngineDetector
- #on_envelope Concurrent::Actor::Behaviour::ErrorsOnUnknownMessage
- #on_envelope Concurrent::Actor::Core
- #on_envelope Concurrent::Actor::Behaviour::Buffer
- #on_envelope Concurrent::Actor::Behaviour::Supervising
- #on_envelope Concurrent::Actor::Behaviour::ExecutesContext
- #on_envelope Concurrent::Actor::Behaviour::Abstract
- #on_envelope Concurrent::Actor::Behaviour::Termination
- #on_envelope Concurrent::Actor::Behaviour::Awaits
- #on_envelope Concurrent::Actor::Behaviour::Pausing
- #on_envelope Concurrent::Actor::AbstractContext
- #on_envelope Concurrent::Actor::Behaviour::RemovesChild
- #on_envelope Concurrent::Actor::Behaviour::Linking
- #on_envelope Concurrent::Actor::Behaviour::SetResults
- #on_event Concurrent::Actor::Behaviour::Abstract
- #on_event Concurrent::Actor::AbstractContext
- #on_event Concurrent::Actor::Behaviour::Pausing
- #on_event Concurrent::Actor::Behaviour::Linking
- #on_event Concurrent::Actor::Behaviour::ExecutesContext
- #on_event Concurrent::Actor::Behaviour::Buffer
- #on_fulfillment Concurrent::Promises::Future
- #on_fulfillment! Concurrent::Promises::Future
- #on_fulfillment_using Concurrent::Promises::Future
- #on_jruby? Concurrent::Utility::EngineDetector
- #on_jruby_9000? Concurrent::Utility::EngineDetector
- #on_linux? Concurrent::Utility::EngineDetector
- #on_message Concurrent::Actor::Utils::AsAdHoc
- #on_message Concurrent::Actor::Root
- #on_message Concurrent::Actor::Utils::Broadcast
- #on_message Concurrent::Actor::DefaultDeadLetterHandler
- #on_message Concurrent::Actor::AbstractContext
- #on_message Concurrent::Actor::Utils::Balancer
- #on_message Concurrent::Actor::Utils::Pool
- #on_osx? Concurrent::Utility::EngineDetector
- #on_rbx? Concurrent::Utility::EngineDetector
- #on_rejection Concurrent::Promises::Future
- #on_rejection! Concurrent::Promises::Future
- #on_rejection_using Concurrent::Promises::Future
- #on_resolution Concurrent::Promises::AbstractEventFuture
- #on_resolution! Concurrent::Promises::AbstractEventFuture
- #on_resolution_using Concurrent::Promises::AbstractEventFuture
- #on_success Concurrent::Promise
- #on_truffle? Concurrent::Utility::EngineDetector
- #on_windows? Concurrent::Utility::EngineDetector
- #or Concurrent::Maybe
- #parent Concurrent::Actor::PublicDelegations
- #parent Concurrent::Actor::Core
- #parties Concurrent::CyclicBarrier
- #pass Concurrent::Actor::Behaviour::Abstract
- #pass Concurrent::Actor::AbstractContext
- #path Concurrent::Actor::PublicDelegations
- #path Concurrent::Actor::Core
- #pause! Concurrent::Actor::Behaviour::Pausing
- #paused? Concurrent::Actor::Behaviour::Pausing
- #peek Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #peek Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #peek Concurrent::Collection::NonConcurrentPriorityQueue
- #peek Concurrent::LockFreeStack
- #pending? Concurrent::Promises::AbstractEventFuture
- #pending? Concurrent::Concern::Obligation
- #perform Concurrent::Async::AsyncDelegator
- physical_processor_count Concurrent
- #physical_processor_count Concurrent::Utility::ProcessorCounter
- #poll Concurrent::Channel::Buffer::Unbuffered
- #poll Concurrent::Channel::Buffer::Timer
- #poll Concurrent::Channel::Buffer::Base
- #poll Concurrent::Channel
- #poll Concurrent::Channel::Buffer::Buffered
- #poll! Concurrent::Channel
- #poll? Concurrent::Channel
- #pop Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #pop Concurrent::LockFreeStack
- #pop Concurrent::Promises::Channel
- #pop Concurrent::Collection::NonConcurrentPriorityQueue
- #pop Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #pop Concurrent::LockFreeQueue
- #post Concurrent::IndirectImmediateExecutor
- #post Concurrent::RubyExecutorService
- #post Concurrent::RubySingleThreadExecutor
- #post Concurrent::AbstractExecutorService
- #post Concurrent::JavaExecutorService
- #post Concurrent::ImmediateExecutor
- #post Concurrent::JavaSingleThreadExecutor
- #post Concurrent::TimerSet
- #post Concurrent::SimpleExecutorService
- #post Concurrent::ThreadPoolExecutor
- post Concurrent::SimpleExecutorService
- #post Concurrent::SerializedExecution
- #post Concurrent::ExecutorService
- #post Concurrent::SerializedExecutionDelegator
- #post Concurrent::SingleThreadExecutor
- #posts Concurrent::SerializedExecution
- #pred Concurrent::Edge::LockFreeLinkedSet::Window
- #process_envelope Concurrent::Actor::Behaviour::Buffer
- #process_envelope Concurrent::Actor::Core
- #process_envelopes? Concurrent::Actor::Behaviour::Buffer
- #processing? Concurrent::ScheduledTask
- #processor_count Concurrent::Utility::ProcessorCounter
- processor_count Concurrent
- #pure_hash Concurrent::Collection::AtomicReferenceMapBackend::Node
- #push Concurrent::Collection::RubyNonConcurrentPriorityQueue
- #push Concurrent::LockFreeQueue
- #push Concurrent::Promises::Channel
- #push Concurrent::LockFreeStack
- #push Concurrent::Collection::JavaNonConcurrentPriorityQueue
- #push Concurrent::Collection::NonConcurrentPriorityQueue
- #put Concurrent::Channel
- #put Concurrent::Channel::Buffer::Unbuffered
- #put Concurrent::MVar
- #put Concurrent::Channel::Buffer::Buffered
- #put Concurrent::Channel::Buffer::Dropping
- #put Concurrent::Channel::Buffer::Sliding
- #put Concurrent::Channel::Buffer::Timer
- #put Concurrent::Channel::Buffer::Base
- #put Concurrent::Channel::Selector
- #put! Concurrent::Channel
- #put? Concurrent::Channel
- #put_if_absent Concurrent::Map
- #queue_length Concurrent::JavaThreadPoolExecutor
- #queue_length Concurrent::RubyThreadPoolExecutor
- #queue_length Concurrent::ThreadPoolExecutor
- #raise_if_canceled Concurrent::Cancellation::Token
- #read Concurrent::Transaction
- #reason Concurrent::Promises::Future
- #reason Concurrent::Concern::Obligation
- #receive Concurrent::ProcessingActor
- #reconfigure Concurrent::Delay
- #redirect Concurrent::Actor::InternalDelegations
- #reference Concurrent::Actor::PublicDelegations
- #reference Concurrent::Actor::Core
- #reference Concurrent::Actor::ActorTerminated
- #register Concurrent::LazyRegister
- #registered? Concurrent::LazyRegister
- #reject Concurrent::Promises::ResolvableFuture
- #reject Concurrent::Promises::ResolvableFuturePromise
- reject Concurrent::Promise
- #reject! Concurrent::Actor::Envelope
- #reject_envelope Concurrent::Actor::Behaviour::Abstract
- #rejected? Concurrent::Concern::Obligation
- #rejected? Concurrent::Promises::Future
- #rejected_future Concurrent::Promises::FactoryMethods
- #release Concurrent::Throttle
- #release Concurrent::MutexSemaphore
- #release Concurrent::Semaphore
- #release_read_lock Concurrent::ReentrantReadWriteLock
- #release_read_lock Concurrent::ReadWriteLock
- #release_write_lock Concurrent::ReadWriteLock
- #release_write_lock Concurrent::ReentrantReadWriteLock
- #remaining_capacity Concurrent::JavaThreadPoolExecutor
- #remaining_capacity Concurrent::RubyThreadPoolExecutor
- #remaining_capacity Concurrent::ThreadPoolExecutor
- #remove Concurrent::Edge::LockFreeLinkedSet
- #remove_child Concurrent::Actor::Core
- #replace_if Concurrent::LockFreeStack
- #replace_if_exists Concurrent::Collection::NonConcurrentMapBackend
- #replace_if_exists Concurrent::Collection::AtomicReferenceMapBackend
- #replace_if_exists Concurrent::Collection::MriMapBackend
- #replace_if_exists Concurrent::Map
- #replace_if_exists Concurrent::Collection::SynchronizedMapBackend
- #replace_pair Concurrent::Collection::MriMapBackend
- #replace_pair Concurrent::Map
- #replace_pair Concurrent::Collection::NonConcurrentMapBackend
- #replace_pair Concurrent::Collection::AtomicReferenceMapBackend
- #replace_pair Concurrent::Collection::SynchronizedMapBackend
- #reschedule Concurrent::ScheduledTask
- #rescue Concurrent::Promise
- #rescue Concurrent::Promises::Future
- #rescue_on Concurrent::Promises::Future
- #rescue_throttled_by Concurrent::Promises::Future::ThrottleIntegration
- #reset Concurrent::Event
- #reset Concurrent::CyclicBarrier
- #reset Concurrent::ScheduledTask
- #reset Concurrent::ThreadSafe::Util::Adder
- #reset Concurrent::Atom
- #reset! Concurrent::Actor::Behaviour::Pausing
- #resolvable_event Concurrent::Promises::FactoryMethods
- #resolvable_event_on Concurrent::Promises::FactoryMethods
- #resolvable_future Concurrent::Promises::FactoryMethods
- #resolvable_future_on Concurrent::Promises::FactoryMethods
- #resolve Concurrent::Promises::ResolvableEvent
- #resolve Concurrent::Promises::ResolvableFuture
- #resolved? Concurrent::Promises::AbstractEventFuture
- #resolved_event Concurrent::Promises::FactoryMethods
- #resolved_future Concurrent::Promises::FactoryMethods
- #restart Concurrent::Agent
- #restart! Concurrent::Actor::Behaviour::Pausing
- restarting_behaviour_definition Concurrent::Actor::Behaviour
- #result Concurrent::Promises::Future
- #resume! Concurrent::Actor::Behaviour::Pausing
- #retry_update Concurrent::ThreadSafe::Util::Striped64
- root Concurrent::Actor
- #ruby_engine Concurrent::Utility::EngineDetector
- #ruby_version Concurrent::Utility::EngineDetector
- #run Concurrent::JavaExecutorService::Job
- #run Concurrent::Promises::Future
- #run Concurrent::AtExitImplementation
- #running? Concurrent::JavaExecutorService
- #running? Concurrent::SingleThreadExecutor
- #running? Concurrent::RubyExecutorService
- #running? Concurrent::RubySingleThreadExecutor
- #running? Concurrent::AbstractExecutorService
- #running? Concurrent::ThreadPoolExecutor
- #running? Concurrent::JavaThreadPoolExecutor
- #running? Concurrent::JavaSingleThreadExecutor
- #running? Concurrent::SimpleExecutorService
- #running? Concurrent::ImmediateExecutor
- #running? Concurrent::TimerTask
- safe_initialization! Concurrent::Synchronization::Object
- safe_initialization? Concurrent::Synchronization::Object
- #schedule Concurrent::Promises::Event
- #schedule Concurrent::Promises::FactoryMethods
- #schedule Concurrent::Promises::Future
- #schedule_execution Concurrent::Actor::Core
- #schedule_on Concurrent::Promises::FactoryMethods
- #schedule_time Concurrent::ScheduledTask
- #scheduled_task_count Concurrent::ThreadPoolExecutor
- #scheduled_task_count Concurrent::JavaThreadPoolExecutor
- #scheduled_task_count Concurrent::RubyThreadPoolExecutor
- #select Concurrent::ImmutableStruct
- #select Concurrent::SettableStruct
- #select Concurrent::MutableStruct
- select Concurrent::Channel
- #select_channel Concurrent::Promises::FactoryMethods::NewChannelIntegration
- #send Concurrent::Agent
- #send! Concurrent::Agent
- #send_off Concurrent::Agent
- #send_off! Concurrent::Agent
- #send_via Concurrent::Agent
- #send_via! Concurrent::Agent
- #sender Concurrent::Actor::Envelope
- #sender_path Concurrent::Actor::Envelope
- #serialized? Concurrent::SerialExecutorService
- #serialized? Concurrent::ThreadPoolExecutor
- #serialized? Concurrent::ExecutorService
- #serialized? Concurrent::JavaExecutorService
- #serialized? Concurrent::RubyExecutorService
- #serialized? Concurrent::AbstractExecutorService
- #serialized? Concurrent::RubySingleThreadExecutor
- #serialized? Concurrent::SingleThreadExecutor
- #serialized? Concurrent::JavaSingleThreadExecutor
- #set Concurrent::MutexAtomicReference
- #set Top Level Namespace
- #set Concurrent::Promise
- #set Concurrent::RbxAtomicReference
- #set Concurrent::Future
- #set Concurrent::CAtomicReference
- #set Concurrent::JavaAtomicReference
- #set Concurrent::IVar
- #set Concurrent::Edge::AtomicMarkableReference
- #set Concurrent::ConcurrentUpdateError
- #set Concurrent::Event
- #set Concurrent::AtomicReference
- #set Concurrent::Tuple
- #set! Concurrent::MVar
- #set? Concurrent::Event
- #set_c_extensions_loaded Concurrent::Utility::NativeExtensionLoader
- #set_java_extensions_loaded Concurrent::Utility::NativeExtensionLoader
- #setup Concurrent::SynchronizedDelegator
- #shutdown Concurrent::RubySingleThreadExecutor
- #shutdown Concurrent::ImmediateExecutor
- #shutdown Concurrent::JavaSingleThreadExecutor
- #shutdown Concurrent::JavaExecutorService
- #shutdown Concurrent::AbstractExecutorService
- #shutdown Concurrent::SimpleExecutorService
- #shutdown Concurrent::RubyExecutorService
- #shutdown Concurrent::ThreadPoolExecutor
- #shutdown Concurrent::SingleThreadExecutor
- #shutdown? Concurrent::AbstractExecutorService
- #shutdown? Concurrent::RubyExecutorService
- #shutdown? Concurrent::SimpleExecutorService
- #shutdown? Concurrent::RubySingleThreadExecutor
- #shutdown? Concurrent::ImmediateExecutor
- #shutdown? Concurrent::JavaExecutorService
- #shutdown? Concurrent::SingleThreadExecutor
- #shutdown? Concurrent::JavaSingleThreadExecutor
- #shutdown? Concurrent::ThreadPoolExecutor
- #shuttingdown? Concurrent::JavaSingleThreadExecutor
- #shuttingdown? Concurrent::ThreadPoolExecutor
- #shuttingdown? Concurrent::SimpleExecutorService
- #shuttingdown? Concurrent::RubyExecutorService
- #shuttingdown? Concurrent::JavaExecutorService
- #shuttingdown? Concurrent::ImmediateExecutor
- #shuttingdown? Concurrent::AbstractExecutorService
- #shuttingdown? Concurrent::RubySingleThreadExecutor
- #shuttingdown? Concurrent::SingleThreadExecutor
- #signal Concurrent::Synchronization::Condition
- #signal Concurrent::Synchronization::Lock
- #signal Concurrent::Synchronization::LockableObject
- #size Concurrent::Collection::SynchronizedMapBackend
- #size Concurrent::Channel::Buffer::Unbuffered
- #size Concurrent::Map
- #size Concurrent::Tuple
- #size Concurrent::Collection::NonConcurrentMapBackend
- #size Concurrent::Collection::AtomicReferenceMapBackend
- #size Concurrent::LockFreeQueue
- #size Concurrent::Channel::Buffer::Base
- spawn Concurrent::Actor::AbstractContext
- spawn Concurrent::Actor
- spawn! Concurrent::Actor
- spawn! Concurrent::Actor::AbstractContext
- #state Concurrent::Concern::Obligation
- #state Concurrent::Promises::AbstractEventFuture
- #stop Concurrent::RubyThreadPoolExecutor::Worker
- #subsequent Concurrent::Actor::Behaviour::Abstract
- #successor_reference Concurrent::Edge::LockFreeLinkedSet::Node
- #sum Concurrent::ThreadSafe::Util::Adder
- supervised Concurrent::Actor::Behaviour
- supervising Concurrent::Actor::Behaviour
- #swap Concurrent::Atom
- #synchronize Concurrent::Synchronization::Lock
- #synchronize Concurrent::Synchronization::LockableObject
- #take Concurrent::MVar
- #take Concurrent::Channel::Buffer::Base
- #take Concurrent::Channel::Buffer::Buffered
- #take Concurrent::Channel::Buffer::Timer
- #take Concurrent::Channel::Selector
- #take Concurrent::Channel
- #take Concurrent::Channel::Buffer::Unbuffered
- #take! Concurrent::Channel
- #take? Concurrent::Channel
- #teardown Concurrent::SynchronizedDelegator
- #tell Concurrent::Actor::AbstractContext
- #tell Concurrent::Actor::Reference
- #tell Concurrent::ProcessingActor
- #tell! Concurrent::ProcessingActor
- #terminate! Concurrent::Actor::Behaviour::Termination
- #terminate! Concurrent::Actor::InternalDelegations
- #terminated Concurrent::Actor::Behaviour::Termination
- #terminated? Concurrent::Actor::Behaviour::Termination
- #terminated? Concurrent::Actor::InternalDelegations
- #termination Concurrent::ProcessingActor
- #then Concurrent::Promise
- #then Concurrent::Promises::Future
- #then_ask Concurrent::Promises::Future::ActorIntegration
- #then_on Concurrent::Promises::Future
- #then_push_channel Concurrent::Promises::Future::NewChannelIntegration
- #then_throttled_by Concurrent::Promises::Future::ThrottleIntegration
- #throttled_block Concurrent::Throttle
- #throttled_by Concurrent::Promises::AbstractEventFuture::ThrottleIntegration
- #throttled_future Concurrent::Throttle::PromisesIntegration
- #throttled_future_chain Concurrent::Throttle::PromisesIntegration
- ticker Concurrent::Channel
- #timeout_interval Concurrent::TimerTask
- timer Concurrent::Channel
- #to_event Concurrent::Promises::Future
- #to_event Concurrent::Promises::Event
- #to_event Concurrent::Cancellation::Token
- #to_future Concurrent::Cancellation::Token
- #to_future Concurrent::Promises::Event
- #to_future Concurrent::Promises::Future
- #to_h Concurrent::ImmutableStruct
- #to_h Concurrent::MutableStruct
- #to_h Concurrent::SettableStruct
- #to_s Concurrent::Cancellation::Token
- #to_s Concurrent::Cancellation
- #to_s Concurrent::Throttle
- #to_s Concurrent::AtomicBoolean
- #to_s Concurrent::LockFreeStack
- #to_s Concurrent::Channel::Tick
- #to_s Concurrent::Promises::Channel
- #to_s Concurrent::AtomicFixnum
- #to_s Concurrent::Promises::AbstractEventFuture
- #to_s Concurrent::AtomicReference
- #to_s Concurrent::Actor::Reference
- to_spawn_options Concurrent::Actor
- to_sym Fulfilled.new(nil)
- #token Concurrent::Cancellation
- #touch Concurrent::Promises::AbstractEventFuture
- #touch Concurrent::Promises::AbstractFlatPromise
- #touch Concurrent::Promises::DelayPromise
- #touch Concurrent::Promises::BlockedPromise
- #trapping= Concurrent::Actor::Behaviour::Termination
- #trapping? Concurrent::Actor::Behaviour::Termination
- #trigger Concurrent::Throttle
- #true? Concurrent::MutexAtomicBoolean
- #true? Concurrent::AtomicBoolean
- #try? Concurrent::Event
- #try_acquire Concurrent::Semaphore
- #try_acquire Concurrent::MutexSemaphore
- #try_await_lock Concurrent::Collection::AtomicReferenceMapBackend::Node
- #try_exchange Concurrent::Exchanger
- #try_exchange Concurrent::AbstractExchanger
- #try_lock_via_hash Concurrent::Collection::AtomicReferenceMapBackend::Table
- #try_lock_via_hash Concurrent::Collection::AtomicReferenceMapBackend::Node
- #try_put! Concurrent::MVar
- #try_read_lock Concurrent::ReentrantReadWriteLock
- #try_set Concurrent::IVar
- #try_take! Concurrent::MVar
- #try_to_cas_in_computed Concurrent::Collection::AtomicReferenceMapBackend::Table
- #try_update Concurrent::Edge::AtomicMarkableReference
- #try_update Concurrent::AtomicDirectUpdate
- #try_update! Concurrent::AtomicDirectUpdate
- #try_update! Concurrent::Edge::AtomicMarkableReference
- #try_write_lock Concurrent::ReentrantReadWriteLock
- #tvar Concurrent::Transaction::ReadLogEntry
- #unlink Concurrent::Actor::Behaviour::Linking
- #unlock Concurrent::Transaction
- #unlock_via_hash Concurrent::Collection::AtomicReferenceMapBackend::Node
- #unregister Concurrent::LazyRegister
- #unscheduled? Concurrent::Concern::Obligation
- #update Concurrent::DependencyCounter
- #update Concurrent::AtomicFixnum
- #update Concurrent::MutexAtomicFixnum
- #update Concurrent::Edge::AtomicMarkableReference
- #update Concurrent::AtomicDirectUpdate
- use_simple_logger Concurrent
- use_stdlib_logger Concurrent
- user_messages Concurrent::Actor::Behaviour
- #utc Concurrent::Channel::Tick
- #valid? Concurrent::Transaction
- #value Concurrent::MutexAtomicFixnum
- #value Concurrent::JavaThreadLocalVar
- #value Concurrent::MutexAtomicBoolean
- #value Concurrent::Delay
- #value Concurrent::TVar
- #value Concurrent::ThreadLocalVar
- #value Concurrent::Concern::Dereferenceable
- #value Concurrent::Edge::AtomicMarkableReference
- #value Concurrent::Promises::Future
- #value Concurrent::Agent
- #value Concurrent::Atom
- #value Concurrent::AtomicBoolean
- #value Concurrent::LockFreeStack::Node
- #value Concurrent::AbstractThreadLocalVar
- #value Concurrent::AtomicFixnum
- #value Concurrent::Concern::Obligation
- #value Concurrent::RubyThreadLocalVar
- #value! Concurrent::Concern::Obligation
- #value! Concurrent::Promises::Future
- #value! Concurrent::Delay
- #value= Concurrent::TVar
- #value= Concurrent::MutexAtomicFixnum
- #value= Concurrent::AtomicBoolean
- #value= Concurrent::AtomicFixnum
- #value= Concurrent::ThreadLocalVar
- #value= Concurrent::JavaThreadLocalVar
- #value= Concurrent::RubyThreadLocalVar
- #value= Concurrent::MutexAtomicBoolean
- #value= Concurrent::AbstractThreadLocalVar
- #value? Concurrent::Map
- #values Concurrent::Map
- #values Concurrent::MutableStruct
- #values Concurrent::ImmutableStruct
- #values Concurrent::SettableStruct
- #values_at Concurrent::ImmutableStruct
- #values_at Concurrent::MutableStruct
- #values_at Concurrent::SettableStruct
- #version Concurrent::Transaction::ReadLogEntry
- volatile_cas_fields Concurrent::Synchronization::Object
- #volatile_get_by_hash Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #volatile_set_by_hash Concurrent::ThreadSafe::Util::PowerOfTwoTuple
- #wait Concurrent::JavaCountDownLatch
- #wait Concurrent::Event
- #wait Concurrent::Promises::AbstractEventFuture
- #wait Concurrent::CountDownLatch
- #wait Concurrent::Agent
- #wait Concurrent::CyclicBarrier
- #wait Concurrent::Synchronization::LockableObject
- #wait Concurrent::MutexCountDownLatch
- #wait Concurrent::Synchronization::Lock
- #wait Concurrent::Delay
- #wait Concurrent::Synchronization::Condition
- #wait Concurrent::Concern::Obligation
- #wait! Concurrent::Promises::Future
- #wait! Concurrent::Concern::Obligation
- #wait_for_termination Concurrent::ImmediateExecutor
- #wait_for_termination Concurrent::RubySingleThreadExecutor
- #wait_for_termination Concurrent::JavaExecutorService
- #wait_for_termination Concurrent::SimpleExecutorService
- #wait_for_termination Concurrent::JavaSingleThreadExecutor
- #wait_for_termination Concurrent::AbstractExecutorService
- #wait_for_termination Concurrent::ThreadPoolExecutor
- #wait_for_termination Concurrent::RubyExecutorService
- #wait_for_termination Concurrent::SingleThreadExecutor
- #wait_or_cancel Concurrent::Future
- #wait_until Concurrent::Synchronization::Condition
- #wait_until Concurrent::Synchronization::Lock
- #wait_until Concurrent::Synchronization::LockableObject
- #with_default_executor Concurrent::Promises::Future
- #with_default_executor Concurrent::Promises::Event
- #with_default_executor Concurrent::Promises::AbstractEventFuture
- #with_hidden_resolvable Concurrent::Promises::ResolvableFuture
- #with_hidden_resolvable Concurrent::Promises::ResolvableEvent
- #with_observer Concurrent::Concern::Observable
- #with_read_lock Concurrent::ReadWriteLock
- #with_read_lock Concurrent::ReentrantReadWriteLock
- #with_write_lock Concurrent::ReadWriteLock
- #with_write_lock Concurrent::ReentrantReadWriteLock
- #write Concurrent::Transaction
- #write_locked? Concurrent::ReadWriteLock
- #xorshift Concurrent::ThreadSafe::Util::XorShiftRandom
- #zip Concurrent::Promise
- #zip Concurrent::Promises::Future
- zip Concurrent::Promise
- #zip Concurrent::Promises::Event
- #zip_events Concurrent::Promises::FactoryMethods
- #zip_events_on Concurrent::Promises::FactoryMethods
- #zip_futures Concurrent::Promises::FactoryMethods
- #zip_futures_on Concurrent::Promises::FactoryMethods


What to do with the current tab after changing cognition mode * ?
The incognito tab should open:
Allow cookies in incognito session if blocked for current tab webpage domain?


--- layout: page title: 404 show_title: false ---
Oh, you caught me.
Let's try again, it's your turn to HIDE, READY?


|
libguac 1.5.3
|
Represents a single stream within the Guacamole protocol. More...
Data Fields | |
| int | index |
| The index of this stream. | |
| void * | data |
| Arbitrary data associated with this stream. | |
| guac_user_ack_handler * | ack_handler |
| Handler for ack events sent by the Guacamole web-client. | |
| guac_user_blob_handler * | blob_handler |
| Handler for blob events sent by the Guacamole web-client. | |
| guac_user_end_handler * | end_handler |
| Handler for stream end events sent by the Guacamole web-client. | |
Represents a single stream within the Guacamole protocol.
| guac_user_ack_handler* guac_stream::ack_handler |
Handler for ack events sent by the Guacamole web-client.
The handler takes a guac_stream which contains the stream index and will persist through the duration of the transfer, a string containing the error or status message, and a status code.
Example:
| guac_user_blob_handler* guac_stream::blob_handler |
Handler for blob events sent by the Guacamole web-client.
The handler takes a guac_stream which contains the stream index and will persist through the duration of the transfer, an arbitrary buffer containing the blob, and the length of the blob.
Example:
| guac_user_end_handler* guac_stream::end_handler |
Handler for stream end events sent by the Guacamole web-client.
The handler takes only a guac_stream which contains the stream index. This guac_stream will be disposed of immediately after this event is finished.
Example:


Namibia to scale up youth-friendly family planning - Iipumbu
by Selma IkelaHome \ National \ Namibia to scale up youth-friendly family planning - Iipumbu - New Era Live
Home \ National \ Namibia to scale up youth-friendly family planning - Iipumbu - New Era Live


A reStructuredText Reference
Contents
Quick reStructuredText
Copyright: This document has been placed in the public domain.
The full details of the markup may be found on the reStructuredText page. This document is just intended as a reminder.
Links that look like "(details)" point into the HTML version of the full reStructuredText specification document. These are relative links; if they don't work, please use the master "Quick reStructuredText" document.
Inline Markup
(details)
Inline markup allows words and phrases within text to have character styles (like italics and boldface) and functionality (like hyperlinks).
| Plain text | Typical result | Notes |
|---|---|---|
| *emphasis* | emphasis | Normally rendered as italics. |
| **strong emphasis** | strong emphasis | Normally rendered as boldface. |
| `interpreted text` | (see note at right) | The rendering and meaning of interpreted text is domain- or application-dependent. It can be used for things like index entries or explicit descriptive markup (like program identifiers). |
| ``inline literal`` |
inline literal
|
Normally rendered as monospaced text. Spaces should be preserved, but line breaks will not be. |
| reference_ | reference | A simple, one-word hyperlink reference. See Hyperlink Targets. |
| `phrase reference`_ | phrase reference | A hyperlink reference with spaces or punctuation needs to be quoted with backquotes. See Hyperlink Targets. |
| anonymous__ | anonymous | With two underscores instead of one, both simple and phrase references may be anonymous (the reference text is not repeated at the target). See Hyperlink Targets. |
| _`inline internal target` | inline internal target | A crossreference target within text. See Hyperlink Targets. |
| |substitution reference| | (see note at right) | The result is substituted in from the substitution definition. It could be text, an image, a hyperlink, or a combination of these and others. |
| footnote reference [1]_ | footnote reference 1 | See Footnotes. |
| citation reference [CIT2002]_ | citation reference [CIT2002] | See Citations. |
| http://docutils.sf.net/ | http://docutils.sf.net/ | A standalone hyperlink. |
Asterisk, backquote, vertical bar, and underscore are inline delimiter characters. Asterisk, backquote, and vertical bar act like quote marks; matching characters surround the marked-up word or phrase, whitespace or other quoting is required outside them, and there can't be whitespace just inside them. If you want to use inline delimiter characters literally, escape (with backslash) or quote them (with double backquotes; i.e. use inline literals).
In detail, the reStructuredText specification says that in inline markup, the following rules apply to start-strings and end-strings (inline markup delimiters):
- The start-string must start a text block or be immediately preceded by whitespace or any of ' " ( [ { or <.
- The start-string must be immediately followed by non-whitespace.
- The end-string must be immediately preceded by non-whitespace.
- The end-string must end a text block (end of document or followed by a blank line) or be immediately followed by whitespace or any of ' " . , : ; ! ? - ) ] } / \ or >.
- If a start-string is immediately preceded by one of ' " ( [ { or <, it must not be immediately followed by the corresponding character from ' " ) ] } or >.
- An end-string must be separated by at least one character from the start-string.
- An unescaped backslash preceding a start-string or end-string will disable markup recognition, except for the end-string of inline literals.
Also remember that inline markup may not be nested (well, except that inline literals can contain any of the other inline markup delimiter characters, but that doesn't count because nothing is processed).
Escaping with Backslashes
(details)
reStructuredText uses backslashes ("\") to override the special meaning given to markup characters and get the literal characters themselves. To get a literal backslash, use an escaped backslash ("\\"). For example:
| Raw reStructuredText | Typical result |
|---|---|
| *escape* ``with`` "\" | escape with "" |
| \*escape* \``with`` "\\" | *escape* ``with`` "\" |
In Python strings it will, of course, be necessary to escape any backslash characters so that they actually reach reStructuredText. The simplest way to do this is to use raw strings:
| Python string | Typical result |
|---|---|
| r"""\*escape* \`with` "\\"""" | *escape* `with` "\" |
| """\\*escape* \\`with` "\\\\"""" | *escape* `with` "\" |
| """\*escape* \`with` "\\"""" | escape with "" |
Section Structure
(details)
| Plain text | Typical result |
|---|---|
|
=====
Title ===== Subtitle -------- Titles are underlined (or over- and underlined) with a printing nonalphanumeric 7-bit ASCII character. Recommended choices are "``= - ` : ' " ~ ^ _ * + # < >``". The underline/overline must be at least as long as the title text. A lone top-level (sub)section is lifted up to be the document's (sub)title. |
Title
Subtitle Titles are underlined (or over- and underlined) with a printing nonalphanumeric 7-bit ASCII character. Recommended choices are "= - ` : ' " ~ ^ _ * + # < >". The underline/overline must be at least as long as the title text. A lone top-level (sub)section is lifted up to be the document's (sub)title. |
Paragraphs
(details)
| Plain text | Typical result |
|---|---|
|
This is a paragraph. Paragraphs line up at their left
|
This is a paragraph. Paragraphs line up at their left edges, and are normally separated by blank lines. |
Bullet Lists
(details)
| Plain text | Typical result |
|---|---|
|
Bullet lists:
- This is item 1
- Bullets are "-", "*" or "+".
Note that a blank line is required
|
Bullet lists:
Note that a blank line is required before the first item and after the last, but is optional between items. |
Enumerated Lists
(details)
| Plain text | Typical result |
|---|---|
|
Enumerated lists:
3. This is the first item
|
Enumerated lists:
|
Definition Lists
(details)
| Plain text | Typical result |
|---|---|
|
Definition lists:
what Definition lists associate a term with a definition. how The term is a one-line phrase, and the definition is one or more paragraphs or body elements, indented relative to the term. Blank lines are not allowed between term and definition. |
Definition lists:
|
Field Lists
(details)
| Plain text | Typical result | ||||||||
|---|---|---|---|---|---|---|---|---|---|
|
:Authors:
Tony J. (Tibs) Ibbs, David Goodger (and sundry other good-natured folks) :Version: 1.0 of 2001/08/08
|
|
Field lists are used as part of an extension syntax, such as options for directives, or database-like records meant for further processing. Field lists may also be used as generic two-column table constructs in documents.
Option Lists
(details)
| Plain text | Typical result | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
-a command-line option "a"
|
|
There must be at least two spaces between the option and the description.
Literal Blocks
(details)
| Plain text | Typical result |
|---|---|
|
A paragraph containing only two colons
indicates that the following indented or quoted text is a literal block. :: Whitespace, newlines, blank lines, and all kinds of markup (like *this* or \this) is preserved by literal blocks. The paragraph containing only '::' will be omitted from the result. The ``::`` may be tacked onto the very end of any paragraph. The ``::`` will be omitted if it is preceded by whitespace. The ``::`` will be converted to a single colon if preceded by text, like this:: It's very convenient to use this form. Literal blocks end when text returns to the preceding paragraph's indentation. This means that something like this is possible:: We start here and continue here and end here. Per-line quoting can also be used on unindented literal blocks:: > Useful for quotes from email and > for Haskell literate programming. |
A paragraph containing only two colons indicates that the following indented or quoted text is a literal block. Whitespace, newlines, blank lines, and all kinds of markup (like *this* or \this) is preserved by literal blocks. The paragraph containing only '::' will be omitted from the result. The :: may be tacked onto the very end of any paragraph. The :: will be omitted if it is preceded by whitespace. The :: will be converted to a single colon if preceded by text, like this: It's very convenient to use this form. Literal blocks end when text returns to the preceding paragraph's indentation. This means that something like this is possible: We start here and continue here and end here. Per-line quoting can also be used on unindented literal blocks: > Useful for quotes from email and > for Haskell literate programming. |
Line Blocks
(details)
| Plain text | Typical result |
|---|---|
|
| Line blocks are useful for addresses,
| verse, and adornment-free lists. | | Each new line begins with a | vertical bar ("|"). | Line breaks and initial indents | are preserved. | Continuation lines are wrapped portions of long lines; they begin with spaces in place of vertical bars. |
Line blocks are useful for addresses,
verse, and adornment-free lists.
Each new line begins with a
vertical bar ("|").
Line breaks and initial indents
are preserved.
Continuation lines are wrapped portions
of long lines; they begin
with spaces in place of vertical bars.
|
Block Quotes
(details)
| Plain text | Typical result |
|---|---|
|
Block quotes are just:
Indented paragraphs, and they may nest. |
Block quotes are just:
|
Use empty comments to separate indentation contexts, such as block quotes and directive contents.
Doctest Blocks
(details)
| Plain text | Typical result |
|---|---|
|
Doctest blocks are interactive
>>> print "This is a doctest block."
|
Doctest blocks are interactive Python sessions. They begin with ">>>" and end with a blank line. >>> print "This is a doctest block."
|
"The doctest module searches a module's docstrings for text that looks like an interactive Python session, then executes all such sessions to verify they still work exactly as shown." (From the doctest docs.)
Tables
(details)
There are two syntaxes for tables in reStructuredText. Grid tables are complete but cumbersome to create. Simple tables are easy to create but limited (no row spans, etc.).
| Plain text | Typical result | ||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
Grid table: +------------+------------+-----------+
|
Grid table:
|
||||||||||||||||||
|
Simple table: ===== ===== ======
|
Simple table:
|
Transitions
(details)
| Plain text | Typical result |
|---|---|
|
A transition marker is a horizontal line
------------ A transition should not begin or end a
|
A transition marker is a horizontal line of 4 or more repeated punctuation characters. A transition should not begin or end a section or document, nor should two transitions be immediately adjacent. |
Transitions are commonly seen in novels and short fiction, as a gap spanning one or more lines, marking text divisions or signaling changes in subject, time, point of view, or emphasis.
Explicit Markup
Explicit markup blocks are used for constructs which float (footnotes), have no direct paper-document representation (hyperlink targets, comments), or require specialized processing (directives). They all begin with two periods and whitespace, the "explicit markup start".
Footnotes
(details)
| Plain text | Typical result | ||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|
|
Footnote references, like [5]_.
Note that footnotes may get rearranged, e.g., to the bottom of the "page". .. [5] A numerical footnote. Note
|
Footnote references, like 5.
Note that footnotes may get rearranged, e.g., to the bottom of
the "page".
|
||||||||||
|
Autonumbered footnotes are
possible, like using [#]_ and [#]_. .. [#] This is the first one.
They may be assigned 'autonumber
.. [#third] a.k.a. third_ .. [#fourth] a.k.a. fourth_ |
Autonumbered footnotes are possible, like using 1 and 2.
They may be assigned 'autonumber labels' - for instance, 4 and 3.
|
||||||||||
|
Auto-symbol footnotes are also
possible, like this: [*]_ and [*]_. .. [*] This is the first one.
|
Auto-symbol footnotes are also
possible, like this: *
and †.
|
The numbering of auto-numbered footnotes is determined by the order of the footnotes, not of the references. For auto-numbered footnote references without autonumber labels ("[#]_"), the references and footnotes must be in the same relative order. Similarly for auto-symbol footnotes ("[*]_").
Citations
(details)
| Plain text | Typical result | ||||||
|---|---|---|---|---|---|---|---|
|
Citation references, like [CIT2002]_.
Note that citations may get rearranged, e.g., to the bottom of the "page". .. [CIT2002] A citation
Citation labels contain alphanumerics,
Given a citation like [this]_, one
.. [this] here. |
Citation references, like [CIT2002].
Note that citations may get rearranged, e.g., to the bottom of
the "page".
Citation labels contain alphanumerics, underlines, hyphens and fullstops. Case is not significant. Given a citation like [this], one can also refer to it like this.
|
Hyperlink Targets
(details)
External Hyperlink Targets
| Plain text | Typical result | |||||
|---|---|---|---|---|---|---|
|
External hyperlinks, like Python_.
.. _Python: http://www.python.org/ |
|
|||||
|
"Fold-in" is the representation typically used in HTML documents (think of the indirect hyperlink being "folded in" like ingredients into a cake), and "call-out" is more suitable for printed documents, where the link needs to be presented explicitly, for example as a footnote. You can force usage of the call-out form by using the "target-notes" directive.
reStructuredText also provides for embedded URIs (details), a convenience at the expense of readability. A hyperlink reference may directly embed a target URI inline, within angle brackets. The following is exactly equivalent to the example above:
| Plain text | Typical result |
|---|---|
|
External hyperlinks, like `Python
<http://www.python.org/>`_. |
External hyperlinks, like Python. |
Internal Hyperlink Targets
| Plain text | Typical result | ||
|---|---|---|---|
|
Internal crossreferences, like example_.
.. _example: This is an example crossreference target. |
|
||
|
Indirect Hyperlink Targets
(details)
| Plain text | Typical result |
|---|---|
|
Python_ is `my favourite
programming language`__. .. _Python: http://www.python.org/ __ Python_ |
The second hyperlink target (the line beginning with "__") is both an indirect hyperlink target (indirectly pointing at the Python website via the "Python_" reference) and an anonymous hyperlink target. In the text, a double-underscore suffix is used to indicate an anonymous hyperlink reference. In an anonymous hyperlink target, the reference text is not repeated. This is useful for references with long text or throw-away references, but the target should be kept close to the reference to prevent them going out of sync.
Implicit Hyperlink Targets
(details)
Section titles, footnotes, and citations automatically generate hyperlink targets (the title text or footnote/citation label is used as the hyperlink name).
| Plain text | Typical result |
|---|---|
|
Titles are targets, too
======================= Implicit references, like `Titles are targets, too`_. |
Titles are targets, too
Implicit references, like Titles are targets, too. |
Directives
(details)
Directives are a general-purpose extension mechanism, a way of adding support for new constructs without adding new syntax. For a description of all standard directives, see reStructuredText Directives.
| Plain text | Typical result |
|---|---|
|
For instance:
.. image:: images/nikola.png |
For instance: |
Substitution References and Definitions
(details)
Substitutions are like inline directives, allowing graphics and arbitrary constructs within text.
| Plain text | Typical result |
|---|---|
|
The |Nikola| static site generator
is named after Nikola Tesla.
.. |Nikola| image:: nikola.png |
The static site generator is named after Nikola Tesla. |
Comments
(details)
Any text which begins with an explicit markup start but doesn't use the syntax of any of the constructs above, is a comment.
| Plain text | Typical result |
|---|---|
|
.. This text will not be shown
(but, for instance, in HTML might be rendered as an HTML comment) |
|
|
An "empty comment" does not
consume following blocks. (An empty comment is ".." with blank lines before and after.) .. So this block is not "lost",
|
An "empty comment" does not
consume following blocks.
(An empty comment is ".." with
blank lines before and after.)
So this block is not "lost", despite its indentation. |
Getting Help
Users who have questions or need assistance with Docutils or reStructuredText should post a message to the Docutils-Users mailing list. The Docutils project web site has more information.
Authors: Tibs<EMAIL_ADDRESS>and David Goodger (goodger@python.org)


Revised 08/03/2010
Red text depicts changes
made since 03/25/2010
| VALUE | MODEL |
|---|---|
| 00-01 |
Reserved |
|
|
Ultra Violet Index Model |
|
|
NCEP/ARL Transport and Dispersion Model |
| 04 |
NCEP/ARL
Smoke Model |
|
|
Satellite Derived Precipitation and temperatures, from IR (See PDS Octet 41... for specific satellite ID) |
|
|
NCEP/ARL Dust Model |
| 07-09 |
Reserved |
|
|
Global Wind-Wave Forecast Model |
|
|
Global Multi-Grid Wave Model (Static Grids) |
|
|
Probabilistic Storm Surge |
| 13-18 |
Reserved |
|
|
Limited-area Fine Mesh (LFM) analysis |
| 20-24 |
Reserved |
|
|
Snow Cover Analysis |
| 26-29 |
Reserved |
|
|
Forecaster generated field |
|
|
Value added post processed field |
| 32-28 |
Reserved |
|
|
Nested Grid forecast Model (NGM) |
| 40-41 |
Reserved |
|
|
Global Optimum Interpolation Analysis (GOI) from GFS model |
|
|
Global Optimum Interpolation Analysis (GOI) from "Final" run |
|
|
Sea Surface Temperature Analysis |
|
|
Coastal Ocean Circulation Model |
| 46 |
HYCOM -
Global |
| 47 |
HYCOM -
North Pacific basin |
| 48 |
HYCOM -
North Atlantic basin |
|
|
Ozone Analysis from TIROS Observations |
| 50-51 |
Reserved |
|
|
Ozone Analysis from Nimbus 7 Observations |
|
|
LFM-Fourth Order Forecast Model |
| 54-63 |
Reserved |
|
|
Regional Optimum Interpolation Analysis (ROI) |
| 65-67 |
Reserved |
|
|
80 wave triangular, 18-layer Spectral model from GFS model |
|
|
80 wave triangular, 18 layer Spectral model from "Medium Range Forecast" run |
|
|
Quasi-Lagrangian Hurricane Model (QLM) |
| 71-72 |
Reserved |
|
|
Fog Forecast model - Ocean Prod. Center |
|
|
Gulf of Mexico Wind/Wave |
|
|
Gulf of Alaska Wind/Wave |
|
|
Bias corrected Medium Range Forecast |
|
|
126 wave triangular, 28 layer Spectral model from GFS model |
|
|
126 wave triangular, 28 layer Spectral model from "Medium Range Forecast" run |
|
|
Backup from the previous run |
|
|
62 wave triangular, 28 layer Spectral model from "Medium Range Forecast" run |
|
|
Analysis from GFS (Global Forecast System) |
|
|
Analysis from GDAS (Global Data Assimilation System) |
|
|
Reserved |
|
|
MESO NAM Model (currently 12 km) |
|
|
No longer used |
|
|
RUC Model, from Forecast Systems Lab (isentropic; scale: 60km at 40N) |
|
|
CAC Ensemble Forecasts from Spectral (ENSMB) |
|
|
NOAA Wave Watch III (NWW3) Ocean Wave Model |
|
|
Non-hydrostatic Meso Model (NMM) (Currently 8 km) |
|
|
62 wave triangular, 28 layer spectral model extension of the "Medium Range Forecast" run |
|
|
62 wave triangular, 28 layer spectral model extension of the GFS model |
|
|
62 wave triangular, 28 layer spectral model run from the "Medium Range Forecast" final analysis |
|
|
62 wave triangular, 28 layer spectral model run from the T62 GDAS analysis of the "Medium Range Forecast" run |
|
|
T170/L42 Global Spectral Model from MRF run |
|
|
T126/L42 Global Spectral Model from MRF run |
|
|
Global Forecast System Model
T574 - Forecast hours 00-192 T190 - Forecast hours 204 - 384 |
| 97 |
Reserved |
| 98 |
Climate
Forecast System Model -- Atmospheric model (GFS)
coupled to a multi level ocean model . Currently GFS
spectral model
at T62, 64 levels coupled to 40 level MOM3 ocean model. |
| 99 |
Miscellaneous
Test ID |
|
|
RUC Surface Analysis (scale: 60km at 40N) |
|
|
RUC Surface Analysis (scale: 40km at 40N) |
| 102-104 |
Reserved |
|
|
RUC Model from FSL (isentropic; scale: 20km at 40N) |
| 106 |
Reserved |
|
|
Global Ensemble Forecast System (GEFS) |
| 108 |
LAMP |
| 109 |
RTMA
(Real Time Mesoscale Analysis) |
|
|
NAM Model - 15km version |
| 111 |
NAM
model, generic resolution (Used in SREF processing) |
| 112 |
WRF-NMM model, generic resolution (Used in various runs) NMM=Nondydrostatic Mesoscale Model (NCEP) |
| 113 |
Products from NCEP SREF processing |
| 114 |
NAEFS Products from joined NCEP, CMC global ensembles |
| 115 |
Downscaled
GFS from NAM eXtension |
| 116 |
WRF-EM
model, generic resolution (Used in various runs) EM - Eulerian
Mass-core (NCAR - aka Advanced Research WRF) |
| 117-119 |
Reserved |
|
|
Ice Concentration Analysis |
|
|
Western North Atlantic Regional Wave Model |
|
|
Alaska Waters Regional Wave Model |
|
|
North Atlantic Hurricane Wave Model |
|
|
Eastern North Pacific Regional Wave Model |
|
|
North Pacific Hurricane Wave Model |
|
|
Sea Ice Forecast Model |
|
|
Lake Ice Forecast Model |
|
|
Global Ocean Forecast Model |
| 129 |
Global Ocean Data Analysis System (GODAS) |
|
|
Merge of fields from the RUC, NAM, and Spectral Model |
| 131 |
Great Lakes Wave Model |
| 132-139 |
Reserved |
|
|
North American Regional Reanalysis (NARR) |
|
|
Land Data Assimilation and Forecast System |
| 142-149 |
Reserved |
|
|
NWS River Forecast System (NWSRFS) |
|
|
NWS Flash Flood Guidance System (NWSFFGS) |
|
|
WSR-88D Stage II Precipitation Analysis |
|
|
WSR-88D Stage III Precipitation Analysis |
| 154-179 |
Reserved |
|
|
Quantitative Precipitation Forecast generated by NCEP |
|
|
River Forecast Center Quantitative Precipitation Forecast mosaic generated by NCEP |
|
|
River Forecast Center Quantitative Precipitation estimate mosaic generated by NCEP |
|
|
NDFD product generated by NCEP/HPC |
|
|
Climatological Calibrated Precipitation Analysis - CCPA |
| 185-189 |
Reserved |
|
|
National Convective Weather Diagnostic generated by NCEP/AWC |
|
|
Current Icing Potential automated product genterated by NCEP/AWC |
| 192 |
Analysis
product from NCEP/AWC |
| 193 |
Forecast
product from NCEP/AWC |
| 194 |
Reserved |
| 195 |
Climate
Data Assimilation System 2 (CDAS2) |
| 196 |
Climate
Data Assimilation System 2 (CDAS2) - used for regeneration runs |
| 197 |
Climate Data Assimilation System (CDAS) |
| 198 |
Climate Data Assimilation System (CDAS) - used for regeneration runs |
| 199 |
Climate
Forecast System Reanalysis (CFSR) -- Atmospheric model (GFS)
coupled to a multi level ocean, land and seaice model. Currently GFS
spectral model at T382, 64 levels coupled to 40 level MOM4 ocean model. |
|
|
CPC Manual Forecast Product |
| 201 |
CPC
Automated Product |
| 202-209 |
Reserved |
|
|
EPA Air Quality Forecast - Currently North East US domain |
| 211 |
EPA Air
Quality Forecast - Currently Eastern US domain |
| 212-214 |
Reserved |
| 215 |
SPC Manual Forecast Product |
| 216-219 | Reserved |
| 220 |
NCEP/OPC
automated product |
| 221-254 |
Reserved |
| 255 |
Missing |


I am Experienced Full Stack Developer & a Big Data Enthusiast. Data structures and algorithms that help problem solving and making systems more efficient excite me a lot. Having said that, I would like to see myself as an algorithmist down the line. Scalability, robustness, modularity, reusability and rich user experience are the integral five of my design process.
Download My ResumeReal-time network forensics and automated threat analysis solutions
Call-Em-All is an on-demand automated voice broadcasting and bulk text messaging service company
TCS is an Indian multinational information technology (IT) service, consulting and business solutions company


directions_run
Execute DSS
Model to use:
attach_file
Input Parameters
Execute
cloud_upload
Upload Model
attach_file
Select Model
Upload Model
list
Previous DSS Executions
List of previous executions
refresh
Results


--- layout: post title: "Google Suffocates Android Development Community" date: 2009-09-26 00:25:19 +0000 permalink: /2009/09/26/google-suffocates-android-development-community/ category: Linux redirect_from: - /blog/google-suffocates-android-development-community/ ---
Today, Google sent a C&D to Cyanogen, the maker of one of the most popular replacement firmwares for the Android platform. His firmware is based on the official Android firmware, but provides a few new features, like direct-dial shortcuts on the home screen, more home screens (5 by default) and root access.
The root access allows tethering from a notebook computer, so I can get 3G internet on something where I can actually read most of the sites. Looks like I might have to consider another platform.
Google: nice way to show how you can use FOSS to choke off an active development community. You should update your site where it says "Do no evil" to be "Do no evil, unless it makes even more money."


Users can post threads Only managers can post threads
Users can post events (for Sign-up) Only managers can post events
Managers:
Save Cancel


Manifests
Prerequisites
- Welcome Quest
- Power of Puppet Quest
- Resources Quest
Quest Objectives
- Understand the concept of a Puppet manifest
- Construct and apply manifests to manage resources
Getting Started
As you saw in the Resources Quest, Puppet's resource declarations can be used to keep track of just about anything in this Learning VM. So far, you have made changes to the Learning VM without using Puppet. You looked at resource declarations using puppet describe
and puppet resource
only in order to track your effects. In this quest, you will learn to craft your own resource declarations and inscribe them in a special file called a manifest. When you're ready to get started, type the following command:
quest --start manifest
Let's See What Quests You've Completed
Before you get started, let's take a look at the quests you have completed. Type the following command:
quest --completed
This is useful incase you forget which Quests you've already done. In this case it shows that you have completed three quests: (1)Welcome Quest (2)Power of Puppet Quest and (3)Resources Quest.
Puppet Manifests
Manifests are files containing Puppet code. They are standard text files saved with the .pp
file extension. The core of the Puppet language is the resource declaration as it describes a desired state for one resource. Puppet manifests contain resource declarations. Manifests, like the resource declarations they contain, are written in Puppet Language.
Don't Forget These Tools Too
You can use puppet describe
and puppet resource
for help using and understanding the user
resource...and any other resource type you're curious about.
Let's get started by making sure you're in your home directory: /root
. This is where you want to place newly created manifests.
cd /root
Text Editors
For the sake of simplicity and consistency, we use the text editor nano
in our instructions, but feel free to use vim
or another text editor of your choice.
Task 1 :
Create a manifest to remove user byte:
Unfortunately byte just doesn't seem to be working out as a sidekick. Let's create a manifest to get rid of byte. We will create a manifest, with some code in it. Type the following command, after you make sure you are in the /root
directory as mentioned above:
nano byte.pp
Type the following instructions into Byte's manifest:
user { 'byte':
ensure => 'absent',
}
Save the file and exit your text editor. We touched on this in the Resources Quests, but the ensure => absent
attribute/value pair states that we are going to make sure user byte does not exist in the Learning VM.
Puppet Parser
What if we made an error when writing our Puppet code? The puppet parser
tool is Puppet's version of a syntax checker. When provided with a file as an argument, this tool validates the syntax of the code in the file without acting on the definitions and declarations within. If no manifest files are provided, Puppet will validate the default site.pp
manifest. If there are no syntax errors, Puppet will return nothing when this command is ran, otherwise Puppet will display the first syntax error encountered.
The `puppet parser` tool can only ensure that the syntax of a manifest is well-formed. It cannot guarantee that your variables are correctly named, your logic is valid, or that your manifest does what you want it to.
Task 2 :
Using the puppet parser
tool, let's you check your manifest for any syntax errors. Type the following command:
puppet parser validate byte.pp
Again, if the parser returns nothing, continue on. If not, make the necessary changes and re-validate until the syntax checks out.
Puppet Apply
Once you've created a manifest you will use the puppet apply
tool to enforce it. The puppet apply
tool enables you to apply individual manifests locally. In the real world, you may want an easier method to apply multiple definitions across multiple systems from a central source. We will get there when we talk about classes and modules in suceeding quests. For now, manifests and puppet apply
aid in learning the Puppet language in small, iterative steps.
When you run puppet apply
with a manifest file as the argument, a catalog is generated containing a list of all resources in the manifest, along with the desired state you specified. Puppet will check each resource in your environment against the resource declaration in the manifest. Puppet's providers will then do everything necessary to bring the state of those resources in line with the resource declarations in your manifest.
Task 3 :
Once your byte.pp
manifest is error free, we're going to simulate the change in the Learning VM without actually enforcing those changes. Let's see what happens:
puppet apply --noop byte.pp
In the returned output, Puppet tells us that it has not made the changes to the Learning VM, but if it had, this is what would be changed.
Task 4 :
Since the simulated change is what we want, let's enforce the change on the Learning VM.
puppet apply byte.pp
How is byte doing?
HINT: Use the puppet resource command discussed in the Resource Quest.
byte does not seem to be doing well. Actually, the user's gone. The ensure => 'absent'
value clearly made short work of the user account.
Task 6 :
With Puppet manifests you can create as well as destroy. Lets create a new, stronger sidekick by adding user gigabyte
to the Learning VM using Puppet. If you need help on how to do this, refer to the previous tasks you've just completed in this quest. One thing to note: ensure => 'present'
will make sure GigaByte exists in the Learning VM.
The steps include creating a manifest file, and writing the minimal amount of Puppet code required to ensure that the user account is created. This task will be marked complete when the user exists on the system.
Review
This is a foundational quest you must understand in order to successfully use Puppet. As you saw when completing this quest, we've added two new tools to your toolbox: puppet parser
and puppet apply
. You always want to use puppet parser
to check the syntax of your manifest before using puppet apply
to enforce it. This quest contained a walkthough of the "best practice" methods to creating, checking, applying your manifest. We've also created a simplified version below for your reference:
- Open or create a manifest with the
.pp
extension - Add or edit your Puppet code
- Use the
puppet parser
tool to check for syntax errors (recommended) - Simulate your manifest using
puppet apply --noop
(recommended) - Enfore your manifest using
puppet apply
- Check to make sure everything is working correctly (recommended)
On a final note, if you go back to the Power of Puppet quest, you will notice that the init.pp
file containing the definition for class lvmguide
is a manifest.


Class: Adapter Abstract
- Inherits:
-
Object
- Object
- Adapter
- Includes:
- Logging
- Defined in:
- lib/business/adapter/adapter.rb
Overview
This class is abstract.
You must implement this class to adapt your data stream in our framework
Direct Known Subclasses
Constant Summary
Constant Summary
Constants included from Logging
Instance Method Summary (collapse)
-
- (Object) connect_stream(stream = 1)
Connects to a particular data stream.
-
- (Adapter) initialize
constructor
Initializes the Adapter to run the logger.
-
- (Object) persist(status)
Persist the status retrieved from the data stream.
Methods included from Logging
Constructor Details
- (Adapter) initialize
Initializes the Adapter to run the logger
14 15 16 17 18 19 |
# File 'lib/business/adapter/adapter.rb', line 14 def initialize logger.fatal('The method initialize in Adapter must be implemented') raise 'This method must be implemented' end |
Instance Method Details
- (Object) connect_stream(stream = 1)
Connects to a particular data stream
25 26 27 28 |
# File 'lib/business/adapter/adapter.rb', line 25 def connect_stream (stream=1) logger.fatal('The method connect_stream in Adapter must be implemented') raise 'This method must be implemented' end |
- (Object) persist(status)
Persist the status retrieved from the data stream
34 35 36 37 |
# File 'lib/business/adapter/adapter.rb', line 34 def persist status logger.fatal('The method persist in Adapter must be implemented') raise 'This method must be implemented' end |


Contributing
Please read through our
contributing guidelines
. Included are directions for opening issues, coding standards, and notes on development.
All HTML and CSS should conform to the
Code Guide
, maintained by
Mark Otto
.
Editor preferences are available in the
editor config
for easy use in common text editors. Read more and download plugins at
https://editorconfig.org/
.


NECO : Ogun cancels November sanitation exercise
by Temisan AmoyeBy James Ogunnaike, Abeokuta
The Ogun State government has cancelled the monthly sanitation exercise for November, 2019, in the State.
The government said it has also lifted restriction of movement order. This, the State government said would enable secondary school students across the state to take part in the on-going National Examination Council (NECO) examinations.
In a statement by Kunle Somorin, the Chief Press Secretary to the State Governor, Prince Dapo Abiodun while giving the approval said the decision was arrived at after reviewing the challenges that the restriction of movement order would have on the Mathematics paper in the NECO exams schedule for Saturday and which coincides with the timing of the monthly sanitation exercise.
ALSO READ: Hit and run driver kills two vigilante operatives in Anambra, guns removed
“It has become expedient that the interest of the students be considered. Mathematics is a general subject and we need to facilitate hitch-free preparation and movement of students, teachers and NECO officials and examiners to various centres where the exams would hold within and outside the state”, the statement said.
Abiodun, however, implored all citizens to ensure that the cleaning exercise is observed at their various houses, irrespective of the non-restriction of movement during the period of the exercise.
He further noted that it was imperative that all drainage channels be kept free of silts and refuse to avoid flooding of homes that could lead to the destruction of lives and properties.
ALSO READ: South Africa court rejects Zuma appeal to prevent corruption trial
“Cleaning should not be a one-month affair. We need to take care of our personal hygiene and clean our environment regularly and on a daily basis to avoid outbreak of cholera and other preventable and communicable diseases that could lead to epidemics,” the statement further said.
The governor mentioned that the Ministry of Environment and the Ogun State Environmental Protection Agency (OGEPA) have been mandated to go round and collect refuse generated during period of the exercise, while Environmental Health Officers have also been directed to ensure compliance with Public health regulations and bring offenders to book.


corda / net.corda.core.transactions / SignedTransaction / id
id
val id: SecureHash
Overrides NamedByHash.id
The Merkle root of the inner WireTransaction. Note that this is not the same as the simple hash of
txBits, which would not use the Merkle tree structure. If the difference isn't clear, please consult
the user guide section "Transaction tear-offs" to learn more about Merkle trees.


We propose the implementation of a special form
called rec
. This form is a generalization and combination of
the forms rec
and named-lambda
of
[Clinger1985]. It allows the simple and non-imperative construction of
self-referential expressions. As an important special case, it extends
the A. Church form lambda
such that it allows the direct
definition of recursive procedures without using further special forms
like let
or letrec
, without using advanced
constructions like the H. B. Curry combinator and, unlike
define
, without introducing variable bindings into the
external environment.