ovr_sdk: 1b39a1b46319 LibOVR/Src/Kernel/OVR

556 OVR_ASSERT((ConstIterator::pHash) && ConstIterator::pHash->pTable && (ConstIterator::Index >= 0) && (ConstIterator::Index <= (intptr_t)ConstIterator::pHash->pTable->SizeMask));

557 return const_cast<SelfType*>(ConstIterator::pHash)->E(ConstIterator::Index).Value;

558 }

559

560 C* operator->() const

561 {

562 return &(operator*());

563 }

564

565 Iterator()

566 : ConstIterator(NULL, 0)

567 { }

568

569 // Removes current element from Hash

570 void Remove()

571 {

572 RemoveAlt(operator*());

573 }

574

575 template <class K>

576 void RemoveAlt(const K& key)

577 {

578 SelfType* phash = const_cast<SelfType*>(ConstIterator::pHash);

579 //Entry* ee = &phash->E(ConstIterator::Index);

580 //const C& key = ee->Value;

581

582 size_t hashValue = AltHashF()(key);

583 intptr_t index = hashValue & phash->pTable->SizeMask;

584

585 Entry* e = &phash->E(index);

586

587 // If empty node or occupied by collider, we have nothing to remove.

588 if (e->IsEmpty() || (e->GetCachedHash(phash->pTable->SizeMask) != (size_t)index))

589 return;

590

591 // Save index

592 intptr_t naturalIndex = index;

593 intptr_t prevIndex = -1;

594

595 while ((e->GetCachedHash(phash->pTable->SizeMask) != (size_t)naturalIndex) || !(e->Value == key))

596 {

597 // Keep looking through the chain.

598 prevIndex = index;

599 index = e->NextInChain;

600 if (index == -1)

601 return; // End of chain, item not found

602 e = &phash->E(index);

603 }

604

605 if (index == (intptr_t)ConstIterator::Index)

606 {

607 // Found it - our item is at index

608 if (naturalIndex == index)

609 {

610 // If we have a follower, move it to us

611 if (!e->IsEndOfChain())

612 {

613 Entry* enext = &phash->E(e->NextInChain);

614 e->Clear();

615 new (e) Entry(*enext);

616 // Point us to the follower's cell that will be cleared

617 e = enext;

618 --ConstIterator::Index;

619 }

620 }

621 else

622 {

623 // We are not at natural index, so deal with the prev items next index

624 phash->E(prevIndex).NextInChain = e->NextInChain;

625 }

626

627 // Clear us, of the follower cell that was moved.

628 e->Clear();

629 phash->pTable->EntryCount --;

630 }

631 else

632 OVR_ASSERT(0); //?

633 }

634

635 private:

636 friend class HashSetBase<C, HashF, AltHashF, Allocator, Entry>;

637

638 Iterator(SelfType* h, intptr_t i0)

639 : ConstIterator(h, i0)

640 { }

641 };

642

643 friend struct Iterator;

644

645 Iterator Begin()

646 {

647 if (pTable == 0)

648 return Iterator(NULL, 0);

649

650 // Scan till we hit the First valid Entry.

651 size_t i0 = 0;

652 while (i0 <= pTable->SizeMask && E(i0).IsEmpty())

653 {

654 i0++;

655 }

656 return Iterator(this, i0);

657 }

658 Iterator End() { return Iterator(NULL, 0); }

659

660 ConstIterator Begin() const { return const_cast<SelfType*>(this)->Begin(); }

661 ConstIterator End() const { return const_cast<SelfType*>(this)->End(); }

662

663 template<class K>

664 Iterator Find(const K& key)

665 {

666 intptr_t index = findIndex(key);

667 if (index >= 0)

668 return Iterator(this, index);

669 return Iterator(NULL, 0);

670 }

671

672 template<class K>

673 Iterator FindAlt(const K& key)

674 {

675 intptr_t index = findIndexAlt(key);

676 if (index >= 0)

677 return Iterator(this, index);

678 return Iterator(NULL, 0);

679 }

680

681 template<class K>

682 ConstIterator Find(const K& key) const { return const_cast<SelfType*>(this)->Find(key); }

683

684 template<class K>

685 ConstIterator FindAlt(const K& key) const { return const_cast<SelfType*>(this)->FindAlt(key); }

686

687 private:

688 // Find the index of the matching Entry. If no match, then return -1.

689 template<class K>

690 intptr_t findIndex(const K& key) const

