org.vishia.event

Interface EventConsumer

All Known Implementing Classes:

EventConsumerAwait, FileAccessorLocalJava7, FileAccessZip, FileRemoteAccessor, FileRemoteProgressEventConsumer, FileRemoteWalkerCallbackCopy, FileRemoteWalkerCallbackDelete, StateMachine

public interface EventConsumer

This interface describe the access to consumers for events. The class which implements this interface is able to get events for example from a common queue and executes the #processEvent(EventMsg) method with the event.

Field Summary

Fields

Modifier and Type	Field and Description
static int	mEventConsumed Bit in return value of the processEvent(EventObject) for designation, that the given Event object was used to switch.
static int	mEventConsumerException This bit is set if the consumption causes an exception which is not intended.
static int	mEventConsumFinished This is the bit that the event consumption is really finished, the work is done.
static int	mEventDonotRelinquish Bit in return value of the processEvent(EventObject) for designation, that the given Event object is stored in another queue, therefore it should not relinquished yet..
static int	mMaskReservedHere This is only a hint which bits are usable here for further usage.
static java.lang.String	version Version, history and license 2023-07-24 Hartmut remove: The 'awaitExecution(...)' is no longer member of.

Method Summary

Modifier and Type	Method and Description
EventThread_ifc	evThread() This operation should return that thread, which is associated to this consumer.
int	processEvent(java.util.EventObject ev) This routine should be overwritten from the user to processes an event.

Field Detail

version

static final java.lang.String version

Version, history and license

• 2023-07-24 Hartmut remove: The 'awaitExecution(...)' is no longer member of. It is specific defined in EventConsumerAwait, not general for all consumer, not used in vishia Software and not sense.
• 2023-03-10 Hartmut new: evThread()
• 2023-02-21 Hartmut new: #awaitExecution(long)
• 2015-01-04 Hartmut chg: It is an abstract class instead an interface yet for new data, less effort for adaption. New method #shouldRun which does not need to override in all implementation.
• 2015-01-04 Hartmut chg: With the method #getStateInfo() any instance is able to quest for its state. It may be an important method for debugging and showing.
• 2013-05-11 Hartmut chg: It is an interface up to now. The idea to store a name for debugging on anonymous overridden instances is able to implement with an toString(){ return "name"} alternatively. The method doProcessEvent is renamed to #processEvent(EventMsg). The advantage of interface: multi inheritance. It is used as interface for org.vishia.stateMachine.StateCompositeBase.
• 2013-04-07 Hartmut adap: Event with 2 generic parameter
• 2012-08-30 Hartmut new: This is an abstract class now instead of an interface. The application should build an anonymous inner class with it. Because better debugging suppert the class has a name which is present to the toString()-method of an event.
• 2011-12-27 Hartmut created, concept of event queue, callback need for remote copy and delete of files (in another thread too). A adequate universal class in java.lang etc wasn't found.

Copyright/Copyleft: For this source the LGPL Lesser General Public License, published by the Free Software Foundation is valid. It means:

1. You can use this source without any restriction for any desired purpose.
2. You can redistribute copies of this source to everybody.
3. Every user of this source, also the user of redistribute copies with or without payment, must accept this license for further using.
4. But the LPGL ist not appropriate for a whole software product, if this source is only a part of them. It means, the user must publish this part of source, but don't need to publish the whole source of the own product.
5. You can study and modify (improve) this source for own using or for redistribution, but you have to license the modified sources likewise under this LGPL Lesser General Public License. You mustn't delete this Copyright/Copyleft inscription in this source file.

If you are intent to use this sources without publishing its usage, you can get a second license subscribing a special contract with the author.

See Also:

Constant Field Values

mEventConsumed

static final int mEventConsumed

Bit in return value of the processEvent(EventObject) for designation, that the given Event object was used to switch.

See Also:

Constant Field Values

mEventDonotRelinquish

static final int mEventDonotRelinquish

Bit in return value of the processEvent(EventObject) for designation, that the given Event object is stored in another queue, therefore it should not relinquished yet..

See Also:

Constant Field Values

mEventConsumFinished

static final int mEventConsumFinished

This is the bit that the event consumption is really finished, the work is done. The difference to mEventConsumed: Last one is on each call of processEvent(EventObject), If the process needs more events to transmit till if it is ready, then the last call should set this bit. If the process is finished with one event processing, this bit should be set by the first return.

See Also:

Constant Field Values

mEventConsumerException

static final int mEventConsumerException

This bit is set if the consumption causes an exception which is not intended.

See Also:

Constant Field Values

mMaskReservedHere

static final int mMaskReservedHere

This is only a hint which bits are usable here for further usage. Note: Bits in range 0xff0000 are used in StateSimple.mRunToComplete etc.

See Also:

Constant Field Values

Method Detail

evThread

EventThread_ifc evThread()

This operation should return that thread, which is associated to this consumer.

Returns:

null possible if no specific thread was associated.

processEvent

int processEvent(java.util.EventObject ev)

This routine should be overwritten from the user to processes an event. The return value of the users implementation can contain the following bits:

• 0x01 = mEventConsumed or StateSimple.mEventConsumed: The event is designated as consumed. If not set, the event should applied on other processEvent(EventObject) operations, for example for other states if possible
• 0x02 = mEventDonotRelinquish or StateSimple.mEventDonotRelinquish: The event should not be relinquished by the manager of the events (EventTimerThread), it will be relinquished later in the application after completion detection. It means the application (user) declares itself responsible for relinquish. See EventWithDst.relinquish().
• 0x04 = #mEventConsumerFinished: The task which should be organized by the event is finished. This bit is especially used to designate a TimeOrder as finished for usage, quest in TimeOrder#awaitExecution(int, int). Note that a task can need some more events or other conditions, this bit should be set on the last expected event in the return value of processEvent(EventObject). For example if a copy of a file tree is finished, or the graphic implementation is completely built.
• 0x08 = mEventConsumerException: The execution of processEvent(EventObject) has thrown an error, which is caught in the calling environment in EventTimerThread. How to deal with this information - the application is responsible to, the problem should be logged or debugged.
• 0x010000 .. 0x80000 = see StateSimple.

Parameters:

ev - The event. It contains some data. The type of the event is not specified here. Any events can be processed.

Returns:

0 or mEventConsumed or mEventDonotRelinquish etc. see list above. This value is forwarded to EventSource.notifyConsumed(int) and can be evaluated by the application in the calling thread or in any other thread which have access to implementation of EventSource.