acssampObjImpl.h

Go to the documentation of this file.

#ifndef _ACSAMP_OBJ_IMPL_H
#define _ACSAMP_OBJ_IMPL_H 
/*******************************************************************************
 *    ALMA - Atacama Large Millimiter Array
 *    (c) European Southern Observatory, 2002
 *    Copyright by ESO (in the framework of the ALMA collaboration)
 *    and Cosylab 2002, All rights reserved
 *
 *    This library is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 2.1 of the License, or (at your option) any later version.
 *
 *    This library is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with this library; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 *
 * "@(#) $Id: acssampObjImpl.h,v 1.30 2008/10/07 06:41:54 cparedes Exp $"
 *
 * who       when      what
 * --------  --------  ----------------------------------------------
 * oat       07/04/03  created 
 */

/************************************************************************
 *
 *----------------------------------------------------------------------
 */

#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif

#include "acssampImpl.h"
#include "acssampS.h"
#include <acsncSimpleSupplier.h>
#include <ace/Message_Queue.h>

#include <sstream>


#define ACS_SAMP_C class T, class T_var, class Tval
#define ACS_SAMP_TL T, T_var, Tval


//forward declaration
template<ACS_SAMP_C>
class ACSSampObjImpl;

template<ACS_SAMP_C>
class SamplingThread : public ACS::Thread
{
  public:
    SamplingThread(const ACE_CString& name,
                   ACSSampObjImpl<ACS_SAMP_TL> *sampObj,
                   const ACS::TimeInterval& responseTime=ThreadBase::defaultResponseTime, 
                   const ACS::TimeInterval& sleepTime=ThreadBase::defaultSleepTime) :
        ACS::Thread(name, responseTime, sleepTime),
        sampObj_p(sampObj) {}

    ~SamplingThread() {}

    virtual void runLoop()
        {
            if ( sampObj_p->isInDestructState() ) exit();
//          ACS_DEBUG("acssamp::ACSSampObjImpl::sampThreadWorker","sampling ...");                  
            // perform the sampling
            sampObj_p->doSamp();
        }
                
  private:

    ACSSampObjImpl<ACS_SAMP_TL> *sampObj_p;   
};


template<ACS_SAMP_C>
class SamplingThreadFlush : public ACS::Thread
{
  public:
    SamplingThreadFlush(const ACE_CString& name, 
                        ACSSampObjImpl<ACS_SAMP_TL> *sampObj,
                        const ACS::TimeInterval& responseTime=ThreadBase::defaultResponseTime, 
                        const ACS::TimeInterval& sleepTime=ThreadBase::defaultSleepTime) :
        ACS::Thread(name, responseTime, sleepTime),
        sampObj_p(sampObj) {}

    ~SamplingThreadFlush() {}

    virtual void runLoop()
        {
            ACS_DEBUG_PARAM("acssamp::ACSSampObjImpl::sampThreadFlush","Starting thread %s",getName().c_str());  
      
            if (sampObj_p->isInDestructState()) exit();
            //  ACS_DEBUG("acssamp::ACSSampObjImpl::sampThreadWorker","flushing on the NC ...");
            sampObj_p->flushSamp();
        }
                
  private:

    ACSSampObjImpl<ACS_SAMP_TL> *sampObj_p;   
};




template <ACS_SAMP_C>
class ACSSampObjImpl: public virtual POA_acssamp::SampObj,
                      public virtual PortableServer::RefCountServantBase
{
  
  public:
    ACSSampObjImpl(const ACE_CString& _cobName, const ACE_CString& _propertyName, 
                   ACS::TimeInterval _sampFrequency, ACS::TimeInterval _sampReportRate, baci::BACIComponent *_m_cob, ACS::Property_var _genProperty, ACSSampImpl * _sampPtr);

    virtual ~ACSSampObjImpl();


    virtual void start ();

    virtual void stop ();
    
    virtual void destroy();

    virtual void suspend();

    virtual void resume();


    virtual void setFrequency (ACS::TimeInterval sFrequency);
  

    virtual void getFrequency (ACS::TimeInterval_out sFrequency);



    virtual void setRate (ACS::TimeInterval rRate);
  


    virtual void getRate (ACS::TimeInterval_out rRate);



    virtual void initialize( );

    virtual void doSamp();


    virtual void flushSamp();


    ACS::TimeInterval getSampFrequency() const { return sampFrequency; }

    void setSampFrequency(const ACS::TimeInterval& _sampFrequency);

    ACS::TimeInterval getReportRate() const { return sampReportRate; }

    void setReportRate(const ACS::TimeInterval& _sampReportRate);

    CORBA::Object_ptr getCORBAReference() const { return reference_p; }


    virtual char * getChannelName();
    

    struct SampData {
        ACS::Time timeStamp; 
        Tval val;
    };


    bool isInDestructState() const { return inDestructState; };

  private:
  
  
    //ACE_CString name;  
    ACE_CString cobName; 
    ACE_CString propertyName;
    ACE_CString sampObjName;
    ACE_CString sampChannelName;

    ACS::TimeInterval sampFrequency;
    ACS::TimeInterval sampReportRate;

    bool inDestructState;

    baci::BACIComponent *cob_p;

    SamplingThread<ACS_SAMP_TL> *controlLoop_p;

    SamplingThreadFlush<ACS_SAMP_TL> *flush_p;
 
    //ACS::ThreadManager *threadManager_p;

    ACS::Property_var genProperty_p;

    T_var propToSamp_p;

    ACE_Message_Queue<ACE_SYNCH> *mq_p;

//  nc::SimpleSupplier<acssamp::SampObj::SampDataBlock> *sampSupplier_p;

    nc::SimpleSupplier *sampSupplier_p;

    CORBA::Object_ptr reference_p;

    ACSSampImpl *samp_p;
};



#include "acssampObjImpl.i"


#endif