691 {

692 if (pTable == NULL)

693 return -1;

694 size_t hashValue = HashF()(key) & pTable->SizeMask;

695 return findIndexCore(key, hashValue);

696 }

697

698 template<class K>

699 intptr_t findIndexAlt(const K& key) const

700 {

701 if (pTable == NULL)

702 return -1;

703 size_t hashValue = AltHashF()(key) & pTable->SizeMask;

704 return findIndexCore(key, hashValue);

705 }

706

707 // Find the index of the matching Entry. If no match, then return -1.

708 template<class K>

709 intptr_t findIndexCore(const K& key, size_t hashValue) const

710 {

711 // Table must exist.

712 OVR_ASSERT(pTable != 0);

713 // Hash key must be 'and-ed' by the caller.

714 OVR_ASSERT((hashValue & ~pTable->SizeMask) == 0);

715

716 size_t index = hashValue;

717 const Entry* e = &E(index);

718

719 // If empty or occupied by a collider, not found.

720 if (e->IsEmpty() || (e->GetCachedHash(pTable->SizeMask) != index))

721 return -1;

722

723 while(1)

724 {

725 OVR_ASSERT(e->GetCachedHash(pTable->SizeMask) == hashValue);

726

727 if (e->GetCachedHash(pTable->SizeMask) == hashValue && e->Value == key)

728 {

729 // Found it.

730 return index;

731 }

732 // Values can not be equal at this point.

733 // That would mean that the hash key for the same value differs.

734 OVR_ASSERT(!(e->Value == key));

735

736 // Keep looking through the chain.

737 index = e->NextInChain;

738 if (index == (size_t)-1)

739 break; // end of chain

740

741 e = &E(index);

742 OVR_ASSERT(!e->IsEmpty());

743 }

744 return -1;

745 }

746

747

748 // Add a new value to the HashSet table, under the specified key.

749 template<class CRef>

750 void add(const CRef& key, size_t hashValue)

751 {

752 CheckExpand();

753 hashValue &= pTable->SizeMask;

754

755 pTable->EntryCount++;

756

757 intptr_t index = hashValue;

758 Entry* naturalEntry = &(E(index));

759

760 if (naturalEntry->IsEmpty())

761 {

762 // Put the new Entry in.

763 new (naturalEntry) Entry(key, -1);

764 }

765 else

766 {

767 // Find a blank spot.

768 intptr_t blankIndex = index;

769 do {

770 blankIndex = (blankIndex + 1) & pTable->SizeMask;

771 } while(!E(blankIndex).IsEmpty());

772

773 Entry* blankEntry = &E(blankIndex);

774

775 if (naturalEntry->GetCachedHash(pTable->SizeMask) == (size_t)index)

776 {

777 // Collision. Link into this chain.

778

779 // Move existing list head.

780 new (blankEntry) Entry(*naturalEntry); // placement new, copy ctor

781

782 // Put the new info in the natural Entry.

783 naturalEntry->Value = key;

784 naturalEntry->NextInChain = blankIndex;

785 }

786 else

787 {

788 // Existing Entry does not naturally

789 // belong in this slot. Existing

790 // Entry must be moved.

791

792 // Find natural location of collided element (i.e. root of chain)

793 intptr_t collidedIndex = naturalEntry->GetCachedHash(pTable->SizeMask);

794 OVR_ASSERT(collidedIndex >= 0 && collidedIndex <= (intptr_t)pTable->SizeMask);

795 for (;;)

796 {

797 Entry* e = &E(collidedIndex);

798 if (e->NextInChain == index)

799 {

800 // Here's where we need to splice.

801 new (blankEntry) Entry(*naturalEntry);

802 e->NextInChain = blankIndex;

803 break;

804 }

805 collidedIndex = e->NextInChain;

806 OVR_ASSERT(collidedIndex >= 0 && collidedIndex <= (intptr_t)pTable->SizeMask);

807 }

808

809 // Put the new data in the natural Entry.

810 naturalEntry->Value = key;

811 naturalEntry->NextInChain = -1;

812 }

813 }

814

815 // Record hash value: has effect only if cached node is used.

816 naturalEntry->SetCachedHash(hashValue);

817 }

818

819 // Index access helpers.

820 Entry& E(size_t index)

821 {

822 // Must have pTable and access needs to be within bounds.

823 OVR_ASSERT(index <= pTable->SizeMask);

824 return *(((Entry*) (pTable + 1)) + index);

825 }

826 const Entry& E(size_t index) const

827 {

828 OVR_ASSERT(index <= pTable->SizeMask);

829 return *(((Entry*) (pTable + 1)) + index);

830 }

