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()
    throw(nidas::util::Exception);

    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) throw(nidas::util::IOException);

    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)
        throw (SyncRecHeaderException);

    int
    getLagOffset(const nidas::core::Variable* var)
        throw (SyncRecHeaderException);

    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)
    throw(SyncRecHeaderException);

    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