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();
}
