maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Due to local reversions and re-patching, I accidentally had multiple copies 

of the 'payload' in this header.

llvm-svn: 94109
This commit is contained in:
John McCall 2010-01-21 22:59:41 +00:00
parent cb8d577eb2
commit 1848ea4fe3
1 changed files with 0 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

151
clang/include/clang/AST/UnresolvedSet.h
View File

@ -206,157 +206,6 @@ template <unsigned InlineCapacity> class UnresolvedSet :
};
} // namespace clang
#endif
//===-- UnresolvedSet.h - Unresolved sets of declarations ------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines the UnresolvedSet class, which is used to store
// collections of declarations in the AST.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_AST_UNRESOLVEDSET_H
#define LLVM_CLANG_AST_UNRESOLVEDSET_H
#include <iterator>
#include <llvm/ADT/PointerIntPair.h>
namespace clang {
class NamedDecl;
/// The iterator over UnresolvedSets. Serves as both the const and
/// non-const iterator.
class UnresolvedSetIterator {
typedef llvm::PointerIntPair<NamedDecl*, 2> DeclEntry;
typedef llvm::SmallVectorImpl<DeclEntry> DeclsTy;
typedef DeclsTy::const_iterator IteratorTy;
IteratorTy ir;
friend class UnresolvedSetImpl;
explicit UnresolvedSetIterator(DeclsTy::iterator ir) : ir(ir) {}
explicit UnresolvedSetIterator(DeclsTy::const_iterator ir) : ir(ir) {}
public:
UnresolvedSetIterator() {}
typedef std::iterator_traits<IteratorTy>::difference_type difference_type;
typedef NamedDecl *value_type;
typedef NamedDecl **pointer;
typedef NamedDecl *reference;
typedef std::iterator_traits<IteratorTy>::iterator_category iterator_category;
NamedDecl *getDecl() const { return ir->getPointer(); }
AccessSpecifier getAccess() const { return AccessSpecifier(ir->getInt()); }
NamedDecl *operator*() const { return getDecl(); }
UnresolvedSetIterator &operator++() { ++ir; return *this; }
UnresolvedSetIterator operator++(int) { return UnresolvedSetIterator(ir++); }
UnresolvedSetIterator &operator--() { --ir; return *this; }
UnresolvedSetIterator operator--(int) { return UnresolvedSetIterator(ir--); }
UnresolvedSetIterator &operator+=(difference_type d) {
ir += d; return *this;
}
UnresolvedSetIterator operator+(difference_type d) const {
return UnresolvedSetIterator(ir + d);
}
UnresolvedSetIterator &operator-=(difference_type d) {
ir -= d; return *this;
}
UnresolvedSetIterator operator-(difference_type d) const {
return UnresolvedSetIterator(ir - d);
}
value_type operator[](difference_type d) const { return *(*this + d); }
difference_type operator-(const UnresolvedSetIterator &o) const {
return ir - o.ir;
}
bool operator==(const UnresolvedSetIterator &o) const { return ir == o.ir; }
bool operator!=(const UnresolvedSetIterator &o) const { return ir != o.ir; }
bool operator<(const UnresolvedSetIterator &o) const { return ir < o.ir; }
bool operator<=(const UnresolvedSetIterator &o) const { return ir <= o.ir; }
bool operator>=(const UnresolvedSetIterator &o) const { return ir >= o.ir; }
bool operator>(const UnresolvedSetIterator &o) const { return ir > o.ir; }
};
/// UnresolvedSet - A set of unresolved declarations. This is needed
/// in a lot of places, but isn't really worth breaking into its own
/// header right now.
class UnresolvedSetImpl {
typedef UnresolvedSetIterator::DeclEntry DeclEntry;
typedef UnresolvedSetIterator::DeclsTy DeclsTy;
// Don't allow direct construction, and only permit subclassing by
// UnresolvedSet.
private:
template <unsigned N> friend class UnresolvedSet;
UnresolvedSetImpl() {}
UnresolvedSetImpl(const UnresolvedSetImpl &) {}
public:
// We don't currently support assignment through this iterator, so we might
// as well use the same implementation twice.
typedef UnresolvedSetIterator iterator;
typedef UnresolvedSetIterator const_iterator;
iterator begin() { return iterator(decls().begin()); }
iterator end() { return iterator(decls().end()); }
const_iterator begin() const { return const_iterator(decls().begin()); }
const_iterator end() const { return const_iterator(decls().end()); }
void addDecl(NamedDecl *D) {
addDecl(D, AS_none);
}
void addDecl(NamedDecl *D, AccessSpecifier AS) {
decls().push_back(DeclEntry(D, AS));
}
bool replace(const NamedDecl* Old, NamedDecl *New) {
for (DeclsTy::iterator I = decls().begin(), E = decls().end(); I != E; ++I)
if (I->getPointer() == Old)
return (I->setPointer(New), true);
return false;
}
bool empty() const { return decls().empty(); }
unsigned size() const { return decls().size(); }
void append(iterator I, iterator E) {
decls().append(I.ir, E.ir);
}
private:
// These work because the only permitted subclass is UnresolvedSetImpl
DeclsTy &decls() {
return *reinterpret_cast<DeclsTy*>(this);
}
const DeclsTy &decls() const {
return *reinterpret_cast<const DeclsTy*>(this);
}
};
/// A set of unresolved declarations
template <unsigned InlineCapacity> class UnresolvedSet :
public UnresolvedSetImpl {
llvm::SmallVector<UnresolvedSetImpl::DeclEntry, InlineCapacity> Decls;
};
} // namespace clang
#endif