baciBACIProperty.h

Go to the documentation of this file.

#ifndef baciBACIProperty_H
#define baciBACIProperty_H

/*******************************************************************
* ALMA - Atacama Large Millimiter Array
* (c) European Southern Observatory, 2003 
*
*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: baciBACIProperty.h,v 1.8 2011/03/30 17:57:23 tstaig Exp $"
*
* who       when      what
* --------  --------  ----------------------------------------------
* dfugate 2005-01-17 created
*/

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

#include "baciExport.h"
#include "baciThread.h"
#include "baciValue.h"
#include "logging.h"
#include "baciBACIMonitor.h"
#include "baciCharacteristicModelImpl.h"

#include <vector>

namespace baci {


class BACIComponent;
class BACIProperty;

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

class baci_EXPORT PropertyImplementator 
{
public:

  virtual void getValue(BACIProperty* property,
                        BACIValue* value, 
                        Completion &completion,
                        CBDescOut& descOut) = 0;

  virtual int initialization() { return 0; }

  virtual ~PropertyImplementator() {}

};  /* PropertyImplementator */

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



class baci_EXPORT BACIProperty
{

public:

  BACIProperty(const ACE_CString& name_,
               PropertyImplementator* propertyImplementator_,
               CharacteristicModelImpl *characteristicModel_,
               const BACIValue& defaultValue_,
               BACIComponent* component_p);

  ~BACIProperty();

  /* ---- */

//  ACE_CString getName() const { return name; }
  const char * getName() const { return name_m.c_str(); }

  BACIValue::Type getType() const { return type_m; }

  PropertyImplementator* getPropertyImplementator() const { return propertyImplementator_mp; }

  CharacteristicModelImpl* getCharacteristicModel() const { return characteristicModel_mp; };

  void getValue(BACIProperty* property,
                BACIValue* value, 
                Completion &completion,
                CBDescOut& descOut)
  {
    if (propertyImplementator_mp!=0)
      propertyImplementator_mp->getValue(property,
                                      value,
                                      completion,
                                      descOut);
  }

  BACIComponent* getComponent() const { return component_mp; }

  int getMonitorCount() const { return monitorVector_m.size(); }
  BACIMonitor* getMonitorAt(int pos) const { return monitorVector_m[pos]; }
  
  bool hasTriggerOnValueMonitor() const { return triggerOnValueMonitor_m; }
  bool hasTriggerOnValuePercentMonitor() const { return triggerOnValuePercentMonitor_m; }

  ACS::TimeInterval getPollInterval() const { return pollInterval_m; }
  ACS::TimeInterval getLastPollTime() const { return lastPollTime_m; }
  ACS::TimeInterval getMonMinTriggerTime() const { return monMinTriggerTime_m; }
  BACIValue getLastValue() const { return lastValue_m; }
  //Completion getLastCompletion() const { return lastCompletion; }

  void setPollInterval(const ACS::TimeInterval& _pollInterval) { pollInterval_m=_pollInterval; }
  void setLastPollTime(const ACS::TimeInterval& _lastPollTime) { lastPollTime_m=_lastPollTime; }
  void setMonMinTriggerTime(const ACS::TimeInterval& _interval) { monMinTriggerTime_m=_interval; }
  void setLastValue(const BACIValue& _lastValue) {lastValue_m=_lastValue;}
  //void setLastCompletion(const Completion& _lastCompletion) { lastCompletion=_lastCompletion;}

  void dispatchMonitors(Completion& completion, CBDescOut& descOut);
  void updateMonitorStates();

  bool isInDestructionState() const { return inDestructionState_m; };

protected:

  void addMonitor(BACIMonitor* monitor);
  void removeMonitor(BACIMonitor* monitor);

  ACS::TimeInterval GCD(ACS::TimeInterval t1, ACS::TimeInterval t2);


private:
  ACE_CString name_m;

  PropertyImplementator* propertyImplementator_mp;
  CharacteristicModelImpl* characteristicModel_mp;

  BACIValue lastValue_m;

  BACIComponent* component_mp;

  BACIMonitorVector monitorVector_m;

  bool triggerOnValueMonitor_m;
  bool triggerOnValuePercentMonitor_m;
    ACS::TimeInterval pollInterval_m;
    ACS::TimeInterval lastPollTime_m;
    ACS::TimeInterval monMinTriggerTime_m;
  // Completion lastCompletion;

  BACIMonitor* archiver_mp;

  BACIValue::Type type_m;

  bool inDestructionState_m;

  BACIMutex monitorVectorMutex_m;

  friend class BACIComponent;
  friend class BACIMonitor;

    void operator=(const BACIProperty&);
    
    BACIProperty(const BACIProperty&);

};   /* BACIProperty */

typedef std::vector<BACIProperty*> BACIPropertyVector;


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

 }; 

#endif /* baci_H */