costitem.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 COST_H
#define COST_H

#include <QString>

#include "subcost.h"
#include "context.h"
#include "utils.h"

class EventType;
class EventTypeSet;
class EventTypeMapping;
class TracePart;
class TraceData;

class CostItem
{
public:

    CostItem(ProfileContext*);
    virtual ~CostItem();

    ProfileContext* context() const { return _context; }
    ProfileContext::Type type() const { return context()->type(); }

  virtual QString name() const;

  virtual QString prettyName() const;

  virtual QString formattedName() const;

  virtual QString costString(EventTypeSet*);

  QString fullName() const;

  QString toString();

  virtual void clear();

  virtual void invalidate();

  void setDependant(CostItem* d) { _dep = d; }

  CostItem* dependant() { return _dep; }

  void setPosition(CostItem* p) { _position = p; }

  void setContext(ProfileContext* context) { _context = context; }

  // getters for specific positions, to be overwritten
  virtual TracePart* part();
  virtual const TracePart* part() const;
  virtual TraceData* data();
  virtual const TraceData* data() const;

 protected:
  virtual void update();

  ProfileContext* _context;
  bool _dirty;

  CostItem* _position;
  CostItem* _dep;
};


// The maximal number of subcosts in a ProfileCostArray and
// event types in a EventSet. Does not really matter for memory
// consumption as cost for a ProfileCostArray is dynamically
// allocated depending on used number of event types, and there
// will be only a low number of objects for EventType{,Set,Mapping}.
#define MaxRealIndexValue 200

class ProfileCostArray: public CostItem
{
    friend class EventType;
public:
  static const int MaxRealIndex;
  static const int InvalidIndex;


  ProfileCostArray(ProfileContext*);
  ProfileCostArray();
  virtual ~ProfileCostArray();

  virtual QString costString(EventTypeSet*);

  virtual void clear();

  // reserve space for cost
  void reserve(int);

  // set costs according to the mapping order of event types
  void set(EventTypeMapping*, const char*);
  void set(EventTypeMapping*, FixString&);
  // add costs according to the mapping order of event types
  void addCost(EventTypeMapping*, const char*);
  void addCost(EventTypeMapping*, FixString&);
  // add the cost of another item
  void addCost(ProfileCostArray* item);
  void addCost(int index, SubCost value);

  // maximal cost
  void maxCost(EventTypeMapping*, FixString&);
  void maxCost(ProfileCostArray* item);
  void maxCost(int index, SubCost value);
  ProfileCostArray diff(ProfileCostArray* item);

  virtual void invalidate();

  SubCost subCost(EventType*);

  QString prettySubCost(EventType*);

  QString prettySubCostPerCall(EventType* t, int calls);

 protected:
  virtual void update();

 private:
  // Only used by friend class EventType: return subcost by index
  SubCost subCost(int);

  SubCost* _cost;
  int _count; // only _count first indexes of _cost are used
  int _allocCount; // number of allocated subcost entries

  // cache last virtual subcost for faster access
  SubCost _cachedCost;
  EventType* _cachedType;
};


#endif // COST_H