//
//  Copyright © 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:   Sensor.cpp
//
//  Project:    6046
//
//  Author(s):  W. Arcus
//
//  Purpose:    Defines an abstract base class for generic sensor interface.
//
//  Notes:      
//

#include "StdAfx.h"
#include "Sensor.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// CSensor class implementation.

int CSensor::m_iSensorRefCount = 0;

CSensor::CSensor( const int &riSensorIndex )

        :m_iInvalidSensorIndex( -1 ),

         m_uiInvalidMessageId      (   static_cast<unsigned int>( -1 ) ),
         m_dwInvalidThreadId       (   static_cast<DWORD>( -1 ) )
{
    ManageDllState_m();

    m_bStarted              = false;
    m_bActivateOnStartup    = false;

    m_iSensorIndex          = riSensorIndex;

    m_uiDataReadyMessageId  = m_uiInvalidMessageId;
    m_uiReplyReadyMessageId = m_uiInvalidMessageId;

    m_dwThreadId            = m_dwInvalidThreadId;
}

CSensor::CSensor( const CSensor &rRhs )

        :m_iInvalidSensorIndex( -1 ),

         m_uiInvalidMessageId      (   static_cast<unsigned int>( -1 ) ),
         m_dwInvalidThreadId       (   static_cast<DWORD>( -1 ) )
{
    ManageDllState_m();

    if ( &rRhs != this )
    {
        m_bStarted              = false;
        m_bActivateOnStartup    = rRhs.m_bActivateOnStartup;

        m_iSensorIndex          = rRhs.m_iSensorIndex;

        m_uiDataReadyMessageId  = rRhs.m_uiDataReadyMessageId;
        m_uiReplyReadyMessageId = rRhs.m_uiReplyReadyMessageId;

        m_dwThreadId            = rRhs.m_dwThreadId;
    }
}

CSensor::~CSensor( void )
{
    ManageDllState_m();

    m_dwThreadId            = m_dwInvalidThreadId;

    m_uiReplyReadyMessageId = m_uiInvalidMessageId;
    m_uiDataReadyMessageId  = m_uiInvalidMessageId;

    m_iSensorIndex          = m_iInvalidSensorIndex;

    m_bActivateOnStartup    = false;
    m_bStarted              = false;
}

CSensor & CSensor::operator = ( const CSensor &rRhs )
{
    ManageDllState_m();

    if ( &rRhs != this )
    {
        m_dwThreadId            = rRhs.m_dwThreadId;

        m_uiReplyReadyMessageId = rRhs.m_uiReplyReadyMessageId;
        m_uiDataReadyMessageId  = rRhs.m_uiDataReadyMessageId;

        m_iSensorIndex          = rRhs.m_iSensorIndex;

        m_bActivateOnStartup    = rRhs.m_bActivateOnStartup;
        m_bStarted              = false;
    }

    return *this;
}

int  CSensor::SensorIndex( void ) const
{
    ManageDllState_m();

    return m_iSensorIndex;
}

void CSensor::SensorIndex( const int &riSensorIndex )
{
    ManageDllState_m();

    m_iSensorIndex = riSensorIndex;
}

bool CSensor::ActivateOnStartup( void ) const
{
    ManageDllState_m();

    return m_bActivateOnStartup;
}

unsigned int CSensor::DataReadyMessage( void ) const
{
    ManageDllState_m();

    return m_uiDataReadyMessageId;
}

unsigned int CSensor::ReplyReadyMessage( void ) const
{
    ManageDllState_m();

    return m_uiReplyReadyMessageId;
}

DWORD CSensor::NotifyThreadId( void ) const
{
    ManageDllState_m();

    return m_dwThreadId;
}

bool CSensor::operator == ( const int &riSensorIndex ) const
{
    ManageDllState_m();

    return ( m_iSensorIndex == riSensorIndex );
}

bool CSensor::operator < ( const CSensor &rRhs ) const
{
    ManageDllState_m();

    return ( m_iSensorIndex < rRhs.m_iSensorIndex );
}

bool CSensor::IsStarted( void ) const
{
    ManageDllState_m();

    return m_bStarted;
}

bool CSensor::Startup(  const int                  &riSensorIndex,
                        const DWORD                &rdwThreadId,
                        const unsigned int         &ruiDataReadyMessageId,
                        const unsigned int         &ruiReplyReadyMessageId,
                        const int                  &riActivateOnStartup )
{
    ManageDllState_m();

    m_iSensorIndex          = riSensorIndex;
    m_dwThreadId            = rdwThreadId;
    m_uiDataReadyMessageId  = ruiDataReadyMessageId;
    m_uiReplyReadyMessageId = ruiReplyReadyMessageId;
    m_bActivateOnStartup    = ( riActivateOnStartup != 0 );

    m_Status.Reset();

    return true;
}

bool CSensor::Shutdown( void )
{
    ManageDllState_m();

    m_bStarted = false;

    return true;
}

bool CSensor::Load( BYTE            *pbyData,
                    unsigned long   *pulSize,
                    unsigned long   *pulTimeStamp )
{
    ManageDllState_m();

    UNREFERENCED_PARAMETER( pbyData );
    UNREFERENCED_PARAMETER( pulSize );
    UNREFERENCED_PARAMETER( pulTimeStamp );

    return true;
}

bool CSensor::SendCommand( int      iClientIndex,
                           char    *pszCommand )
{
    ManageDllState_m();

    UNREFERENCED_PARAMETER( iClientIndex );
    UNREFERENCED_PARAMETER( pszCommand );

    return true;
}

bool CSensor::RetrieveStatus(   BYTE                       *pbyData,
                                unsigned long              *pulSize,
                                unsigned long              *pulTimeStamp,
                                int                        *piClientIndex )
{
    ManageDllState_m();

    UNREFERENCED_PARAMETER( pbyData );

    *pulSize        = 0UL;
    *pulTimeStamp   = 0UL;
    *piClientIndex  = -1;

    return true;
}

bool CSensor::IsSensorHealthy( void )
{
    ManageDllState_m();

    return true;
}

bool CSensor::Reset( void )
{
    ManageDllState_m();

    m_Status.Reset();

    return true;
}

bool CSensor::RouteMessage( const int                  &riClientIndex,
                            const BYTE                 *pbyMessage,
                            const unsigned long        &rulSize,
                            const unsigned long        &rulTimeStamp )
{
    ManageDllState_m();

    UNREFERENCED_PARAMETER( riClientIndex );
    UNREFERENCED_PARAMETER( pbyMessage );
    UNREFERENCED_PARAMETER( rulSize );
    UNREFERENCED_PARAMETER( rulTimeStamp );

    return true;
}

bool CSensor::Identify( SENSORINFO *psSensorInfo )
{
    ManageDllState_m();

    UNREFERENCED_PARAMETER( psSensorInfo );

    return false;
}

bool CSensor::QueryHealth( void )
{
    ManageDllState_m();

    return true;
}

int CSensor::RefCount( void )
{
    ManageDllState_m();

    return m_iSensorRefCount;
}

int CSensor::AddRef( void )
{
    ManageDllState_m();

    return ( ++m_iSensorRefCount );
}

int CSensor::ReleaseRef( void )
{
    ManageDllState_m();

    if ( --m_iSensorRefCount < 0 )
    {
        m_iSensorRefCount = 0;
    }

    return m_iSensorRefCount;
}