TRANSFER BUFFER Operation

3. 
   TRANSFER BUFFER Operation
   

#include

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual size_t

virtual HRESULT

Set_MaximumSize( size_t size ) = 0;

virtual size_t

Get_Size() const = 0;

virtual bool

Full() const = 0;

virtual bool

Empty() const = 0;

virtual void

Append( ISLE_Operation* poperation ) = 0;

virtual void

Prepend( ISLE_Operation* poperation,

bool extend = false ) = 0;

virtual ISLE_Operation*

RemoveFront() = 0;

virtual ISLE_Operation*

RemoveRear() = 0;

virtual const ISLE_Operation*

Front() const = 0;

virtual void

Clear() = 0;

virtual void

Reset() = 0;

virtual bool

MoreData() const = 0;

virtual const ISLE_Operation*

Next() = 0;

};

Methods

size_t Get_MaximumSize() const;

Returns the maximum number of elements that can be stored into the buffer.

Sets the maximum number of elements that can be stored into the buffer. If the current size exceeds the requested maximum size returns an error.

Returns the number of elements currently stored in the buffer.

Returns true if the number of stored elements equals the maximum number that can be stored.

Returns true if nothing is stored in the buffer.

Appends the operation object to the end of the buffer. The operation object will be deleted by the buffer when it itself is deleted.

Inserts the operation object at the front of the buffer. If the argument ‘extend’ is set to true, the buffer is extended if it is already full and the maximum size is adjusted.

Returns the operation object at the beginning of the buffer and removes it from the buffer. If the buffer is empty returns NULL.

Returns the operation object at the end of the buffer and removes it from the buffer. If the buffer is empty returns NULL.

Returns a pointer to the first object in the buffer, without changing the buffer content.

Remove and delete all stored objects.

The following methods define a simple iterator for the transfer buffer. Iteration is always from the first to the last element stored.

Resets the iterator to the beginning of the buffer.

Returns true if more objects are stored in the buffer; i.e., the next call to Next() will return an object. If the iterator has reached the end of the buffer, returns false.

Returns the object at the position of the iterator and advances the iterator by one.

Code Example for iteration through the buffer (pbuf is a pointer to the buffer):

const ISLE_Operation* poperation = 0;

pbuf->Reset();

while ( buf->MoreData() ) {

poperation = buf->Next();

// do something with the object

}

Default Setting of Operation Parameters after Creation

No checks are defined.

1. 
   Interfaces Provided by Several Components
   
1. 
   Control of Interface BEHAVIOR
   
   1. 
      Sequential Flows of Control
      

The interface is used to control processing of a component providing the behavior ‘Sequential Flows of Control’ as defined in 3.7.2.

Processing of the component is started with the method StartSequential() and stopped by TerminateSequential(). StartSequential() returns as soon as processing of the component has started.

The event monitor (interface ISLE_EventMonitor) is used by the component to register events on which the component implementing this interface will wait. The timer handler (interface ISLE_TimerHandler) is used by the component to start timers and register a timeout processor to be called when the timer expires.

#include

#include

interface ISLE_EventMonitor;

interface ISLE_TimerHandler;
#define IID_ISLE_Sequential_DEF { 0xd020b008, 0xccd1, 0x11d2, \

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual HRESULT

ISLE_TimerHandler* ptimerhandler ) = 0;

virtual HRESULT

TerminateSequential() = 0;

};

Methods

HRESULT StartSequential( ISLE_EventMonitor* pmonitor,
ISLE_TimerHandler* ptimerhandler );

Starts processing of the component.

Terminates processing of the component.

2. 
   Event Monitor
   

Objects implementing this interface provide the means to register and de-register external events, which the object will monitor. When an event is detected, the object will call the method ProcessEvent() of the interface ISLE_EventProcessor passed as argument to the event registration method. If, for any reason the object is no longer able to monitor an event, it calls the method MonitorAbort() of the event processor.

#include

#include

interface ISLE_EventProcessor;

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual HRESULT

ISLE_EventProcessor* pprocessor ) = 0;

virtual HRESULT

RemoveEvent( const SLE_EventHandle& handle ) = 0;

};

Methods

HRESULT AddEvent( const SLE_EventHandle& handle,
ISLE_EventProcessor* pprocessor );

Registers the event identified by the event handle and the event processor that will process the event.

Removes a previously registered event and its event handler from the event monitor.

3. 
   Event Processor
   

The event processor handles an event detected by the event monitor with which it has been registered.

#include

#include
#define IID_ISLE_EventProcessor_DEF { 0xd020b00a, 0xccd1, 0x11d2, \

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual void

virtual void

MonitorAbort( const SLE_EventHandle& handle ) = 0;

};

Methods

Processes the event passed as argument.

The method is called when the event handler is no longer able to monitor the event.

4. 
   Timer Handler
   