831

832

833 // Resize the HashSet table to the given size (Rehash the

834 // contents of the current table). The arg is the number of

835 // HashSet table entries, not the number of elements we should

836 // actually contain (which will be less than this).

837 void setRawCapacity(size_t newSize)

838 {

839 if (newSize == 0)

840 {

841 // Special case.

842 Clear();

843 return;

844 }

845

846 // Minimum size; don't incur rehashing cost when expanding

847 // very small tables. Not that we perform this check before

848 // 'log2f' call to avoid fp exception with newSize == 1.

849 if (newSize < HashMinSize)

850 newSize = HashMinSize;

851 else

852 {

853 // Force newSize to be a power of two.

854 int bits = Alg::UpperBit(newSize-1) + 1; // Chop( Log2f((float)(newSize-1)) + 1);

855 OVR_ASSERT((size_t(1) << bits) >= newSize);

856 newSize = size_t(1) << bits;

857 }

858

859 SelfType newHash;

860 newHash.pTable = (TableType*)

861 Allocator::Alloc(

862 sizeof(TableType) + sizeof(Entry) * newSize);

863 // Need to do something on alloc failure!

864 OVR_ASSERT(newHash.pTable);

865

866 newHash.pTable->EntryCount = 0;

867 newHash.pTable->SizeMask = newSize - 1;

868 size_t i, n;

869

870 // Mark all entries as empty.

871 for (i = 0; i < newSize; i++)

872 newHash.E(i).NextInChain = -2;

873

874 // Copy stuff to newHash

875 if (pTable)

876 {

877 for (i = 0, n = pTable->SizeMask; i <= n; i++)

878 {

879 Entry* e = &E(i);

880 if (e->IsEmpty() == false)

881 {

882 // Insert old Entry into new HashSet.

883 newHash.Add(e->Value);

884 // placement delete of old element

885 e->Clear();

886 }

887 }

888

889 // Delete our old data buffer.

890 Allocator::Free(pTable);

891 }

892

893 // Steal newHash's data.

894 pTable = newHash.pTable;

895 newHash.pTable = NULL;

896 }

897

898 struct TableType

899 {

900 size_t EntryCount;

901 size_t SizeMask;

902 // Entry array follows this structure

903 // in memory.

904 };

905 TableType* pTable;

906 };

907

908

909

910 //-----------------------------------------------------------------------------------

911 template<class C, class HashF = FixedSizeHash<C>,

912 class AltHashF = HashF,

913 class Allocator = ContainerAllocator<C>,

914 class Entry = HashsetCachedEntry<C, HashF> >

915 class HashSet : public HashSetBase<C, HashF, AltHashF, Allocator, Entry>

916 {

917 public:

918 typedef HashSetBase<C, HashF, AltHashF, Allocator, Entry> BaseType;

919 typedef HashSet<C, HashF, AltHashF, Allocator, Entry> SelfType;

920

921 HashSet() { }

922 HashSet(int sizeHint) : BaseType(sizeHint) { }

923 HashSet(const SelfType& src) : BaseType(src) { }

924 ~HashSet() { }

925

926 void operator = (const SelfType& src) { BaseType::Assign(src); }

927

928 // Set a new or existing value under the key, to the value.

929 // Pass a different class of 'key' so that assignment reference object

930 // can be passed instead of the actual object.

931 template<class CRef>

932 void Set(const CRef& key)

933 {

934 BaseType::Set(key);

935 }

936

937 template<class CRef>

938 inline void Add(const CRef& key)

939 {

940 BaseType::Add(key);

941 }

942

943 // Hint the bucket count to >= n.

944 void Resize(size_t n)

945 {

946 BaseType::SetCapacity(n);

947 }

948

949 // Size the HashSet so that it can comfortably contain the given

950 // number of elements. If the HashSet already contains more

951 // elements than newSize, then this may be a no-op.

952 void SetCapacity(size_t newSize)

953 {

954 BaseType::SetCapacity(newSize);

955 }

956

957 };

958

959 // HashSet with uncached hash code; declared for convenience.

960 template<class C, class HashF = FixedSizeHash<C>,

961 class AltHashF = HashF,

962 class Allocator = ContainerAllocator<C> >

963 class HashSetUncached : public HashSet<C, HashF, AltHashF, Allocator, HashsetEntry<C, HashF> >

