hash_type VectorRecord::hash() const { if (!mDataPtr) return hash_type(); return mDataPtr->hash() + hash_type(mSize, mOffset, mStride); }
void Serializer<PolymorphicSharedPtr<SerializedObject>, HashingStreamSerializer>::serialize( HashingStreamSerializer& s, const PolymorphicSharedPtr<SerializedObject>& in ) { if (!in) s.serialize(hash_type(0)); else { s.serialize(hash_type(1)); s.serialize(in->hash()); } }
void TAO_Service_Type_Repository:: validate_supertypes (Service_Type_Map &super_map, const CosTradingRepos::ServiceTypeRepository::ServiceTypeNameSeq &super_types) { for (CORBA::ULong i = 0; i < super_types.length (); i++) { const char *type = super_types[i]; if (TAO_Trader_Base::is_valid_identifier_name (type) == 0) throw CosTrading::IllegalServiceType (type); else { CORBA::String_var hash_type (type); Service_Type_Map::ENTRY *type_entry = 0; if (this->type_map_.find (hash_type, type_entry) == -1) throw CosTrading::UnknownServiceType (type); else { if (super_map.bind (hash_type, type_entry->int_id_) == 1) throw CosTradingRepos::ServiceTypeRepository::DuplicateServiceTypeName ( type); } } } }
inline std::size_t hash_float(Float_type const& t) { std::size_t h = hash_type(t); boost::hash_combine(h, t.precision()); return h; }
inline std::size_t hash_value(Placeholder_id const& n) { std::size_t h = hash_type(n); boost::hash_combine(h, n.number()); return h; }
std::size_t hash_value(Predicate_cons const& c) { std::size_t h = hash_type(c); boost::hash_combine(h, c.expression()); return h; }
std::size_t hash_parm(Type_parm const& d) { std::size_t h = hash_type(d); boost::hash_combine(h, d.index()); return h; }
hash_type VectorRecord::vectorHandleHash() const { if (!mDataPtr) return hash_type(); return mDataPtr->hash(); }
std::size_t hash_value(Unary_expr const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.operand()); return h; }
// The hash value of a user-defined type is that of its declaration. inline std::size_t hash_declared_type(Declared_type const& t) { std::size_t h = hash_type(t); boost::hash_combine(h, t.declaration()); return h; }
inline std::size_t hash_value(Operator_id const& n) { std::size_t h = hash_type(n); boost::hash_combine(h, n.kind()); return h; }
std::size_t hash_value(Decl_expr const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.declaration()); return h; }
std::size_t hash_value(Id_expr const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.id()); return h; }
std::size_t hash_value(Literal_expr<T> const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.value()); return h; }
inline std::size_t hash_value(Simple_id const& n) { std::size_t h = hash_type(n); boost::hash_combine(h, &n.symbol()); return h; }
std::size_t hash_value(Binary_cons const& c) { std::size_t h = hash_type(c); boost::hash_combine(h, c.left()); boost::hash_combine(h, c.right()); return h; }
std::size_t hash_parm(Parameterized_cons const& c) { std::size_t h = hash_type(c); boost::hash_combine(h, c.variables()); boost::hash_combine(h, c.constraint()); return h; }
std::size_t hash_usage(T const& c) { std::size_t h = hash_type(c); boost::hash_combine(h, c.expression()); boost::hash_combine(h, c.type()); return h; }
inline std::size_t hash_integer(Integer_type const& t) { std::size_t h = hash_type(t); boost::hash_combine(h, t.sign()); boost::hash_combine(h, t.precision()); return h; }
std::size_t hash_conv(Conv const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.destination()); boost::hash_combine(h, e.source()); return h; }
std::size_t hash_value(Binary_expr const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.left()); boost::hash_combine(h, e.right()); return h; }
inline std::size_t hash_function_type(Function_type const& t) { std::size_t h = hash_type(t); boost::hash_combine(h, t.parameter_types()); boost::hash_combine(h, t.return_type()); return h; }
std::size_t hash_value(Call_expr const& e) { std::size_t h = hash_type(e); boost::hash_combine(h, e.function()); boost::hash_combine(h, e.arguments()); return h; }
std::size_t hash_value(Concept_cons const& c) { std::size_t h = hash_type(c); boost::hash_combine(h, c.declaration()); boost::hash_combine(h, c.arguments()); return h; }
VectorRecord VectorRecord::concatenate( const VectorRecord& inLHS, const VectorRecord& inRHS, MemoryPool* inPool, VectorDataManager* inVDM, hash_type inVectorHash ) { if (!inLHS) return inRHS; if (!inRHS) return inLHS; if (!inLHS.isCanonicallySliced()) return concatenate( inLHS.canonicallySliced(inPool, inVDM, inVectorHash + hash_type(0, 1, 0)), inRHS, inPool, inVDM, inVectorHash ); if (!inRHS.isCanonicallySliced()) return concatenate( inLHS, inRHS.canonicallySliced(inPool, inVDM, inVectorHash + hash_type(0, 2, 0)), inPool, inVDM, inVectorHash ); return VectorRecord( VectorHandle::concatenate( inLHS.mDataPtr, inLHS.mSize, inRHS.mDataPtr, inRHS.mSize, inPool, inVDM, inVectorHash ) ); }
VectorHandlePtr newUnpagedHandle(int64_t index, int64_t valueCount) { ForaValueArray* array = ForaValueArray::Empty(&memoryPool); for (int64_t k = 0; k < valueCount; k++) array->append(ImplValContainer(CSTValue((int64_t)k))); return memoryPool.construct<VectorHandle>( Fora::BigVectorId(), Fora::PageletTreePtr(), array, &memoryPool, hash_type(index) ); }
VectorHandlePtr newPagedHandle(int64_t index, ImmutableTreeVector<int64_t> pageSizes) { BigVectorPageLayout layout = mBigVecTestFixture.getLayout(pageSizes); mPagedHandles->registerNewLayout(layout); VectorHandle* result = memoryPool.construct<VectorHandle>( layout.identity(), Fora::PageletTreePtr(), (ForaValueArray*)0, &memoryPool, hash_type(index) ); //result->associatePagedValues(mPagedHandles->getHandle(layout.identity())); return result; }
hash_type SerializedObject::hash(void) const { if (!mHash) { hash_type h = (mSerializedData ? hashValue(*mSerializedData) : hash_type()); h = h + hashValue(mTypesReferenced); h = h + hashValue(mJovsReferenced); h = h + hashValue(mExpressionsReferenced); h = h + hashValue(mControlFlowGraphsReferenced); h = h + mMemoStorage.hash(); mHash = h; } return *mHash; }
typename hash_table<T, Hash, Equals, Allocator>::size_type hash_table<T, Hash, Equals, Allocator>:: hash(const_reference x) { return hash_type()(x); }
hash_type ArbitraryNativeConstantForCSTValue::hash() { return hash_type(mAsImplval ? 1 : 0) + mValue.hash(); }