File: pdbClass.h

/*************************************************************************/
/* DUCTAPE Version 2.0                                                   */
/* Copyright (C) 2001                                                    */
/* Forschungszentrum Juelich, Zentralinstitut fuer Angewandte Mathematik */
/*************************************************************************/

#ifndef __PDB_CLASS_H__
#define __PDB_CLASS_H__

#include "pdbGroup.h"
#include "pdbCRoutine.h"

class pdbBase : public pdbLoc {
public:
  pdbBase();
  pdbBase(pdbItem::virt_t v, pdbItem::access_t a, const pdbClass *base,
          pdbFile *file, int line, int col);
 
  pdbItem::virt_t virtuality() const;
  pdbItem::access_t access() const;
  const pdbClass *base() const;
  bool isVirtual() const;

  void virtuality(pdbItem::virt_t v);
  void access(pdbItem::access_t a);
  void base(const pdbClass* base);

private:
  pdbItem::virt_t   virt;
  pdbItem::access_t acs;
  const pdbClass   *bptr;
};

class pdbFriendFunc : public pdbLoc {
public:
  pdbFriendFunc();
  pdbFriendFunc(const pdbCRoutine *f, pdbFile *file, int line, int col);

  const pdbCRoutine *friendFunc() const;
  void friendFunc(const pdbCRoutine* f);

private:
  const pdbCRoutine *fuptr;
};

class pdbFriendClass : public pdbLoc {
public:
  pdbFriendClass();
  pdbFriendClass(const pdbClass *c, pdbFile *file, int line, int col);

  const pdbClass *friendClass() const;
  void friendClass(const pdbClass* c);

private:
  const pdbClass *cptr;
};

class pdbMethod : public pdbLoc {
public:
  pdbMethod();
  pdbMethod(const pdbCRoutine *f, pdbFile *file, int line, int col);

  const pdbCRoutine *func() const;
  void func(const pdbCRoutine* f);

private:
  const pdbCRoutine *fptr;
};

ostream& operator<<(ostream& ostr, const pdbBase& b);
ostream& operator<<(ostream& ostr, const pdbFriendFunc& f);
ostream& operator<<(ostream& ostr, const pdbFriendClass& c);
ostream& operator<<(ostream& ostr, const pdbMethod& f);

class pdbClass : public pdbGroup {
public:
  pdbClass(int id);
  pdbClass(const string& name, int id);
  virtual ~pdbClass();

  virtual ostream& print(ostream& ostr) const;
  virtual void adjustPtrs(PDB* p);
  virtual void process(PDB* p);
  virtual dupl_t findDuplicate(pdbSimpleItem* r);

  typedef vector<pdbBase *> basevec;
  typedef vector<pdbClass *> classvec;
  typedef vector<pdbMethod *> methodvec;
  typedef vector<pdbFriendClass *> friendclassvec;
  typedef vector<pdbFriendFunc *> friendfuncvec;

  const basevec& baseClasses() const;
  classvec& derivedClasses();
  const classvec& derivedClasses() const;
  const methodvec& methods() const;
  bool isABC() const;
  const friendclassvec& friendClasses() const;
  const friendfuncvec& friendRoutines() const;

  void addBaseClass(pdbItem::virt_t virt, pdbItem::access_t acs,
                    const pdbClass *bclass, pdbFile *file, int line, int col);
  void addDerivedClass(pdbClass *dclass);
  void addMethod(pdbCRoutine *func, pdbFile *file, int line, int col);
  void addFriendClass(pdbClass *f, pdbFile *file, int line, int col);
  void addFriendRoutine(pdbCRoutine *f, pdbFile *file, int line, int col);

private:
  basevec            base;
  classvec           drvd;
  methodvec          fmem;
  bool               abc;
  friendclassvec     fcl;
  friendfuncvec      fro;
};

#ifndef NO_INLINE
#  include "pdbClass.inl"
#endif
#endif