qsescan.cpp

Go to the documentation of this file.

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

#include <QRegExp>

#include <math.h>

QseScan::QseScan(const char *name)
  : QObject(NULL),
    m_Role(UnspecifiedRole),
    m_Name(name),
    m_ScanNumber(-1)
{
}

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

  QseColumn *column;

  foreach (column, m_Columns) {
    delete column;
  }

  foreach (column, m_SpareColumns) {
    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]) {
      m_SpareColumns.append(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;
}

QseColumn *QseScan::appendColumn()
{
  QseColumn *col=NULL;

  {
    QMutexLocker lock(&m_Mutex);

    if (m_SpareColumns.size()) {
      col = m_SpareColumns.takeLast();
      col -> clear();
    } else {
      col = new QseColumn();
    }
    
    m_Columns.append(col);
  }

  return col;
}

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++) {
    found = strstr(ptr, "  ");
    if (found) {
      next = found + 2;
    } else {
      next = NULL;
    }
    
    QseColumn* c= NULL;
    
    if (col >= nc) {
      c = appendColumn();
      nc++;
    } else {
      c = column(col);
    }

    if (next) {
      qstrncpy(nam, ptr, found-ptr+1);
      c->setName(nam);
    } else {
      c->setName(ptr);
    }
    
    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();
      c -> setName(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);

  int ix = m_Header.indexOf(QRegExp("^#S.*$"));

  if (ix >= 0) {
    return m_Header[ix];
  } else {
    return "";
  }
}

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

  res->setName(name);

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


QseScan::QseScanRole QseScan::scanRole() const
{
  QMutexLocker lock(&m_Mutex);

  return m_Role;
}

void QseScan::setScanRole(const QseScan::QseScanRole r)
{
  QMutexLocker lock(&m_Mutex);

  m_Role = r;
}

void QseScan::setDefaultRoles()
{
  setScanRole(QseScan::UnspecifiedRole);
  int sz;
  {
    QMutexLocker lock(&m_Mutex);
    sz = m_Columns.size();
  }

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

    if (c) {
      c ->setDefaultRoles();
    }
  }
}

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
{
  return m_ScanDateTime;
}

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

int QseScan::scanNumber() const
{
  return m_ScanNumber;
}

void QseScan::setScanNumber(int n)
{
  m_ScanNumber = n;
}

---