eventtype.h

Go to the documentation of this file.

/* This file is part of KCachegrind.
   Copyright (C) 2002 - 2009 Josef Weidendorfer <Josef.Weidendorfer@gmx.de>

   KCachegrind 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, version 2.

   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 GNU General Public License
   along with this program; see the file COPYING.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#ifndef EVENTTYPE_H
#define EVENTTYPE_H

#include <QString>

#include "subcost.h"
#include "costitem.h"

class EventTypeSet;

class EventType
{
public:

  explicit EventType(const QString& name,
                          const QString& longName = QString(),
                          const QString& formula = QString());

  void setName(const QString& n) { _name = n; }
  void setLongName(const QString& n) { _longName = n; }
  void setEventTypeSet(EventTypeSet* m);
  // enforces event to be derived, even with empty formula
  void setFormula(const QString&);
  // default arg is for specifying a real type, but index unknown
  void setRealIndex(int r = ProfileCostArray::MaxRealIndex);

  const QString& name() { return _name; }
  const QString& longName() { return _longName; }
  const QString& formula() { return _formula; }
  EventTypeSet* set() { return _set; }
  int realIndex() { return _realIndex; }
  bool isReal() { return _isReal; }

  /*
   * returns true if all cost type names can be resolved in formula
   */
  bool parseFormula();
  QString parsedFormula();
  QString parsedRealFormula();

  SubCost subCost(ProfileCostArray*);

  /*
   * For virtual costs, returns a histogram for use with
   * partitionPixmap().
   * Returns maximal real index.
   */
  int histCost(ProfileCostArray* c, double total, double* hist);

  // application wide known types, referenced by short name
  // next 2 functions return a new type object instance
  static EventType* knownRealType(const QString&);
  static EventType* knownDerivedType(const QString&);
  static void add(EventType*, bool overwriteExisting = true);
  static bool remove(const QString&);
  static int knownTypeCount();
  static EventType* knownType(int);

private:

  QString _name, _longName, _formula, _parsedFormula;
  EventTypeSet* _set;
  bool _parsed, _inParsing, _isReal;
  // index MaxRealIndex is for constant addition
  int _coefficient[MaxRealIndexValue];
  int _realIndex;

  static QList<EventType*>* _knownTypes;
};


class EventTypeSet
{
public:
  EventTypeSet();
  ~EventTypeSet();

  EventTypeMapping* createMapping(const QString& types);

  // "knows" about some real types
  int addReal(const QString&);
  int add(EventType*);
  bool remove(EventType*);
  int realCount() { return _realCount; }
  int derivedCount() { return _derivedCount; }
  int minDerivedIndex() { return ProfileCostArray::MaxRealIndex; }
  EventType* type(int);
  EventType* realType(int);
  EventType* derivedType(int);
  EventType* type(const QString&);
  EventType* typeForLong(const QString&);
  int realIndex(const QString&);
  int index(const QString&);

  int addKnownDerivedTypes();

private:
  // we support only a fixed number of real and derived types
  EventType* _real[MaxRealIndexValue];
  EventType* _derived[MaxRealIndexValue];
  int _realCount, _derivedCount;
};

class EventTypeMapping
{
public:
  EventTypeMapping(EventTypeSet*);

  bool append(const QString&, bool create=true);
  bool append(int);
  void clear();

  EventTypeSet* set() { return _set; }

  int count() { return _count; }

  bool isIdentity() { return _isIdentity; }
  int realIndex(int i)
    { return (i<0 || i>=_count) ? ProfileCostArray::InvalidIndex : _realIndex[i]; }

  int maxRealIndex(int count);

  int firstUnused() { return _firstUnused; }
  int nextUnused(int i) {
      if (i<0 || i>=ProfileCostArray::MaxRealIndex) return ProfileCostArray::InvalidIndex;
      return _nextUnused[i]; }

private:
  EventTypeSet* _set;
  int _count, _firstUnused;
  bool _isIdentity;
  int _realIndex[MaxRealIndexValue];
  int _nextUnused[MaxRealIndexValue];
};


#endif // EVENTTYPE_H