source: trunk/ETSI-Testsuites/ETSI_auto_IOT/adapter/src/Capture/GenericCapture.h

/**
 * @file GenericCapture.h
 * This header file defines the GenericCapture class.
 * @author Tomas Urban
 * @version 0.2
 * @date 21/07/2009
 */
#ifndef GENERIC_CAPTURE_H
#define GENERIC_CAPTURE_H

#include "Messages/CapturedData.h"
#include "CaptureDispatch.h"


/**
 * Abstract class describing a capturing device. It defines the common interface and several
 * useful methods. However, the capturing code itself must be implemented in child classes
 * according to the means used for capture (strategy design pattern).
 */
class GenericCapture
{
private:
        CaptureDispatch * m_pDispatch;
        struct timeval m_offset;
        struct timeval m_startPoint;
        struct timeval m_timestamp;
        void UpdateTimestamp();
protected:
        GenericCapture();
        /**
         * This method is used for processing the captured data, passing it to an associated
         * CaptureDispatch object.
         * @param pData Data to process
         */
        void ProcessCapturedData(CapturedData * pData);
        /**
         * Sets the capture start point timestamp which is used in time-based filtering
         * @param timestamp Timestamp of the beginning of capture
         */
        void SetStartPoint(struct timeval timestamp);
public: 
        virtual ~GenericCapture(void);
        /**
         * Sets the object used for delivering captured data to the final recipient.
         */
        void InitDispatch(CaptureDispatch * pDispatch) { m_pDispatch = pDispatch; }
        /**
         * Initializes capturing object. The parameter contains additional initialization
         * data. The format of the data is device specific.
         * @param sParams Start-up parameters of the device
         * @return Operation success
         */
        virtual ECaptureInitResult OpenDevice(const std::string sParams) = 0;
        /**
         * Sets the path to an associated capture file. This call is used only by devices
         * capable of saving traffic into a file. In the default case, the method
         * doesn't cause any traffic to be saved.
         * @param sFile Name of the target file or empty string if the traffic should not 
         * be saved.
         * @return \c true if the operation succeeds, \c false otherwise.
         */
        virtual bool SetCaptureFile(const std::string sFile);
        /**
         * Contains device-specific clean-up code.
         */
        virtual void CloseDevice() = 0; 
        /**
         * Sets up the capture filter. If the string is empty, no filtering should be applied.
         * The format of the filtering parameter is device specific.
         * @param sFilter Filtering data
         * @return \c true if the operation was successful, \c false otherwise (e.g. in case
         * of invalid filter format)
         **/
        virtual bool SetFilter(const std::string sFilter) = 0;
        /**
         * Starts or resumes data capture on the device
         * @return \c true if the operation was successful, \c false otherwise
         */     
        virtual bool StartCapture() = 0;
        /**
         * Stops or suspends data capture on the device
         * @return \c true if the operation was successful, \c false otherwise
         */     
        virtual bool StopCapture() = 0;
        /**
         * Returns the type of the capturing device.
         * @return Capture type
         */
        virtual ECaptureType GetCaptureType() = 0;
        /**
         * Returns the offset of the time-based capturing filter. If the returned value is equal
         * to zero, no time-based filter is applied.
         * @return Offset used for time-based filtering
         */
        struct timeval GetStartOffset() const { return m_offset; }
        /**
         * Sets the offset of the time-based capturing filter. If the timestamp value is equal
         * to zero, no time-based filter is applied. Otherwise the capturing device automatically
         * discards captured messages whose timestamp is smaller than the specified offset. The
         * offset is related to the first captured message.
         * @param offset Offset used for time-based filtering
         */
        void SetStartOffset(struct timeval offset);
};

#endif