ArchiveChannel.h

#ifndef ARCHIVECHANNEL_H_
#define ARCHIVECHANNEL_H_

// tools
#include "tools/AutoPtr.h"

// storage
#include "storage/Index.h"

// engine
#include "engine/Named.h"
#include "engine/SampleMechanism.h"
#include "engine/EngineConfig.h"
#include "engine/ScanList.h"

class ArchiveChannel : public NamedBase,
                       public Guardable,
                       public ProcessVariableListener {

public:

    ArchiveChannel(EngineConfig& config, 
                   ProcessVariableContext& ctx,
                   ScanList& scan_list,
                   const char* channel_name,
                   double scan_period, 
                   bool monitor);

    virtual ~ArchiveChannel();

 protected:

    virtual SampleMechanism* 
      createSampleMechanism(EngineConfig& config,
                            ProcessVariableContext& ctx,
                            ScanList& scan_list) = 0;   

 public:

    // Guardable API

    virtual OrderedMutex& getMutex();

 public:

    // ProcessVariableListener API

    virtual void pvConnected(ProcessVariable& pv, const epicsTime& when);
    
    virtual void pvDisconnected(ProcessVariable& pv, const epicsTime& when);
              
    virtual void pvValue(ProcessVariable& pv, const RawValue::Data* data);

 public:

    void configure(ProcessVariableContext& ctx,
                   ScanList& scan_list,
                   double scan_period, 
                   bool monitor);

 public:
                
    void addToGroup(Guard& group_guard, 
                    class GroupInfo* group,
                    Guard& channel_guard, 
                    bool disabling);

    inline const stdList<class GroupInfo *> getGroups(Guard &guard) const;

    inline const stdList<class GroupInfo *> getGroupsToDisable(Guard& guard) const;

 public:
                      
    void start(Guard& guard);
    
    bool isRunning(Guard& guard);
    
    bool isConnected(Guard& guard) const;
     
    void disable(Guard& guard, const epicsTime& when);
     
    void enable(Guard& guard, const epicsTime& when);

    inline bool isDisabling(Guard& guard) const;
      
    inline bool isDisabled(Guard &guard) const;
    
    std::string getSampleInfo(Guard& guard);

    void stop(Guard& guard);

    unsigned long write(Guard& guard, Index& index); 

 public:
                 
    void addToFUX(Guard &guard, class FUX::Element *doc);
                
 protected:

    EngineConfig& config;

    OrderedMutex mutex;
    double scan_period;
    bool monitor;
    
    // See comments in implementation of waitWhileSampleMechanismBusy().
    bool sample_mechanism_busy;

    AutoPtr<SampleMechanism> sample_mechanism;
    void waitWhileSampleMechanismBusy(Guard &guard);

    // TODO: Use ConcurrentList types for the next 2.
    // Groups that this channel disables (might be empty)
    stdList<class GroupInfo *> disable_groups;

    // Groups to which this channel belongs (at least one)
    stdList<class GroupInfo *> groups;
    
    inline bool canDisable(Guard &guard) const;
    
    bool currently_disabling;
    
    size_t disable_count;
    
};

inline const stdList<class GroupInfo *>
ArchiveChannel::getGroups(Guard& guard) const {
    return groups;
}

inline const stdList<class GroupInfo *>
ArchiveChannel::getGroupsToDisable(Guard& guard) const {
    return disable_groups;
}
    
inline bool ArchiveChannel::isDisabled(Guard& guard) const {
    // Disabled when disabled by all its groups.
    // As long as one group didn't disable the channel,
    // it has to stay enabled.
    return disable_count == groups.size();
}
    
inline bool ArchiveChannel::canDisable(Guard& guard) const {
    return !disable_groups.empty();
}

inline bool ArchiveChannel::isDisabling(Guard& guard) const {
    return currently_disabling;
}

#endif /*ARCHIVECHANNEL_H_*/