964 {

965 public:

966

967 typedef HashSetUncached<C, HashF, AltHashF, Allocator> SelfType;

968 typedef HashSet<C, HashF, AltHashF, Allocator, HashsetEntry<C, HashF> > BaseType;

969

970 // Delegated constructors.

971 HashSetUncached() { }

972 HashSetUncached(int sizeHint) : BaseType(sizeHint) { }

973 HashSetUncached(const SelfType& src) : BaseType(src) { }

974 ~HashSetUncached() { }

975

976 void operator = (const SelfType& src)

977 {

978 BaseType::operator = (src);

979 }

980 };

981

982

983 //-----------------------------------------------------------------------------------

984 // ***** Hash hash table implementation

985

986 // Node for Hash - necessary so that Hash can delegate its implementation

987 // to HashSet.

988 template<class C, class U, class HashF>

989 struct HashNode

990 {

991 typedef HashNode<C, U, HashF> SelfType;

992 typedef C FirstType;

993 typedef U SecondType;

994

995 C First;

996 U Second;

997

998 // NodeRef is used to allow passing of elements into HashSet

999 // without using a temporary object.

1000 struct NodeRef

1001 {

1002 const C* pFirst;

1003 const U* pSecond;

1004

1005 NodeRef(const C& f, const U& s) : pFirst(&f), pSecond(&s) { }

1006 NodeRef(const NodeRef& src) : pFirst(src.pFirst), pSecond(src.pSecond) { }

1007

1008 // Enable computation of ghash_node_hashf.

1009 inline size_t GetHash() const { return HashF()(*pFirst); }

1010 // Necessary conversion to allow HashNode::operator == to work.

1011 operator const C& () const { return *pFirst; }

1012 };

1013

1014 // Note: No default constructor is necessary.

1015 HashNode(const HashNode& src) : First(src.First), Second(src.Second) { }

1016 HashNode(const NodeRef& src) : First(*src.pFirst), Second(*src.pSecond) { }

1017 void operator = (const NodeRef& src) { First = *src.pFirst; Second = *src.pSecond; }

1018

1019 template<class K>

1020 bool operator == (const K& src) const { return (First == src); }

1021

1022 template<class K>

1023 static size_t CalcHash(const K& data) { return HashF()(data); }

1024 inline size_t GetHash() const { return HashF()(First); }

1025

1026 // Hash functors used with this node. A separate functor is used for alternative

1027 // key lookup so that it does not need to access the '.First' element.

1028 struct NodeHashF

1029 {

1030 template<class K>

1031 size_t operator()(const K& data) const { return data.GetHash(); }

1032 };

1033 struct NodeAltHashF

1034 {

1035 template<class K>

1036 size_t operator()(const K& data) const { return HashNode<C,U,HashF>::CalcHash(data); }

1037 };

1038 };

1039

1040

1041

1042 // **** Extra hashset_entry types to allow NodeRef construction.

1043

1044 // The big difference between the below types and the ones used in hash_set is that

1045 // these allow initializing the node with 'typename C::NodeRef& keyRef', which

1046 // is critical to avoid temporary node allocation on stack when using placement new.

1047

1048 // Compact hash table Entry type that re-computes hash keys during hash traversal.

1049 // Good to use if the hash function is cheap or the hash value is already cached in C.

1050 template<class C, class HashF>

1051 class HashsetNodeEntry

1052 {

1053 public:

1054 // Internal chaining for collisions.

1055 intptr_t NextInChain;

1056 C Value;

1057

1058 HashsetNodeEntry()

1059 : NextInChain(-2) { }

1060 HashsetNodeEntry(const HashsetNodeEntry& e)

1061 : NextInChain(e.NextInChain), Value(e.Value) { }

1062 HashsetNodeEntry(const C& key, intptr_t next)

1063 : NextInChain(next), Value(key) { }

1064 HashsetNodeEntry(const typename C::NodeRef& keyRef, intptr_t next)

1065 : NextInChain(next), Value(keyRef) { }

1066

1067 bool IsEmpty() const { return NextInChain == -2; }

1068 bool IsEndOfChain() const { return NextInChain == -1; }

1069 size_t GetCachedHash(size_t maskValue) const { return HashF()(Value) & maskValue; }

1070 void SetCachedHash(size_t hashValue) { OVR_UNUSED(hashValue); }

1071

1072 void Clear()

1073 {

1074 Value.~C(); // placement delete

1075 NextInChain = -2;

1076 }

1077 // Free is only used from dtor of hash; Clear is used during regular operations:

1078 // assignment, hash reallocations, value reassignments, so on.

1079 void Free() { Clear(); }

1080 };

1081

1082 // Hash table Entry type that caches the Entry hash value for nodes, so that it

1083 // does not need to be re-computed during access.

1084 template<class C, class HashF>

1085 class HashsetCachedNodeEntry

1086 {

1087 public:

1088 // Internal chaining for collisions.

1089 intptr_t NextInChain;

1090 size_t HashValue;

1091 C Value;

1092

1093 HashsetCachedNodeEntry()

1094 : NextInChain(-2) { }

1095 HashsetCachedNodeEntry(const HashsetCachedNodeEntry& e)

1096 : NextInChain(e.NextInChain), HashValue(e.HashValue), Value(e.Value) { }

1097 HashsetCachedNodeEntry(const C& key, intptr_t next)

1098 : NextInChain(next), Value(key) { }

1099 HashsetCachedNodeEntry(const typename C::NodeRef& keyRef, intptr_t next)

1100 : NextInChain(next), Value(keyRef) { }

1101

1102 bool IsEmpty() const { return NextInChain == -2; }

1103 bool IsEndOfChain() const { return NextInChain == -1; }

1104 size_t GetCachedHash(size_t maskValue) const { OVR_UNUSED(maskValue); return HashValue; }

1105 void SetCachedHash(size_t hashValue) { HashValue = hashValue; }

1106

1107 void Clear()

1108 {

1109 Value.~C();

1110 NextInChain = -2;

1111 }

1112 // Free is only used from dtor of hash; Clear is used during regular operations:

1113 // assignment, hash reallocations, value reassignments, so on.

1114 void Free() { Clear(); }

1115 };

1116

1117

1118 //-----------------------------------------------------------------------------------

1119 template<class C, class U,

1120 class HashF = FixedSizeHash<C>,

1121 class Allocator = ContainerAllocator<C>,

1122 class HashNode = OVR::HashNode<C,U,HashF>,

1123 class Entry = HashsetCachedNodeEntry<HashNode, typename HashNode::NodeHashF>,

1124 class Container = HashSet<HashNode, typename HashNode::NodeHashF,

1125 typename HashNode::NodeAltHashF, Allocator,

1126 Entry> >

1127 class Hash

1128 {

1129 public:

1130 OVR_MEMORY_REDEFINE_NEW(Hash)

1131

1132 // Types used for hash_set.

1133 typedef U ValueType;

1134 typedef Hash<C, U, HashF, Allocator, HashNode, Entry, Container> SelfType;

1135

1136 // Actual hash table itself, implemented as hash_set.

1137 Container mHash;

1138

1139 public:

1140 Hash() { }

1141 Hash(int sizeHint) : mHash(sizeHint) { }

1142 Hash(const SelfType& src) : mHash(src.mHash) { }

1143 ~Hash() { }

1144

1145 void operator = (const SelfType& src) { mHash = src.mHash; }

1146

1147 // Remove all entries from the Hash table.

1148 inline void Clear() { mHash.Clear(); }

1149 // Returns true if the Hash is empty.

1150 inline bool IsEmpty() const { return mHash.IsEmpty(); }

1151

1152 // Access (set).

1153 inline void Set(const C& key, const U& value)

1154 {

1155 typename HashNode::NodeRef e(key, value);

1156 mHash.Set(e);

1157 }

1158 inline void Add(const C& key, const U& value)

1159 {

1160 typename HashNode::NodeRef e(key, value);

1161 mHash.Add(e);

1162 }

1163

1164 // Removes an element by clearing its Entry.

1165 inline void Remove(const C& key)

1166 {

1167 mHash.RemoveAlt(key);

1168 }

1169 template<class K>

1170 inline void RemoveAlt(const K& key)

1171 {

1172 mHash.RemoveAlt(key);

1173 }

1174

1175 // Retrieve the value under the given key.

1176 // - If there's no value under the key, then return false and leave *pvalue alone.

1177 // - If there is a value, return true, and Set *Pvalue to the Entry's value.

1178 // - If value == NULL, return true or false according to the presence of the key.

1179 bool Get(const C& key, U* pvalue) const

1180 {

1181 const HashNode* p = mHash.GetAlt(key);

1182 if (p)

1183 {

1184 if (pvalue)

1185 *pvalue = p->Second;

1186 return true;

1187 }

1188 return false;

1189 }

1190

1191 template<class K>

1192 bool GetAlt(const K& key, U* pvalue) const

1193 {

1194 const HashNode* p = mHash.GetAlt(key);

1195 if (p)

1196 {

1197 if (pvalue)

1198 *pvalue = p->Second;

1199 return true;

1200 }

1201 return false;

1202 }

1203

1204 // Retrieve the pointer to a value under the given key.

1205 // - If there's no value under the key, then return NULL.

1206 // - If there is a value, return the pointer.

1207 inline U* Get(const C& key)

1208 {

1209 HashNode* p = mHash.GetAlt(key);

1210 return p ? &p->Second : 0;

1211 }

1212 inline const U* Get(const C& key) const

1213 {

1214 const HashNode* p = mHash.GetAlt(key);

1215 return p ? &p->Second : 0;

1216 }

1217

1218 template<class K>

1219 inline U* GetAlt(const K& key)

1220 {

1221 HashNode* p = mHash.GetAlt(key);

1222 return p ? &p->Second : 0;

1223 }

1224 template<class K>

1225 inline const U* GetAlt(const K& key) const

1226 {

1227 const HashNode* p = mHash.GetAlt(key);

1228 return p ? &p->Second : 0;

1229 }

1230

1231 // Sizing methods - delegate to Hash.

1232 inline size_t GetSize() const { return mHash.GetSize(); }

1233 inline int GetSizeI() const { return (int)GetSize(); }

1234 inline void Resize(size_t n) { mHash.Resize(n); }

1235 inline void SetCapacity(size_t newSize) { mHash.SetCapacity(newSize); }

1236

1237 // Iterator API, like STL.

1238 typedef typename Container::ConstIterator ConstIterator;

1239 typedef typename Container::Iterator Iterator;

1240

1241 inline Iterator Begin() { return mHash.Begin(); }

1242 inline Iterator End() { return mHash.End(); }

1243 inline ConstIterator Begin() const { return mHash.Begin(); }

1244 inline ConstIterator End() const { return mHash.End(); }

1245

1246 Iterator Find(const C& key) { return mHash.FindAlt(key); }

1247 ConstIterator Find(const C& key) const { return mHash.FindAlt(key); }

1248

1249 template<class K>

1250 Iterator FindAlt(const K& key) { return mHash.FindAlt(key); }

1251 template<class K>

1252 ConstIterator FindAlt(const K& key) const { return mHash.FindAlt(key); }

1253 };

1254

1255

1256

1257 // Hash with uncached hash code; declared for convenience.

1258 template<class C, class U, class HashF = FixedSizeHash<C>, class Allocator = ContainerAllocator<C> >

1259 class HashUncached

1260 : public Hash<C, U, HashF, Allocator, HashNode<C,U,HashF>,

1261 HashsetNodeEntry<HashNode<C,U,HashF>, typename HashNode<C,U,HashF>::NodeHashF> >

1262 {

1263 public:

1264 typedef HashUncached<C, U, HashF, Allocator> SelfType;

1265 typedef Hash<C, U, HashF, Allocator, HashNode<C,U,HashF>,

1266 HashsetNodeEntry<HashNode<C,U,HashF>,

1267 typename HashNode<C,U,HashF>::NodeHashF> > BaseType;

1268

1269 // Delegated constructors.

1270 HashUncached() { }

1271 HashUncached(int sizeHint) : BaseType(sizeHint) { }

1272 HashUncached(const SelfType& src) : BaseType(src) { }

1273 ~HashUncached() { }

1274 void operator = (const SelfType& src) { BaseType::operator = (src); }

1275 };

1276

1277

1278

1279 // And identity hash in which keys serve as hash value. Can be uncached,

1280 // since hash computation is assumed cheap.

1281 template<class C, class U, class Allocator = ContainerAllocator<C>, class HashF = IdentityHash<C> >

1282 class HashIdentity

1283 : public HashUncached<C, U, HashF, Allocator>

1284 {

1285 public:

1286 typedef HashIdentity<C, U, Allocator, HashF> SelfType;

1287 typedef HashUncached<C, U, HashF, Allocator> BaseType;

1288

1289 // Delegated constructors.

1290 HashIdentity() { }

1291 HashIdentity(int sizeHint) : BaseType(sizeHint) { }

1292 HashIdentity(const SelfType& src) : BaseType(src) { }

1293 ~HashIdentity() { }

1294 void operator = (const SelfType& src) { BaseType::operator = (src); }

1295 };

1296

1297

1298 } // OVR

1299

1300

1301 #ifdef OVR_DEFINE_NEW

1302 #define new OVR_DEFINE_NEW

1303 #endif

1304

1305 #endif