Objects implementing this interface provide the means to start a timer and register a timeout processor. When the timer expires, the method ProcessTimeout() of the timeout processor is called. The interface also provides a method to cancel a running timer and to restart a timer that is already running. If for any reason the timer handler aborts a running timer by itself it calls the method HandlerAbort() of the timeout processor.

A running timer is identified by a timer identifier. This is an opaque type, with which the client must not associate any specific meaning. A specific identifier is only valid as long as the associated timer is running.

As an option, an invocation identifier can be associated with every activation of a timer. This invocation identifier is passed to the matching call of the method ProcessTimeout() of the timeout processor.

#include

#include

interface ISLE_TimeoutProcessor;

#define IID_ISLE_TimerHandler_DEF { 0xe265180, 0xd4bf, 0x11d2, \

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } };

{

virtual HRESULT

ISLE_TimeoutProcessor* pprocessor,

SLE_TimerId& timer,

int invocationId = 0 ) = 0;

virtual HRESULT

CancelTimer( SLE_TimerId timer ) = 0;

virtual HRESULT

RestartTimer( SLE_TimerId timer,

int timeout,

int invocationId = 0 ) = 0;

};

Methods

HRESULT StartTimer( int timeout,
ISLE_TimeoutProcessor* pprocessor,
SLE_TimerId& timer,
int invocationId );

Starts a timer and registers a timeout processor to be called when the timer expires.

Cancels a previously started timer.

Cancels and subsequently starts the timer identified in the first argument. Returns an error if the timer is not active.

5. 
   Timeout Processor
   

The timeout processor is called when a timer expires.

#include

#include
#define IID_ISLE_TimeoutProcessor_DEF { 0xe265181, 0xd4bf, 0x11d2, \

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } };

{

virtual void

int invocationId ) = 0;

virtual void

HandlerAbort( SLE_TimerId timer ) = 0;

};

Methods

void ProcessTimeout( SLE_TimerId timer, int invocationId );

Processes a timeout.

The method is called when the timer handler has aborted the timer for whatever reason.

6. 
   Concurrent Flows of Control
   

The interface is used to control processing of a component providing the behavior ‘Concurrent Flows of Control’ as defined in 3.7.3.

Processing of the component is started with the method StartConcurent(). The method checks the configuration and returns as soon as processing within the component has been started.

Synopsis

#include

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual HRESULT

virtual HRESULT

TerminateConcurrent() = 0;

};

Methods

Starts processing of the component.

Terminates processing of the component.

29. 
    Control of Traces
    

The interface is exported by objects that support generation of diagnostic traces. Trace records are entered to the interface ISLE_Trace passed to the method StartTrace(). This interface is provided by the SLE Application. Trace records and the trace levels are specified in 3.6.3.

#include

#include

interface ISLE_Trace;

{ 0x9b, 0x44, 0x0, 0xa0, 0x24, 0x6d, 0x80, 0xdb } }

{

virtual HRESULT

SLE_TraceLevel level,

bool forward ) = 0;

virtual HRESULT

StopTrace() = 0;

};

Methods

Starts tracing by the object that exports the interface. If the argument forward is set to true, the object also starts tracing of associated lower layers of the API, if applicable.

Stops a previously started trace.

1. 
   SLE API Proxy
   
1. 
   Component Creator Function
   

.H

The API proxy component includes a function to create an instance and obtain a pointer to the administrative interface. The signature of this function is defined as:

extern "C" HRESULT

_CreateProxy( const GUID& iid,

void** ppv );

where is replaced by the product identifier of the implementation. External ‘C’ linkage is required. The function ensures that a single instance of the proxy is created and returns pointer to the same instance if it is called repetitively. The function checks the argument identifying the interface and returns an error when the implementation does not support an interface with that identifier.

Arguments

iid identifier of the required interface

ppv pointer to the requested interface of the API proxy

Result codes

S_OK the object has been created

E_NOINTERFACE the specified interface is not supported

31. 
    SLE Proxy Administrative Interface
    

Name ISLE_ProxyAdmin

GUID {D020B00C-CCD1-11d2-9B44-00A0246D80DB}

Directory: sec -> docs -> 201510 Documents for SC13 Submission
sec -> Security Education Narrative Database Patterns of Professional Education
sec -> Guidelines for implementation of Prime Minister’s New 15 Point Programme for the Welfare of Minorities
sec -> Morphodynamics of a Constructed Marsh: Project Greenshores, Pensacola, Florida
sec -> Registration 6: 00pm – 6: 10pm Welcome/Opening Remarks
sec -> ¡bienvenidos! Welcome to Puerto Rico! 2 Things to know immediately upon arrival 2
sec -> Cadillac Racing cts-v coupe Media Kit
sec -> Sure Bet Narrative Nonfiction Suggestions
sec -> Executive Board of the United Nations Development Programme, the United Nations Population Fund and the United Nations Office for Project Services
201510 Documents for SC13 Submission -> Recommendation for Space Data System Practices

Download 2.26 Mb.

Share with your friends: