6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-26 21:32:10 +00:00
Code Issues Projects Releases Wiki Activity

Add default index functor (an identity functor). You could use a

Browse Source 
vector directly to get the same functionality but using a DenseMap
makes the code more readable IMO.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@16052 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Alkis Evlogimenos 2004-08-26 03:37:28 +00:00
parent 07b52b367f
commit 5501e568b3
3 changed files with 54 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
include/Support/DenseMap.h
View File

@ -24,39 +24,45 @@
namespace llvm { namespace llvm {
template <typename T, typename ToIndexT> struct IdentityFunctor : std::unary_function<unsigned, unsigned> {
class DenseMap { unsigned operator()(unsigned Index) const {
return Index;
}
};
template <typename T, typename ToIndexT = IdentityFunctor>
class DenseMap {
typedef typename ToIndexT::argument_type IndexT; typedef typename ToIndexT::argument_type IndexT;
typedef std::vector<T> StorageT; typedef std::vector<T> StorageT;
StorageT storage_; StorageT storage_;
T nullVal_; T nullVal_;
ToIndexT toIndex_; ToIndexT toIndex_;
public: public:
DenseMap() : nullVal_(T()) { } DenseMap() : nullVal_(T()) { }
explicit DenseMap(const T& val) : nullVal_(val) { } explicit DenseMap(const T& val) : nullVal_(val) { }
typename StorageT::reference operator[](IndexT n) { typename StorageT::reference operator[](IndexT n) {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
typename StorageT::const_reference operator[](IndexT n) const { typename StorageT::const_reference operator[](IndexT n) const {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
void clear() { void clear() {
storage_.clear(); storage_.clear();
} }
void grow(IndexT n) { void grow(IndexT n) {
unsigned NewSize = toIndex_(n) + 1; unsigned NewSize = toIndex_(n) + 1;
if (NewSize > storage_.size()) if (NewSize > storage_.size())
storage_.resize(NewSize, nullVal_); storage_.resize(NewSize, nullVal_);
} }
}; };
} // End llvm namespace } // End llvm namespace

30
include/llvm/ADT/DenseMap.h
View File

@ -24,39 +24,45 @@
namespace llvm { namespace llvm {
template <typename T, typename ToIndexT> struct IdentityFunctor : std::unary_function<unsigned, unsigned> {
class DenseMap { unsigned operator()(unsigned Index) const {
return Index;
}
};
template <typename T, typename ToIndexT = IdentityFunctor>
class DenseMap {
typedef typename ToIndexT::argument_type IndexT; typedef typename ToIndexT::argument_type IndexT;
typedef std::vector<T> StorageT; typedef std::vector<T> StorageT;
StorageT storage_; StorageT storage_;
T nullVal_; T nullVal_;
ToIndexT toIndex_; ToIndexT toIndex_;
public: public:
DenseMap() : nullVal_(T()) { } DenseMap() : nullVal_(T()) { }
explicit DenseMap(const T& val) : nullVal_(val) { } explicit DenseMap(const T& val) : nullVal_(val) { }
typename StorageT::reference operator[](IndexT n) { typename StorageT::reference operator[](IndexT n) {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
typename StorageT::const_reference operator[](IndexT n) const { typename StorageT::const_reference operator[](IndexT n) const {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
void clear() { void clear() {
storage_.clear(); storage_.clear();
} }
void grow(IndexT n) { void grow(IndexT n) {
unsigned NewSize = toIndex_(n) + 1; unsigned NewSize = toIndex_(n) + 1;
if (NewSize > storage_.size()) if (NewSize > storage_.size())
storage_.resize(NewSize, nullVal_); storage_.resize(NewSize, nullVal_);
} }
}; };
} // End llvm namespace } // End llvm namespace

30
include/llvm/ADT/IndexedMap.h
View File

@ -24,39 +24,45 @@
namespace llvm { namespace llvm {
template <typename T, typename ToIndexT> struct IdentityFunctor : std::unary_function<unsigned, unsigned> {
class DenseMap { unsigned operator()(unsigned Index) const {
return Index;
}
};
template <typename T, typename ToIndexT = IdentityFunctor>
class DenseMap {
typedef typename ToIndexT::argument_type IndexT; typedef typename ToIndexT::argument_type IndexT;
typedef std::vector<T> StorageT; typedef std::vector<T> StorageT;
StorageT storage_; StorageT storage_;
T nullVal_; T nullVal_;
ToIndexT toIndex_; ToIndexT toIndex_;
public: public:
DenseMap() : nullVal_(T()) { } DenseMap() : nullVal_(T()) { }
explicit DenseMap(const T& val) : nullVal_(val) { } explicit DenseMap(const T& val) : nullVal_(val) { }
typename StorageT::reference operator[](IndexT n) { typename StorageT::reference operator[](IndexT n) {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
typename StorageT::const_reference operator[](IndexT n) const { typename StorageT::const_reference operator[](IndexT n) const {
assert(toIndex_(n) < storage_.size() && "index out of bounds!"); assert(toIndex_(n) < storage_.size() && "index out of bounds!");
return storage_[toIndex_(n)]; return storage_[toIndex_(n)];
} }
void clear() { void clear() {
storage_.clear(); storage_.clear();
} }
void grow(IndexT n) { void grow(IndexT n) {
unsigned NewSize = toIndex_(n) + 1; unsigned NewSize = toIndex_(n) + 1;
if (NewSize > storage_.size()) if (NewSize > storage_.size())
storage_.resize(NewSize, nullVal_); storage_.resize(NewSize, nullVal_);
} }
}; };
} // End llvm namespace } // End llvm namespace