struct Handler 
{ 
    /// Meyer's case-insensitive comparision functor.
    struct CStrCaseInsComp : public std::binary_function< const char*, const char*, bool > 
    {
        bool operator()( const char* lhs, const char* rhs ) const
        { return (0 < strcmp(lhs, rhs)); }
	};
    /// map of pairs <key, value> for properties
	typedef std::map< const char*, const char*, CStrCaseInsComp > StringProperties;
    /// Initialize Handler. This methos is called once for handler each time business layer
    /// is initialized. Thi smethod is NOT called whe rule is applied to the message.
    /// @param fixEdgeProps set of the FixEdge properties.
    /// @param handlerProps set of the Handler's properties.
    /// @param pHelper handler helper
  virtual void init( const StringProperties &fixEdgeProps, const StringProperties &handlerProps, HandlerHelper *pHelper) = 0; 
    /// Registers message sender. Registered pointer is valid until detach() or destroy() 
    /// is called.
    /// @param pObserver - message sender object.
    /// @note pObserver not enqueues messages from handler's internal threads (from handler caller threads only)
    virtual void attach( MessageSender *pObserver ) = 0; 
    /// De-registers message sender. Do not use pointer after this method is called.
    virtual void detach() = 0; 
    /// Registers message sender. Registered pointer is valid until detachAsyncSender() or destroy() 
    /// is called.
    /// @param pObserver - message sender object.
    virtual void attachSyncSender( SyncMessageSender *pObserver ) = 0; 
    /// De-registers message sender. Do not use pointer after this method is called.
    virtual void detachSyncSender() = 0; 
    /// Destroys handler. Note detach() has already called.
    virtual void destroy() = 0; 
    /// Processes message. Method is called each time rule is successully applied to
    /// the message if correspondent handler call exists in rule's action
    /// @param msg Message being processed
    /// @param pIdentifier contains session ID if message was received from transport
    /// adaptor. Otherwise (i.e. message is received from FIX session) contains FIX session name from config or NULL.
    /// @note If message is received from FIX session then SenderCompID and TargetCompID can
    /// be extracted from message.
    /// @param isSourceID If parameter has true value then pIdentifier is the source identifier.
    /// @param execResult can be used 
    ///              for replacing original message (execResult.resultMsg_ - ownership is transmitted) for further processing or
    ///              for making custom reject with (execResult.description_) if message processing should be terminated
    /// @return false if message processing should be terminated in this rule    
    virtual bool process( const Engine::FIXMessage &msg, const char *pID, bool isSourceID, const StringProperties *props = NULL, ExtendedExecutionResult* execResult = NULL ) = 0; 
    /// Destructor. Desrtoys hander.
    virtual ~Handler() {}
	static const char* findProperty(const StringProperties& props, const char* value)
	{
		Handler::StringProperties::const_iterator iter = props.find(value);
		if (iter != props.end())
		{	
			return (*iter).second;
		}
		return "";
	}

/// Message sender interface. Observer.
struct MessageSender
{   
    /// Enqueues message to be send to the client session i.e. via transport adapter
    /// @param msg Message to be sent
    /// @param pIdentifier can contains the transport adapter client ID where message will be sent
    /// or source identifier of FixSession or TA client
    /// @ bIsClientID If parameter has false value then pIdentifier is the source identifier
    virtual void enqueue( const Engine::FIXMessage &msg , const char *pIdentifier, bool bIsClientID = true) = 0;         

    /// Enqueues message to be send to the FIX session.
    /// @param msg Message to be sent
    /// @param pSenderCompID target FIX session's SenderCompID
    /// @param pTargetCompID target FIX session's TargetCompID
    /// @note do not use this message to send message to the transport adapter session
    virtual void enqueue( const Engine::FIXMessage &msg, const char *pSenderCompID, const char *pTargetCompID ) = 0;

    /// Verifies that any message was enqueued for passed target
    /// @param pIdentifier can contains the transport adapter client ID or source identifier
    /// @ bIsClientID If parameter has false value then pIdentifier is the source identifier
    /// @return true if message is saved to queue, false - otherwise
    virtual bool isMsgEnqueued(const char *pIdentifier, bool bIsClientID = true) = 0;

    /// Verifies that any message was enqueued for passed target
    /// @param pSenderCompID FIX session's SenderCompID
    /// @param pTargetCompID FIX session's TargetCompID
    /// @return true if message is saved to queue, false - otherwise
    virtual bool isMsgEnqueued( const char *pSenderCompID, const char *pTargetCompID ) = 0;
};

<DllHandlers>
		<Handler
				Name="TestHandler"
				Description="Test Handler description"
				DllName="./SimplePlugin_71.dll"
				VerifyHandlersVersion="true" />
</DllHandlers>

<Action>
		<HandlerAction Name="TestHandler" />
</Action>