SyncRecordReader.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_DYNLD_RAF_SYNCRECORDREADER_H
#define NIDAS_DYNLD_RAF_SYNCRECORDREADER_H
 
#include <deque>
 
#include <nidas/dynld/SampleInputStream.h>
#include <nidas/core/SampleTag.h>
#include "SyncRecordVariable.h"
#include "SyncServer.h"
 
#include <nidas/util/ThreadSupport.h>
 
#ifdef SYNC_RECORD_JSON_OUTPUT
#include <json/json.h>
#endif
 
namespace nidas { namespace dynld { namespace raf {
 
class SyncRecHeaderException: public nidas::util::Exception
{
public:
    SyncRecHeaderException(const std::string& expect, const std::string& got):
    nidas::util::Exception("SyncRecHeaderException",
        std::string("expected: \"") + expect +
        "\", got: \"" + got + "\"")
    {
    }
    SyncRecHeaderException(const std::string& msg):
    nidas::util::Exception("SyncRecHeaderException",msg)
    {
    }
 
    SyncRecHeaderException(const SyncRecHeaderException& x):
    nidas::util::Exception(x)
    {
    }
};
 
class SyncRecordReader : public nidas::core::SampleClient
{
public:
 
    SyncRecordReader(IOChannel* iochan);
 
    SyncRecordReader(SyncServer* ss);
 
    virtual ~SyncRecordReader();
 
    const std::string& getProjectName() const { return projectName; }
 
    const std::string& getTailNumber() const { return aircraftName; }
 
    const std::string& getFlightName() const { return flightName; }
 
    const std::string& getSoftwareVersion() const { return softwareVersion; }
 
    time_t getStartTime() const { return startTime; }
 
    const std::list<const SyncRecordVariable*> getVariables();
 
    const SyncRecordVariable* getVariable(const std::string& name) const;
 
    size_t getNumValues() const { return numDataValues; }
 
    size_t read(dsm_time_t* tt, double *ptr, size_t len);
 
    const std::string &
    textHeader()
    {
        return _header;
    }
 
    virtual bool
    receive(const Sample *s) throw();
 
    virtual void
    flush() throw();
 
    void
    endOfStream();
 
    int
    getSyncRecOffset(const nidas::core::Variable* var);
 
    int
    getLagOffset(const nidas::core::Variable* var);
 
    const std::string&
    getConfigName()
    {
        return _sampleStreamConfigName;
    }
 
private:
 
    void init();
 
    void scanHeader(const Sample* samp);
 
    const Sample*
    nextSample();
 
    SampleInputStream* inputStream;
    SyncServer* syncServer;
 
    bool _read_sync_server;
 
    std::string getQuotedString(std::istringstream& str);
 
    void readKeyedQuotedValues(std::istringstream& header);
 
    SyncRecHeaderException* headException;
 
    std::list<SampleTag*> sampleTags;
 
    std::list<const SyncRecordVariable*> variables;
 
    std::map<std::string,const SyncRecordVariable*> variableMap;
 
    size_t numDataValues;
 
    std::string projectName;
 
    std::string aircraftName;
 
    std::string flightName;
 
    std::string softwareVersion;
 
    time_t startTime;
 
    bool _debug;
 
    std::string _header;
 
    nidas::util::Cond _qcond;
    bool _eoq;
 
    std::deque<const Sample*> _syncRecords;
 
    std::string _sampleStreamConfigName;
 
    SyncRecordReader(const SyncRecordReader&);
 
    SyncRecordReader& operator=(const SyncRecordReader&);
};
 
#ifdef SYNC_RECORD_JSON_OUTPUT
inline void
write_sync_record_header_as_json(std::ostream& json,
                                 const std::string& textheader)
{
    Json::Value root;
 
    std::istringstream iss(textheader);
    std::vector<std::string> lines;
    std::string line;
    while (getline(iss, line))
    {
        // Skip empty lines, especially the last one.
        if (line.length())
        {
            lines.push_back(line);
        }
    }
    Json::Value header;
    header.resize(lines.size());
    for (unsigned int i = 0; i < lines.size(); ++i)
    {
        header[i] = lines[i];
    }
    root["header"] = header;
    json << root;
}
 
 
std::string
json_sync_record_header_as_string(Json::Value& root)
{
  Json::Value& header = root["header"];
 
  std::ostringstream oss;
  for (unsigned int i = 0; i < header.size(); ++i)
  {
    oss << header[i].asString() << "\n";
  }
  return oss.str();
}
 
 
inline void
write_sync_record_data_as_json(std::ostream& json,
                               dsm_time_t tt,
                               const double* rec,
                               size_t numValues)
{
    Json::Value root;
    root["time"] = Json::UInt64(tt);
    root["numValues"] = (int)numValues;
    // Unfortunately the JSON spec does not support NAN, and so
    // the data values are written as strings. NANs have a
    // string form like 'nan' which strtod() can reliably
    // convert back to a double.  Likewise for infinity (inf*),
    // but those are not as likely to be seen in nidas data.
    Json::Value data;
    data.resize(numValues);
    char buf[64];
    for (unsigned int i = 0; i < numValues; ++i)
    {
        snprintf(buf, sizeof(buf), "%.16g", rec[i]);
        data[i] = buf;
    }
    root["data"] = data;
    json << root;
}
 
inline std::string
double_to_string(double value)
{
    char buf[64];
    snprintf(buf, sizeof(buf), "%.16g", value);
    return buf;
}
 
inline
Json::Value
write_sync_variable_as_json(const SyncRecordVariable* var,
                            dsm_time_t tt,
                            const double* rec)
{
    Json::Value variable;
    Json::Value values(Json::arrayValue);
 
    // Unfortunately the JSON spec does not support NAN, and so
    // the data values are written as strings. NANs have a
    // string form like 'nan' which strtod() can reliably
    // convert back to a double.  Likewise for infinity (inf*),
    // but those are not as likely to be seen in nidas data.
    size_t varoffset = var->getSyncRecOffset();
    int irate = (int)ceil(var->getSampleRate());
    int vlen = var->getLength();
 
    values.resize(vlen*irate);
    for (int i = 0; i < vlen*irate; ++i)
    {
        values[i] = double_to_string(rec[varoffset+i]);
    }
    variable["name"] = var->getName();
    variable["values"] = values;
 
    size_t lagoffset = var->getLagOffset();
    // int deltatUsec = (int)rint(USECS_PER_SEC / var->getSampleRate());
    dsm_time_t vtime = tt;
    if (!std::isnan(rec[lagoffset]))
        vtime += (int) rec[lagoffset];
    variable["time"] = Json::UInt64(vtime);
    variable["lagoffset"] = double_to_string(rec[lagoffset]);
    return variable;
}
 
inline
void
write_sync_record_as_json(std::ostream& json, dsm_time_t tt,
                          const double* record, int nvalues,
                          std::vector<const SyncRecordVariable*>& vars)
{
    Json::Value root;
    root["time"] = Json::UInt64(tt);
    root["numValues"] = nvalues;
    Json::Value& data = root["data"];
    std::vector<const SyncRecordVariable*>::const_iterator it;
    for (it = vars.begin(); it != vars.end(); ++it)
    {
        Json::Value variable = write_sync_variable_as_json(*it, tt, record);
        data.append(variable);
    }
    json << root;
}
#endif
 
}}} // namespace nidas namespace dynld namespace raf
 
#endif