qsescan.cpp

Go to the documentation of this file.

#include "qsescan.h"
#include "qsedataset.h"

#include <QRegExp>

#include <math.h>
#include <stdio.h>

QseScan::QseScan(const char *name)
  : QObject(NULL),
//     m_Role(UnspecifiedRole),
    m_Name(name),
    m_Command(name),
    m_Mutex(QMutex::Recursive),
    m_ScanDateTime(QDateTime::currentDateTime()),
    m_ScanNumber(-1)
{
}

QseScan::~QseScan()
{
  QMutexLocker lock(&m_Mutex);

  QseColumn *column;

  foreach (column, m_Columns) {
    delete column;
  }
}

QString QseScan::name() const
{
  QMutexLocker lock(&m_Mutex);

  return m_Name;
}

void QseScan::setName(QString name)
{
  QMutexLocker lock(&m_Mutex);
  
  m_Name = name;
}

int QseScan::columnCount() const
{
  QMutexLocker lock(&m_Mutex);

  return m_Columns.size();
}

void QseScan::setColumnCount(int n)
{
  int sz = columnCount();

  for (int i = sz-1; i>=n; i--) {
    QMutexLocker lock(&m_Mutex);
    
    if (m_Columns[i]) {
      delete m_Columns.takeAt(i);
    }
  }
}

void QseScan::clear()
{
  setColumnCount(0);

  QMutexLocker lock(&m_Mutex);

  m_Header.clear();
}

int QseScan::maxRowCount() const
{
  int maxcount = 0;
  int nc = columnCount();

  for (int i=0; i<nc; i++) {
    QseColumn *c = column(i);

    if (c) {
      int nr = c->rowCount();

      if (nr > maxcount) {
        maxcount = nr;
      }
    }
  }

  return maxcount;
}

void QseScan::setRowCount(int n)
{
  QMutexLocker lock(&m_Mutex);
  QseColumn *column;

  foreach (column, m_Columns) {
    column -> setRowCount(n);
  }
}

QseColumn* QseScan::column(int n) const
{
  if ((0 <= n) && (n < m_Columns.size())) {
    return m_Columns.at(n);
  } else {
    return NULL;
  }
}

QseColumn* QseScan::column(const QString& nm) const
{
  QMutexLocker lock(&m_Mutex);
  QseColumn *column;

  foreach (column, m_Columns) {
    if (column && (column->name()==nm)) {
      return column;
    }
  }

  return NULL;
}

void QseScan::setColumnNames(const char *nms)
{
  const char *ptr = nms + 3;
  const char *found, *next;
  int nc = columnCount();
  int col;
  char nam[256];

  for (col = 0; ptr; col++) {
    while ((*ptr)=='\t' || (*ptr)==' ') {
      ptr++;
    }
      
    found = strstr(ptr, "  ");
    if (found) {
      next = found + 2;
    } else {
      next = NULL;
    }
    
    QseColumn* c= NULL;
    
    if (next) {
      qstrncpy(nam, ptr, found-ptr+1);
      c = appendColumn(nam);
    } else {
      c = appendColumn(ptr);
    }
    
    nc++;
    ptr = next;
  }
}

void QseScan::appendHeader(const QString& h)
{
  QMutexLocker lock(&m_Mutex);
  m_Header.push_back(h);
}

QStringList QseScan::header() const
{
  QMutexLocker lock(&m_Mutex);
  return m_Header;
}

void QseScan::mergeHeaders(const QStringList &hdr)
{
  QString hdrline;

  foreach (hdrline, hdr) {
    bool nocont;
    {
      QMutexLocker lock(&m_Mutex);
      nocont = !m_Header.contains(hdrline);
    }

    if (nocont) {
      appendHeader(hdrline);
    }
  }
}

void QseScan::appendData(const char *l)
{
  int nc = columnCount();
  const char *ptr = l;
  char *next;

  for (int col = 0; ptr; col++) {
    double val;
    val = strtod(ptr, &next);

    if (ptr == next) {
      return ;
    }

    QseColumn *c=NULL;

    if (col >= nc) {
      c = appendColumn(QString("col%1").arg(col));

      if (nc > 0) {
        c -> setRowCount(column(0)->rowCount() - 1);
      }

      nc++;
    } else {
      c = column(col);
    }

    c -> appendData(val);

    ptr = next;
  }

  printf("\n");
}

QString QseScan::scanCommand() const
{
  QMutexLocker lock(&m_Mutex);

  return m_Command;
}

void QseScan::setScanCommand(const QString& cmd)
{
  QMutexLocker lock(&m_Mutex);

  m_Command = cmd;
}

QseColumn *QseScan::appendColumn(const QString &name, const QseColumn *proto)
{
  QseColumn *res=NULL;

  {
    QMutexLocker lock(&m_Mutex);

    res = new QseColumn(name);
    m_Columns.append(res);
    m_ColumnsDictionary[name]=res;
  }

  if (proto) {
    res -> setRowCount(proto -> rowCount());
    res -> assignment(proto);
  } else if (columnCount() > 0) {
    res -> setRowCount(column(0)->rowCount());
    res -> assignment(0.0);
  }
  
  return res;
}

void QseScan::writeScan(const QString &name)
{
  FILE *f = fopen(qPrintable(name),"w");
  int nr = maxRowCount();
  int nc = columnCount();
  int hsz;

  {
    QMutexLocker lock(&m_Mutex);
    hsz = m_Header.size();
  }

  for (int i = 0; i < hsz; i++) {
    QMutexLocker lock(&m_Mutex);
    fputs(qPrintable(m_Header[i]+"\n"), f);
  }

  fprintf(f,"#N");

  for (int i = 0; i < nc; i++) {
    QseColumn *c = column(i);
    if (c) {
      fprintf(f,"\t%s", qPrintable(c->name()));
    }
  }
  
  fprintf(f,"\n");
  
  for (int r = 0; r<nr; r++) {
    fprintf(f, "%d", r);

    for (int i = 0; i < nc; i++) {
      QseColumn *c = column(i);
      if (c) {
        fprintf(f,"\t%0.12g", c->data(r));
      }
    }
    
    fprintf(f,"\n");
  }

  fclose(f);
}

QDateTime QseScan::scanDateTime() const
{
  QMutexLocker lock(&m_Mutex);
  
  return m_ScanDateTime;
}

void QseScan::setScanDateTime(const QDateTime& datetime)
{
  QMutexLocker lock(&m_Mutex);
  
  m_ScanDateTime = datetime;
}

QString QseScan::scanDateLine() const
{
  QMutexLocker lock(&m_Mutex);
  
  return "#D " + m_ScanDateTime.toString(Qt::TextDate);
}

QString QseScan::scanColumnCountLine() const
{
  QMutexLocker lock(&m_Mutex);
  
  return QString("#N %1").arg(columnCount());
}

QString QseScan::scanColumnNamesLine() const
{
  QMutexLocker lock(&m_Mutex);
  
  QString res = "#L ";
  int ncols = columnCount();

  for (int i=0; i<ncols; i++) {
    if (i != 0) {
      res += "  ";
    }

    res += column(i) -> name();
  }

  return res;
}

int QseScan::scanNumber() const
{
  QMutexLocker lock(&m_Mutex);
  
  return m_ScanNumber;
}

void QseScan::setScanNumber(int n)
{
  QMutexLocker lock(&m_Mutex);
  
  m_ScanNumber = n;
}