dataset.h

/* 
 * Copyright (C) 2006-2013  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Gaia
 * 
 * Gaia is free software: you can redistribute it and/or modify it under 
 * the terms of the GNU Affero General Public License as published by the Free 
 * Software Foundation (FSF), either version 3 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.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */

#ifndef GAIA_DATASET_H
#define GAIA_DATASET_H

#include <QVector>
#include <QReadWriteLock>
#include "point.h"
#include "pointlayout.h"
#include "transformation.h"

namespace gaia2 {

// forward-declaration of View, a bit complex as everything is now templated...
class SearchPoint;
class DistanceFunction;
class DataSet;

template <typename DataSetType, typename PointType, typename SearchPointType, typename DistanceType>
class BaseView;

typedef BaseView<DataSet, Point, SearchPoint, DistanceFunction> View;


class PointArray : public QVector<Point*> {
 protected:
  bool _ownsMemory;

 public:

  PointArray(int n = 0, bool ownsMemory = true) : QVector<Point*>(n, 0), _ownsMemory(ownsMemory) {}
  PointArray(bool ownsMemory) : _ownsMemory(ownsMemory) {}
  ~PointArray();

  void clear();

  int totalSegments() const;

  const Point* samplePoint() const;
};



class DataSet : public PointArray, public QObject {

 public:
  DataSet();
  ~DataSet();

  QReadWriteLock lock;

  const QString& name() const { return _name; }

  void setName(const QString& name) { _name = name; }

  const Point* point(const QString& id) const;

  Point* point(const QString& id);

  bool contains(const QString& id) const;

  QStringList pointNames() const;

  const PointLayout& layout() const { return _layout; }

  const PointLayout& originalLayout() const;

  void checkAllPointsShareSameLayout(const QVector<Point*>* points = 0) const;

  const TransfoChain& history() const { return _history; }

  void setHistory(const TransfoChain& history);

  void forgetHistory();

  void simplifyHistory();



  void setReferenceDataSet(DataSet* dataset = 0, bool checkOriginalLayout = true);

  const DataSet* referenceDataSet() const;

  void addPoint(const Point* point);

  void addPoints(const QVector<Point*>& points);

  void appendDataSet(const DataSet* dataset);

  void removePoint(const QString& id);

  void removePoints(const QList<QString>& ids);




  void addView(View* view);

  void removeView(View* view);




  static DataSet* mergeFiles(const QMap<QString, QString>& sigfiles,
                             const QStringList& descsSelect = QStringList() << "*",
                             const QStringList& descsExclude = QStringList(),
                             int start = 0, int end = 10000000,
                             PointLayout* reflayout = 0);

  DataSet* copy() const;

  void load(const QString& filename, int start = 0, int end = -1);

  void loadNthPart(const QString& filename, int idx = 0, int total = 1);

  void save(const QString& filename) const;

  void fromBase64(const std::string& data);

  void fromBase64(const QByteArray& data);

  std::string toBase64() const;



 protected:

  QString _name;

  TransfoChain _history;

  PointLayout _layout;

  QList<DataSet*> _linkedDataSets;

  QList<View*> _linkedViews;

  bool _isDataSorted;

  int binarySearch(const QString& id, int start, int end) const;

  int pointIndex(const QString& id) const;

  void clear();

  int load(QDataStream& in, int start = 0, int end = -1, bool readAllPointsFromStream = false);

  void setLayoutIfEmpty(const Point* point);

  void invalidateViews();

  void modify();

  void setHistoryNoCheck(const TransfoChain& history) { _history = history; }

  void addTransformation(const Transformation& transfo);

  bool consistentLinks() const;

  void forceUnlinkReferringDataSets();

  void unifyLayout();

  void checkUniqueIDs();

  void checkUniqueIDsFrom(const QVector<Point*>& v);


  void addPoints(const QVector<Point*>& points,
                 bool layoutCheck,
                 bool transformPoint,
                 bool checkUnique = true,
                 bool takeOwnership = false,
                 bool relaySignal = true);

  void removePoints(const QList<QString>& ids, bool relaySignal);

  void sortPoints(int pivotIdx = -1);

  // make both the copy-constructor and assignment operator protected, so we
  // can ensure that no copy of a dataset can be made unintentionally (which could
  // lead to either memory problems or terrible performance)
  // people wanting to make a copy of a DataSet should use the DataSet::copy() method.
  DataSet(const DataSet& rhs);
  DataSet& operator=(const DataSet& rhs);

  // those functions from the parent class should also not be callable
  void resize(int n);

 public:

  friend class Applier; // to access the transformation history

  // mergeDataSets needs to have direct access to a DataSet to work properly
  // because it needs to call the setHistoryNoCheck() method.
  friend DataSet* mergeDataSets(const DataSet* ds1, const DataSet* ds2);


  // serialization methods
  friend QDataStream& operator<<(QDataStream& out, const DataSet& dataset);
  friend QDataStream& operator>>(QDataStream& in, DataSet& dataset);

};


} // namespace gaia2

#endif // GAIA_DATASET_H