SyncRecordSource.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2005, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program 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 General Public License for more details.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
 
#ifndef NIDAS_CORE_SYNCRECORDSOURCE_H
#define NIDAS_CORE_SYNCRECORDSOURCE_H
 
#include <nidas/core/Resampler.h>
#include <nidas/core/SampleTag.h>
 
#define SYNC_RECORD_ID 3
#define SYNC_RECORD_HEADER_ID 2
 
namespace nidas {
 
namespace util {
class LogContext;
}
 
namespace core {
class Variable;
class SampleTracer;
}
 
namespace dynld { namespace raf {
 
using namespace nidas::core;
 
class Aircraft;
 
class SyncInfo;
 
class SyncRecordSource: public Resampler
{
public:
 
    SyncRecordSource();
 
    virtual ~SyncRecordSource();
 
    static void
    selectVariablesFromProject(Project* project,
                               std::list<const Variable*>& variables);
 
    static void
    selectVariablesFromSensor(DSMSensor* sensor,
                              std::list<const Variable*>& variables);
 
    SampleSource* getRawSampleSource() { return 0; }
 
    SampleSource* getProcessedSampleSource() { return &_source; }
 
    std::list<const SampleTag*> getSampleTags() const
    {
        return _source.getSampleTags();
    }
 
    SampleTagIterator getSampleTagIterator() const
    {
        return _source.getSampleTagIterator();
    }
 
    void addSampleClient(SampleClient* client) throw()
    {
        _source.addSampleClient(client);
    }
 
    void removeSampleClient(SampleClient* client) throw()
    {
        _source.removeSampleClient(client);
    }
 
    void addSampleClientForTag(SampleClient* client,const SampleTag*) throw()
    {
        // I only have one tag, so just call addSampleClient()
        _source.addSampleClient(client);
    }
 
    void removeSampleClientForTag(SampleClient* client,const SampleTag*) throw()
    {
        _source.removeSampleClient(client);
    }
 
    int getClientCount() const throw()
    {
        return _source.getClientCount();
    }
 
    void flush() throw();
 
    const SampleStats& getSampleStats() const
    {
        return _source.getSampleStats();
    }
 
    void connect(SampleSource* source) throw();
 
    void disconnect(SampleSource* source) throw();
 
    void init();
 
    void sendSyncHeader() throw();
 
    bool receive(const Sample*) throw();
 
    // static const int NSYNCREC = 2;
 
    void
    preLoadCalibrations(dsm_time_t sampleTime) throw();
 
    static const int NSLOT_LIMIT = 2;
 
    static int nextRecordIndex(int i);
 
    static int prevRecordIndex(int i);
 
    bool prevRecord(SyncInfo& sinfo);
 
    bool nextRecord(SyncInfo& sinfo);
 
    static const int NSYNCREC = 2;
 
    int computeSlotIndex(const Sample* samp, SyncInfo& sinfo);
 
private:
 
    bool checkTime(const Sample* samp, SyncInfo& sinfo, SampleTracer& stracer,
            nidas::util::LogContext& lc, int warn_times);
 
    void slog(SampleTracer& stracer, const std::string& msg,
        const Sample* samp, const SyncInfo& sinfo);
 
    void log(nidas::util::LogContext& lc, const std::string& msg,
            const Sample* samp, const SyncInfo& sinfo);
 
    void log(nidas::util::LogContext& lc, const std::string& msg,
            const SyncInfo& sinfo);
 
    SampleSourceSupport _source;
 
    void addSampleTag(const SampleTag* tag) throw ()
    {
        _source.addSampleTag(tag);
    }
 
    void removeSampleTag(const SampleTag* tag) throw ()
    {
        _source.removeSampleTag(tag);
    }
 
    void createHeader(std::ostream&) throw();
 
    void
    sendSyncRecord();
 
    void
    allocateRecord(int irec, dsm_time_t timetag);
 
    int advanceRecord(dsm_time_t timetag);
 
    std::map<dsm_sample_id_t, SyncInfo> _syncInfo;
 
    std::list<const Variable*> _variables;
 
    SampleTag _syncRecordHeaderSampleTag;
 
    SampleTag _syncRecordDataSampleTag;
 
    size_t _recSize;
 
    dsm_time_t _syncHeaderTime;
 
    dsm_time_t _syncTime[2];
 
    int _current;
 
    int _halfMaxUsecsPerSample;
 
    SampleT<double>* _syncRecord[2];
 
    double* _dataPtr[2];
 
    size_t _unrecognizedSamples;
 
    std::ostringstream _headerStream;
 
    const Aircraft* _aircraft;
 
    bool _initialized;
 
    int _unknownSampleType;
 
    unsigned int _badLaterSamples;
 
    SyncRecordSource(const SyncRecordSource&);
 
    SyncRecordSource& operator=(const SyncRecordSource&);
 
};
 
/*
 * Whether to define an explicit copy constructor
 * and assignment op for SyncInfo. Some care is taken
 * in the code to avoid copy and assignment. Define
 * this to detect how often they are called.
 */
#define EXPLICIT_SYNCINFO_COPY_ASSIGN
 
class SyncInfo
{
public:
 
    SyncInfo(dsm_sample_id_t i, float r, SyncRecordSource* srs);
 
#ifdef EXPLICIT_SYNCINFO_COPY_ASSIGN
    SyncInfo(const SyncInfo&);
    static unsigned int ncopy;
 
    SyncInfo& operator=(const SyncInfo&);
    static unsigned int nassign;
#endif
 
    void addVariable(const Variable* var);
 
    void advanceRecord(int last);
 
    dsm_sample_id_t id;
 
    float rate;
 
    int nSlots;
 
    int dtUsec;
 
private:
    int islot;
 
    int irec;
 
public:
 
    int getSlotIndex() const { return islot; }
 
    bool incrementSlot();
 
    bool decrementSlot();
 
    bool checkNonIntRateIncrement();
 
    void computeSlotIndex(const Sample* samp);
 
    int getRecordIndex() const { return irec; }
 
    void incrementRecord()
    {
        irec = _srs->nextRecordIndex(irec);
    }
 
    void decrementRecord()
    {
        incrementRecord();
    }
 
    std::vector<size_t> varLengths;
 
    size_t sampleLength;
 
    size_t sampleSRIndex;
 
    std::list<const Variable*> variables;
 
    std::vector<size_t> varSRIndex;
 
    unsigned int discarded;
 
    bool overWritten;
 
    unsigned int noverWritten;
 
    unsigned int nskips;
 
    unsigned int skipped;
 
    unsigned int total;
 
    int minDiffInit;
 
    int minDiff;
 
    int skipMod;
 
    int skipModCount;
 
    static const int TDIFF_CHECK_USEC = 2 * USECS_PER_MSEC;
 
    unsigned int nEarlySamp;
 
    unsigned int nLateSamp;
 
    unsigned int outOfSlotMax;
 
private:
 
    SyncRecordSource* _srs;
 
};
 
}}} // namespace nidas namespace dynld namespace raf
 
#endif