Dep.H

Go to the documentation of this file.

// Copyright (C) 2001, Compaq Computer Corporation
// 
// This file is part of Vesta.
// 
// Vesta is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// 
// Vesta 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
// Lesser General Public License for more details.
// 
// You should have received a copy of the GNU Lesser General Public
// License along with Vesta; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

// File: Dep.H

#ifndef Dep_H
#define Dep_H

#include "ValExpr.H"
#include <FV2.H>
#include <FP.H>
#include <SharedTable.H>

typedef FV2::T ArcSeq;

// The kind of a DepPath.
enum PathKind {
  NormPK = 'N', BangPK = '!', TypePK = 'T', LLenPK = 'L', BLenPK = 'B',
  ExprPK = 'E', DummyPK = 'D' };

class DepPath {
  // The representation of a path:
public:
  class DepPathC {
  public:
    DepPathC(int size)
      : pKind(NormPK), pathFP("", 0), dpathVersion(0)
        { path = NEW_CONSTR(ArcSeq, (size)); };
    DepPathC(const Text& id, PathKind pk);
    DepPathC(ArcSeq *tpath, PathKind pk);
    DepPathC(const ArcSeq& tpath, PathKind pk, const FP::Tag& fp,
             int version)
      : pKind(pk), pathFP(fp), dpathVersion(version)
        { path = NEW_CONSTR(ArcSeq, (tpath)); };
    DepPathC(ArcSeq *tpath, PathKind pk, const FP::Tag& fp)
      : path(tpath), pKind(pk), pathFP(fp), dpathVersion(0) { /*SKIP*/ };
    // Constructors.

    PathKind pKind;
    // The kind of a DepPath.

    int dpathVersion;
    // Used to avoid duplicate copy of this path.

    ArcSeq *path;
    // A path is a sequence of arcs (text).
    
    FP::Tag pathFP;
    // For efficient equality test only.
  };
      
  DepPathC *content;
  // The content of this DepPath.

  DepPath() { content = NULL; };
  // Default.  We do not allocate anything.

  DepPath(int size) { content = NEW_CONSTR(DepPathC, (size)); };
  // Construct an empty new DepPath.

  DepPath(ArcSeq *tpath, PathKind pk, const FP::Tag& fp)
    { content = NEW_CONSTR(DepPathC, (tpath, pk, fp)); };
  // Construct a new DepPath using a text sequence.

  DepPath(const Text& id, PathKind pk = NormPK)
    { content = NEW_CONSTR(DepPathC, (id, pk)); };
  // Construct a new DepPath with singleton id.

  DepPath(ArcSeq *path, PathKind pk)
    { content = NEW_CONSTR(DepPathC, (path, pk)); };
  // Construct a new DepPath using a copy of the text sequence path.

  DepPath(DepPathC *tcontent, int version = 0)
    { content = NEW_CONSTR(DepPathC, 
                           (*tcontent->path,
                             tcontent->pKind,
                             tcontent->pathFP,
                             version)); };
  // Construct a new DepPath by deep copying.

  void DeepCopy(const DepPath& dp, int version = 0)
    { content = NEW_CONSTR(DepPathC, 
                           (*dp.content->path,
                             dp.content->pKind,
                             dp.content->pathFP,
                             version)); };
  // Make this to be a deep copy of dp.

  DepPath* DeepCopy(int version = 0)
    { return NEW_CONSTR(DepPath, (this->content, version)); };
  // Make a deep copy of this.

  void Print(std::ostream *os);
  // Print this dependency path.

  int Size() { return content->path->size(); };
  // The length of this dependency path.

  int Version() { return content->dpathVersion; };
  // The version of this path.

  void Extend(const Text& id, PathKind pk = NormPK);
  // Extend (destructively) this path by id.

  void Extend(const ArcSeq& p, PathKind pk = NormPK);
  // Extend (destructively) this path by p from the end.

  void ExtendLow(const DepPath *dp);
  // Extend (destructively) this path by p from the front.

  Word Hash() const throw () { return content->pathFP.Hash(); };
  // Return a hash value for this.

  friend bool operator== (const DepPath& p1, const DepPath& p2)
    throw () {
      return ((p1.content->pathFP == p2.content->pathFP) && 
              (p1.content->pKind == p2.content->pKind)); };
  // Compare equality of two DepPaths.
};

class DepPathTbl {
public:
  typedef SharedTable<DepPath, Val>::T T;
  typedef SharedTable<DepPath, Val>::Iterator TIter;
  typedef SharedTable<DepPath, Val>::KVPair KVPair;
  typedef KVPair *KVPairPtr;

  class DPS: public T {
  public:
    DPS(int sizeHint = 0) throw (): T(sizeHint) { /*SKIP*/ };
    bool Member(const DepPath& p) { KVPairPtr dummyKV; return Get(p, dummyKV); };
    DPS* Add(DepPath *dp, Val v, PathKind pk = DummyPK);
    DPS* AddExtend(DepPath *dp, Val v, PathKind pk, const Text& id);
    DPS* Merge(DPS *pds) { if (pds != NULL) this->Copy(pds); return this; };
    void Print(std::ostream *os);
  };
};

typedef DepPathTbl::DPS DPaths;

#endif // Dep_H

---