void AggregationVisualizerNode::expand(VariableNode* a_pVariableNode, const vector<reflection::Expression*>& a_LeftExpressions) const
{
a_pVariableNode->setDelegate(o_new(AggregationVariableNodeDelegate));
vector<vector<reflection::Expression*>> groupedVariables;
for(size_t i = 0; i<a_LeftExpressions.size(); ++i)
{
reflection::Expression* pLeftExpression = a_LeftExpressions[i];
reflection::AggregationClass* pAggregationClass = as<reflection::AggregationClass*>(pLeftExpression->getValueType()->removeReference());
o_assert(pAggregationClass);
vector<reflection::Expression*> signature;
reflection::Expression* pSizeExpression = cplusplus()->qualifiedLookup(pLeftExpression->clone(), "count", nullptr, &signature)->asExpression();
bool ok;
size_t count = pSizeExpression->get().as<size_t>(&ok);
o_assert(ok);
groupedVariables.resize(std::max(groupedVariables.size(), count));
for(size_t i = 0; i<count; ++i)
{
reflection::Expression* pIndexExpression = o_new(reflection::ConstantExpression)(constant<size_t>(i));
reflection::Expression* pExpression = cplusplus()->solveBinaryOperator("[]", pLeftExpression->clone(), pIndexExpression);
o_assert(pExpression);
groupedVariables[i].push_back(pExpression);
}
o_dynamic_delete pSizeExpression;
}
size_t i = 0;
for(;i<groupedVariables.size(); ++i)
{
VariableNode* pChild = o_new(VariableNode)(lexical_cast<string>(i), groupedVariables[i]);
pChild->setDelegate(o_new(AggregationAggregateVariableNodeDelegate)(i, groupedVariables.size()));
a_pVariableNode->addChildNode(pChild);
}
}
void ClassTypeVisualizerNode::expand( VariableNode* a_pParentNode, const vector<reflection::Expression*>& a_LeftExpressions, reflection::ClassType* a_pClassType) const
{
// Public Value Members (Properties and InstanceAttributes
{
auto it = a_pClassType->beginValueMembers();
auto end = a_pClassType->endValueMembers();
for(;it != end;++it)
{
reflection::ValueMember* pValueMember = *it;
if(!m_Filter(a_pParentNode, pValueMember))
continue;
vector<reflection::Expression*> expressions;
for(auto it = a_LeftExpressions.begin(); it != a_LeftExpressions.end(); ++it)
{
reflection::Expression* pLeftExpression = *it;
expressions.push_back(cplusplus()->qualifiedLookup(pLeftExpression->clone(), pValueMember->getName(), nullptr, nullptr, 0)->asExpression());
}
VariableNode* pVariableNode = o_new(VariableNode)(nameOf(pValueMember), expressions);
pVariableNode->setIcon(QIcon(iconOf(pValueMember).c_str()));
pVariableNode->setRange(pValueMember->getRange());
pVariableNode->setModifiers(pValueMember->getModifiers());
a_pParentNode->addChildNode(pVariableNode);
}
}
}
void FlagsVisualizerNode::expand( VariableNode* a_pParent, const vector<reflection::Expression*>& a_LeftExpressions ) const
{
map<reflection::Constant*, vector<reflection::Expression*>> flagsExpressions;
for(auto it = a_LeftExpressions.begin(); it != a_LeftExpressions.end(); ++it)
{
reflection::Expression* pLeftExpression = *it;
if(NOT(pLeftExpression->hasEffectiveAddress())) continue;
reflection::Enum* pEnum = pLeftExpression->getValueType()->removeReference()->removeConst()->getOwner()->asTemplateSpecialization()->getArgument("Enum")->asEnum();
for(size_t i = 0; i<pEnum->getConstantCount(); ++i)
{
flagsExpressions[pEnum->getConstant(i)].push_back(
cplusplus()->qualifiedLookup(
cplusplus()->solveBinaryOperator("[]", pLeftExpression->clone(), o_new(reflection::ConstantExpression)(pEnum->getConstant(i)))
, "value", nullptr, nullptr, 0)->asExpression()
);
}
}
for(auto it = flagsExpressions.begin(); it != flagsExpressions.end(); ++it)
{
VariableNode* pNode = o_new(VariableNode)(nameOf(it->first), it->second);
pNode->setIcon(QIcon(iconOf(it->first).c_str()));
a_pParent->addChildNode(pNode);
}
}
void BuiltInOperator::implicitConversions( Type** a_ppTypes, vector<conversions>& a_Conversions, vector<overload>& a_Overloads ) const
{
Language* pLanguage = cplusplus();
vector<overload> extraOverloads;
for(size_t i = 0; i<m_uiOperandCount; ++i)
fetchExtraOverloads(a_ppTypes[i], extraOverloads);
a_Conversions.resize(extraOverloads.size()+m_Overloads.size());
for(size_t i = 0; i<extraOverloads.size(); ++i)
{
conversions& conv = a_Conversions[i];
extraOverloads[i].implicitConversions(pLanguage, a_ppTypes, conv);
a_Overloads.push_back(extraOverloads[i]);
}
for(size_t i = 0; i<m_Overloads.size(); ++i)
{
conversions& conv = a_Conversions[i];
m_Overloads[i].implicitConversions(pLanguage, a_ppTypes, conv);
a_Overloads.push_back(m_Overloads[i]);
}
}
void UmlRelation::import(UmlRelation::Role * role) {
if (!role->doc.isEmpty())
set_Description(role->doc);
if (! role->cardinality.isEmpty())
set_Multiplicity(role->cardinality);
if (role->is_static)
set_isClassMember(TRUE);
if (!role->name.isEmpty())
set_RoleName(role->name);
set_Visibility(role->visibility);
switch (((UmlClass *) parent())->language()) {
case Cplusplus:
case AnsiCplusplus:
case VCplusplus:
cplusplus(role);
break;
case Oracle8:
oracle8(role);
break;
case Corba:
corba(role);
break;
case Java:
java(role);
break;
default:
break;
}
setProperties(role->prop);
}
