Type Type::resolveOnSuperArgumentsAndConstraints(const TypeContext &typeContext) const {
if (typeContext.calleeType().type() == TypeType::NoReturn) {
return *this;
}
TypeDefinition *c = typeContext.calleeType().typeDefinition();
Type t = *this;
if (type() == TypeType::NoReturn) {
return t;
}
bool optional = t.optional();
bool box = t.storageType() == StorageType::Box;
// Try to resolve on the generic arguments to the superclass.
while (t.type() == TypeType::GenericVariable && t.genericVariableIndex() < c->superGenericArguments().size()) {
t = c->superGenericArguments()[t.genericArgumentIndex_];
}
while (t.type() == TypeType::LocalGenericVariable && typeContext.function() == t.localResolutionConstraint_) {
t = typeContext.function()->constraintForIndex(t.genericArgumentIndex_);
}
while (t.type() == TypeType::GenericVariable
&& typeContext.calleeType().typeDefinition()->canBeUsedToResolve(t.typeDefinition())) {
t = typeContext.calleeType().typeDefinition()->constraintForIndex(t.genericArgumentIndex_);
}
if (optional) {
t.setOptional();
}
if (box) {
t.forceBox_ = true;
}
return t;
}
TypeDefinition* newPoly_PortType()
{
PortType* pPortTypeObj = NULL;
TypeDefinition* pObj = new_TypeDefinition();
/* Allocating memory */
pPortTypeObj = (PortType*)malloc(sizeof(PortType));
if (pPortTypeObj == NULL)
{
pObj->Delete(pObj);
return NULL;
}
pObj->pDerivedObj = pPortTypeObj; /* Pointing to derived object */
pPortTypeObj->super = pObj;
pPortTypeObj->synchrone = -1;
pObj->super->metaClassName = PortType_metaClassName;
pObj->internalGetKey = PortType_internalGetKey;
pObj->VisitAttributes = PortType_VisitAttributes;
pObj->VisitPathAttributes = PortType_VisitPathAttributes;
pObj->VisitReferences = TypeDefinition_VisitReferences;
pObj->VisitPathReferences = TypeDefinition_VisitPathReferences;
pObj->FindByPath = PortType_FindByPath;
pObj->Delete = deletePoly_PortType;
return pObj;
}
TypeDefinition* newPoly_NodeType()
{
NodeType* pNodeTypeObj = NULL;
TypeDefinition* pObj = new_TypeDefinition();
/* Allocating memory */
pNodeTypeObj = (NodeType*)malloc(sizeof(NodeType));
if (pNodeTypeObj == NULL)
{
pObj->Delete(pObj);
return NULL;
}
pObj->pDerivedObj = pNodeTypeObj; /* Pointing to derived object */
pObj->MetaClassName = NodeType_MetaClassName;
pObj->InternalGetKey = NodeType_InternalGetKey;
pObj->VisitAttributes = NodeType_VisitAttributes;
pObj->VisitReferences = TypeDefinition_VisitReferences;
pObj->Delete = deletePoly_NodeType;
return pObj;
}
TypeDefinition* newPoly_ComponentType(void)
{
ComponentType* pCompTypeObj = NULL;
TypeDefinition* pObj = new_TypeDefinition();
if(pObj == NULL)
return NULL;
/* Allocating memory */
pCompTypeObj = (ComponentType*)malloc(sizeof(ComponentType));
if (pCompTypeObj == NULL)
{
pObj->Delete(pObj);
return NULL;
}
pObj->pDerivedObj = pCompTypeObj; /* Pointing to derived object */
pCompTypeObj->super = pObj;
pCompTypeObj->eContainer = NULL;
pCompTypeObj->path = NULL;
pCompTypeObj->refs = NULL;
pCompTypeObj->required = NULL;
pCompTypeObj->provided = NULL;
pCompTypeObj->FindRequiredByID = ComponentType_FindRequiredByID;
pCompTypeObj->FindProvidedByID = ComponentType_FindProvidedByID;
pCompTypeObj->AddRequired = ComponentType_AddRequired;
pCompTypeObj->AddProvided = ComponentType_AddProvided;
pCompTypeObj->RemoveRequired = ComponentType_RemoveRequired;
pCompTypeObj->RemoveProvided = ComponentType_RemoveProvided;
pCompTypeObj->metaClassName = ComponentType_metaClassName;
pCompTypeObj->internalGetKey = ComponentType_internalGetKey;
pCompTypeObj->VisitAttributes = ComponentType_VisitAttributes;
pCompTypeObj->VisitPathAttributes = ComponentType_VisitPathAttributes;
pCompTypeObj->VisitReferences = ComponentType_VisitReferences;
pCompTypeObj->VisitPathReferences = ComponentType_VisitPathReferences;
pObj->super->metaClassName = ComponentType_metaClassName;
pObj->internalGetKey = ComponentType_internalGetKey;
pObj->VisitAttributes = ComponentType_VisitAttributes;
pObj->VisitReferences = ComponentType_VisitReferences;
pObj->FindByPath = ComponentType_FindByPath;
pObj->Delete = deletePoly_ComponentType;
return pObj;
}
Type Type::resolveReferenceToBaseReferenceOnSuperArguments(const TypeContext &typeContext) const {
TypeDefinition *c = typeContext.calleeType().typeDefinition();
Type t = *this;
// Try to resolve on the generic arguments to the superclass.
while (t.type() == TypeType::GenericVariable && c->canBeUsedToResolve(t.typeDefinition()) &&
t.genericVariableIndex() < c->superGenericArguments().size()) {
Type tn = c->superGenericArguments()[t.genericVariableIndex()];
if (tn.type() == TypeType::GenericVariable && tn.genericVariableIndex() == t.genericVariableIndex()
&& tn.typeDefinition() == t.typeDefinition()) {
break;
}
t = tn;
}
return t;
}
void TypeRegistry::registerType(const TypeDefinition& def, const char* pParentNames[])
{
m_TypeDefs.insert(TypeDefMap::value_type(def.getName(), def));
if (pParentNames) {
string sChildArray[1];
sChildArray[0] = def.getName();
vector<string> sChildren = vectorFromCArray(1, sChildArray);
const char **ppCurParentName = pParentNames;
while (*ppCurParentName) {
TypeDefinition def = getTypeDef(*ppCurParentName);
def.addChildren(sChildren);
updateDefinition(def);
++ppCurParentName;
}
}
}
void TypeRegistry::writeTypeDTD(const TypeDefinition& def, stringstream& ss) const
{
ss << "<!ELEMENT " << def.getName() << " " << def.getDTDChildrenString() << " >\n";
if (!def.getDefaultArgs().getArgMap().empty()) {
ss << "<!ATTLIST " << def.getName();
for (ArgMap::const_iterator argIt = def.getDefaultArgs().getArgMap().begin();
argIt != def.getDefaultArgs().getArgMap().end(); argIt++)
{
string argName = argIt->first;
string argType = (argName == "id") ? "ID" : "CDATA";
string argRequired = def.getDefaultArgs().getArg(argName)->isRequired() ?
"#REQUIRED" : "#IMPLIED";
ss << "\n " << argName << " " << argType << " " << argRequired;
}
ss << " >\n";
}
}
void TypeRegistry::updateDefinition(const TypeDefinition& def)
{
m_TypeDefs[def.getName()] = def;
}
void DebugBootstrapTest::testBug(){
DefaultkevoreeFactory factory;
ContainerRoot *model = factory.createContainerRoot();
ContainerRoot *model2 = factory.createContainerRoot();
CPPUNIT_ASSERT(model != NULL);
CPPUNIT_ASSERT(model2 != NULL);
DeployUnit *d =factory.createDeployUnit();
d->name = "CPPNodeType";
d->groupName = "org.kevoree.library";
d->version = "1.0";
d->type ="elf32-i386";
TypeDefinition *nodetype = factory.createNodeType();
nodetype->name = "CPPNode";
nodetype->abstract= false;
nodetype->adddeployUnit(d);
DeployUnit *dg =factory.createDeployUnit();
dg->name = "kevoree-group-websocket";
dg->groupName = "org.kevoree.library";
dg->version = "1.0";
dg->type ="elf32-i386";
TypeDefinition *grouptype = factory.createGroupType();
grouptype->abstract= false;
grouptype->name ="w";
grouptype->version = "1";
DictionaryType *typegroup= factory.createDictionaryType();
DictionaryAttribute *attport = factory.createDictionaryAttribute();
attport->optional = false;
attport->datatype = "int";
attport->fragmentDependant = true;
attport->name ="port";
attport->defaultValue = "9000";
typegroup->addattributes(attport);
grouptype->adddictionaryType(typegroup);
grouptype->adddeployUnit(dg);
ContainerNode *node0 = factory.createContainerNode();
node0->name = "node0";
node0->started = true;
Group *group = factory.createGroup();
group->name ="g0";
group->started = true;
group->addtypeDefinition(grouptype);
FragmentDictionary *dico =factory.createFragmentDictionary();
dico->name ="node0";
DictionaryValue *valport = factory.createDictionaryValue();
valport->name ="port";
valport->value ="9000";
dico->addvalues(valport);
group->addfragmentDictionary(dico);
TypeDefinition *comtype = factory.createComponentType();
comtype->name = "comp";
comtype->abstract = false;
DeployUnit *dc =factory.createDeployUnit();
dc->name = "HelloWorldComponent";
dc->groupName = "org.kevoree.library";
dc->version = "1.0";
dc->type ="elf32-i386";
comtype->adddeployUnit(dc);
ComponentInstance *c2 = factory.createComponentInstance();
c2->name ="HelloWorldComponent0";
c2->started = true;
node0->addtypeDefinition(nodetype);
model->addtypeDefinitions(grouptype);
model->addtypeDefinitions(nodetype);
model->addtypeDefinitions(comtype);
model->adddeployUnits(d);
model->adddeployUnits(dg);
model->adddeployUnits(dc);
c2->addtypeDefinition(comtype);
model->addnodes(node0);
model->addgroups(group);
group->addsubNodes(node0);
node0->addgroups(group);
ModelCompare *compare= new ModelCompare();
TraceSequence *sequencediff = compare->diff(model,model);
TraceSequence *sequenceinter = compare->inter(model,model);
TraceSequence *sequencemerge = compare->merge(model,model);
TraceSequence *sequencediff2 = compare->diff(model2,model);
// std::cout << sequencediff2->exportToString() << std::endl;
CPPUNIT_ASSERT(sequencediff2->traces.size() != 0);
CPPUNIT_ASSERT(sequencediff->traces.size() == 0);
CPPUNIT_ASSERT(sequenceinter->traces.size() ==70);
CPPUNIT_ASSERT(sequencemerge->traces.size() ==0);
}
