descriptortree.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_DESCRIPTORTREE_H
#define GAIA_DESCRIPTORTREE_H

#include <QList>
#include <QStringList>
#include "region.h"
#include "gaia.h"

// OMFG is there no other way to do this?
#define NOCONST_CALL(f) const_cast<DescriptorTree*>(const_cast<const DescriptorTree*>(this)->f)

namespace gaia2 {

class DescriptorTree {

 public:
  // constructors
  DescriptorTree();
  DescriptorTree(const QString& name, DescriptorType type,
                 DescriptorLengthType ltype = VariableLength, int size = 1);

  // destructor
  ~DescriptorTree();

  // copy-constructor, assignment operator and equality comparison
 protected:
  DescriptorTree(const DescriptorTree& rhs);
  DescriptorTree& operator=(const DescriptorTree& rhs);

 public:
  bool operator==(const DescriptorTree& rhs) const;

  bool subtreeOf(const DescriptorTree* other) const;

  DescriptorTree* copy() const;

  void clear();

  QString name() const { return _segment.name; }

  QString fullName(bool recurseDown = true) const;

  DescriptorType type() const;

  DescriptorLengthType lengthType() const;

  const DescriptorTree* parent() const { return _parent; }
  DescriptorTree* parent() { return _parent; }

  bool isLeaf() const { return _children.empty(); }

  const DescriptorTree* root() const;

  DescriptorTree* root() { return NOCONST_CALL(root()); }

  void addChild(DescriptorTree* t);

  bool addChild(const QString& name, DescriptorType type,
                DescriptorLengthType ltype = VariableLength, int size = 1);

  void removeChild(DescriptorTree* child);

  void removeNode(const QString& name, bool recurse = true);

  void removeNodes(const QStringList& names, bool recurse = true);



  void fixLength(int length);

  void enumerate();

  QString descriptorName(DescriptorType type, DescriptorLengthType ltype, int index) const;

  QStringList descriptorNames() const;


  Region correspondingRegion() const;


  void updateLayout();

  DescriptorTree* findSimple(const QString& name);

  const DescriptorTree* find(const QString& name) const;
  DescriptorTree* find(const QString& name) { return NOCONST_CALL(find(name)); }

  const DescriptorTree* findFromRoot(const QString& name) const;
  DescriptorTree* findFromRoot(const QString& name) { return NOCONST_CALL(findFromRoot(name)); }


  const DescriptorTree* findLeaf(const QString& name) const;
  DescriptorTree* findLeaf(const QString& name) { return NOCONST_CALL(findLeaf(name)); }

  int regionSize(DescriptorType type, DescriptorLengthType ltype) const;

  // intended for debug only
  void printLeafSegments() const;

  QString toYaml(int spaces = 0) const;

  // this checks if the regiontree is in a consistent state. This includes the
  // following criteria up to now:
  // - the segment in each leaf node has to be of size 1;
  // - all leaf nodes should have a type which is not Undefined
  void checkConsistency() const;

  void modify();


 protected:
  Segment _segment; // should always be of size 1
                      // that is not necessarily true anymore, now that we have fixed length descriptors in the game, or is it?
  DescriptorTree* _parent;
  QList<DescriptorTree*> _children;


  bool _modified;
  bool _hashModified;

  struct CachedValues {
    uint hash;
    QList<DescriptorTree*> dfs;
    QList<const DescriptorTree*> dfsConst;
    QList<DescriptorTree*> leaves;
    QList<const DescriptorTree*> leavesConst;
    int realSize, stringSize, enumSize;
    int realSizeFixed, stringSizeFixed, enumSizeFixed;
  };

  mutable struct CachedValues _cache;

  QList<DescriptorTree*> nodes();
  QList<DescriptorTree*> leaves();

  QList<const DescriptorTree*> nodes() const;
  QList<const DescriptorTree*> leaves() const;

  QList<const DescriptorTree*> dfsNoCache() const;

  int regionSizeNoCache(DescriptorType type, DescriptorLengthType ltype) const;

  void reorder() const;
  void recomputeCaches() const;
  void recomputeHash() const;

  uint hash() const;

  void detach();

  void updateSegments(const QList<DescriptorTree*>& lrt) const;

  // find the given branch within this tree, starting at its root. Returns 0 if not found.
  // if onlyLeaves is set to true, only returns those branches that end in a leaf
  const DescriptorTree* find(const QStringList& nodeList, bool onlyLeaves, int i=0) const;

  friend QDataStream& operator<<(QDataStream& out, const DescriptorTree& tree);
  friend QDataStream& operator>>(QDataStream& in, DescriptorTree& tree);
};


} // namespace gaia2


#endif // GAIA_DESCRIPTORTREE_H