contrib/llvm/tools/clang/include/clang/AST/ASTUnresolvedSet.h

   1 //===-- ASTUnresolvedSet.h - Unresolved sets of declarations  ---*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file provides an UnresolvedSet-like class, whose contents are
  11 //  allocated using the allocator associated with an ASTContext.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  16 #define LLVM_CLANG_AST_ASTUNRESOLVEDSET_H
  17
  18 #include "clang/AST/ASTVector.h"
  19 #include "clang/AST/UnresolvedSet.h"
  20
  21 namespace clang {
  22
  23 /// \brief An UnresolvedSet-like class which uses the ASTContext's allocator.
  24 class ASTUnresolvedSet {
  25   struct DeclsTy : ASTVector<DeclAccessPair> {
  26     DeclsTy() {}
  27     DeclsTy(ASTContext &C, unsigned N) : ASTVector<DeclAccessPair>(C, N) {}
  28
  29     bool isLazy() const { return getTag(); }
  30     void setLazy(bool Lazy) { setTag(Lazy); }
  31   };
  32
  33   DeclsTy Decls;
  34
  35   ASTUnresolvedSet(const ASTUnresolvedSet &) LLVM_DELETED_FUNCTION;
  36   void operator=(const ASTUnresolvedSet &) LLVM_DELETED_FUNCTION;
  37
  38   friend class LazyASTUnresolvedSet;
  39
  40 public:
  41   ASTUnresolvedSet() {}
  42   ASTUnresolvedSet(ASTContext &C, unsigned N) : Decls(C, N) {}
  43
  44   typedef UnresolvedSetIterator iterator;
  45   typedef UnresolvedSetIterator const_iterator;
  46
  47   iterator begin() { return iterator(Decls.begin()); }
  48   iterator end() { return iterator(Decls.end()); }
  49
  50   const_iterator begin() const { return const_iterator(Decls.begin()); }
  51   const_iterator end() const { return const_iterator(Decls.end()); }
  52
  53   void addDecl(ASTContext &C, NamedDecl *D, AccessSpecifier AS) {
  54     Decls.push_back(DeclAccessPair::make(D, AS), C);
  55   }
  56
  57   /// Replaces the given declaration with the new one, once.
  58   ///
  59   /// \return true if the set changed
  60   bool replace(const NamedDecl *Old, NamedDecl *New, AccessSpecifier AS) {
  61     for (DeclsTy::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
  62       if (I->getDecl() == Old) {
  63         I->set(New, AS);
  64         return true;
  65       }
  66     }
  67     return false;
  68   }
  69
  70   void erase(unsigned I) { Decls[I] = Decls.pop_back_val(); }
  71
  72   void clear() { Decls.clear(); }
  73
  74   bool empty() const { return Decls.empty(); }
  75   unsigned size() const { return Decls.size(); }
  76
  77   void reserve(ASTContext &C, unsigned N) {
  78     Decls.reserve(C, N);
  79   }
  80
  81   void append(ASTContext &C, iterator I, iterator E) {
  82     Decls.append(C, I.ir, E.ir);
  83   }
  84
  85   DeclAccessPair &operator[](unsigned I) { return Decls[I]; }
  86   const DeclAccessPair &operator[](unsigned I) const { return Decls[I]; }
  87 };
  88
  89 /// \brief An UnresolvedSet-like class that might not have been loaded from the
  90 /// external AST source yet.
  91 class LazyASTUnresolvedSet {
  92   mutable ASTUnresolvedSet Impl;
  93
  94   void getFromExternalSource(ASTContext &C) const;
  95
  96 public:
  97   ASTUnresolvedSet &get(ASTContext &C) const {
  98     if (Impl.Decls.isLazy())
  99       getFromExternalSource(C);
 100     return Impl;
 101   }
 102
 103   void reserve(ASTContext &C, unsigned N) { Impl.reserve(C, N); }
 104   void addLazyDecl(ASTContext &C, uintptr_t ID, AccessSpecifier AS) {
 105     assert(Impl.empty() || Impl.Decls.isLazy());
 106     Impl.Decls.setLazy(true);
 107     Impl.addDecl(C, reinterpret_cast<NamedDecl*>(ID << 2), AS);
 108   }
 109 };
 110
 111 } // namespace clang
 112
 113 #endif