//
//  Copyright © 2001 - 2002, RESON Inc. All Rights Reserved.
//
//  No part of this file may be reproduced or transmitted in any form or by
//  any means, electronic or mechanical, including photocopy, recording, or
//  information storage or retrieval system, without permission in writing
//  from RESON Inc.
//
//  Filename:   SensorScheduler.h
//
//  Project:    6046.
//
//  Author(s):  W. Arcus
//
//  Purpose:    
//
//  Notes:      
//

#if !defined(AFX_SENSORSCHEDULER_H__4794DDA9_A977_4A6F_A282_78E78446AA60__INCLUDED_)
#define AFX_SENSORSCHEDULER_H__4794DDA9_A977_4A6F_A282_78E78446AA60__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "ProcessInf.h"
#include "Timer.h"

#pragma pack( push, SENSORSCHEDULER_H_PACK, 1 )

typedef struct tagSCHEDULEDSENSOR
{
    int         m_iDelayInSeconds;
    int         m_iModule;
    SENSORINFO  m_sSensorInfo;

    tagSCHEDULEDSENSOR( void )
    {
        m_iDelayInSeconds   = 0;
        m_iModule           = 0;

        ::memset( &m_sSensorInfo, 0x00, SENSORINFO::Size() );
    }

    tagSCHEDULEDSENSOR( const int        &riDelayInSeconds,
                        const int        &riModule,
                        const SENSORINFO &rsSensorInfo )
    {
        m_iDelayInSeconds   = riDelayInSeconds;
        m_iModule           = riModule;
        m_sSensorInfo       = rsSensorInfo;
    }
    
    virtual ~tagSCHEDULEDSENSOR( void )
    {
        // Nothing to do.
    }

    bool operator < ( const tagSCHEDULEDSENSOR &rRhs ) const
    {
        return ( m_iDelayInSeconds < rRhs.m_iDelayInSeconds );
    }

    bool operator == ( const int &riModule ) const
    {
        return ( m_iModule == riModule );
    }
}
SCHEDULEDSENSOR, *PSCHEDULEDSENSOR;

#pragma pack( pop, SENSORSCHEDULER_H_PACK )

#include <list>

class CSensorScheduler  
{
public:

                        CSensorScheduler            (   void );
    virtual            ~CSensorScheduler            (   void );
                                                    
    bool                Start                       (   void );
                                                    
    bool                Reset                       (   void );
                                                    
    bool                Queue                       (   const   int             &riDelayInSeconds,
                                                        const   int             &riModule,
                                                        const   SENSORINFO      &rsSensorInfo );

    bool                ScheduledSensorInfo         (   SENSORINFO              &rsSensorInfo,
                                                        int                     &riModule,
                                                        const bool              &rbRemoveFromQueue = true );
                                                    
    bool                ScheduleNext                (   void );

                        operator HANDLE             (   void )  const;

private:

    ///////////////
    // Definitions.

    typedef std::list<SCHEDULEDSENSOR>              SchedulableSensorList_t;
    typedef SchedulableSensorList_t::iterator       SchedulableSensorListIterator_t;

    ///////////////
    // Attributes.

    CTimer                                          m_Timer;
    SchedulableSensorList_t                         m_SchedulableSensorList;

    ///////////////
    // Services.

    CSensorScheduler &  operator =                  (   const CSensorScheduler  &rRhs );     // Not implemented.
                        CSensorScheduler            (   const CSensorScheduler  &rRhs );     // Not implemented.

};

#endif // !defined(AFX_SENSORSCHEDULER_H__4794DDA9_A977_4A6F_A282_78E78446AA60__INCLUDED_)