void FunctionType::exchangeTypes( TypeExchanger* exchanger )
{
TYPE_D_DYNAMIC(FunctionType);
for (uint i = 0; i < d->m_argumentsSize (); ++i)
d->m_argumentsList()[i] = IndexedType(exchanger->exchange(d->m_arguments()[i].abstractType()));
d->m_returnType = IndexedType(exchanger->exchange(d->m_returnType.abstractType()));
}
inline void create_map(TurnPoints const& turn_points, MappedVector& mapped_vector)
{
typedef typename boost::range_value<TurnPoints>::type turn_point_type;
typedef typename turn_point_type::container_type container_type;
int index = 0;
for (typename boost::range_iterator<TurnPoints const>::type
it = boost::begin(turn_points);
it != boost::end(turn_points);
++it, ++index)
{
// Add operations on this ring, but skip discarded ones
if (! it->discarded)
{
int op_index = 0;
for (typename boost::range_iterator<container_type const>::type
op_it = boost::begin(it->operations);
op_it != boost::end(it->operations);
++op_it, ++op_index)
{
// We should NOT skip blocked operations here
// because they can be relevant for "the other side"
// NOT if (op_it->operation != operation_blocked)
ring_identifier ring_id
(
op_it->seg_id.source_index,
op_it->seg_id.multi_index,
op_it->seg_id.ring_index
);
mapped_vector[ring_id].push_back
(
IndexedType(index, op_index, *op_it)
);
}
}
}
}
std::string Name()
{
return "[" + IndexedType().Name();
}
void FunctionType::setReturnType(AbstractType::Ptr returnType)
{
d_func_dynamic()->m_returnType = IndexedType(returnType);
}
void PointerType::setBaseType(AbstractType::Ptr type)
{
d_func_dynamic()->m_baseType = IndexedType(type);
}
void PointerType::exchangeTypes( TypeExchanger* exchanger ) {
d_func_dynamic()->m_baseType = IndexedType(exchanger->exchange( d_func()->m_baseType.abstractType()));
}
