Examples with CompositeEntity org.whole.lang.models.model.CompositeEntity used on opensource projects

Example 1 with CompositeEntity

use of org.whole.lang.models.model.CompositeEntity in project whole by wholeplatform.

the class ControlQueriesTest method testChoose4.

@Test
public void testChoose4() {
    Model model = new ModelsModel().create();
    ModelDeclarations decls = model.getDeclarations();
    IBindingManager bm = BindingManagerFactory.instance.createBindingManager();
    ITemplateManager tm = ControlQueriesTemplateManager.instance();
    PathExpression query = (PathExpression) tm.create("choose4");
    int i = 0;
    IEntityIterator<IEntity> iterator = BehaviorUtils.compileAndLazyEvaluate(query, model, bm);
    while (iterator.hasNext()) {
        IEntity result = iterator.next();
        assertSame(result, bm.wGet("type"));
        assertTrue(result instanceof ClassDeclaration);
        ClassDeclaration classDecl = (ClassDeclaration) result;
        IEntity decl = decls.wGet(i++);
        String name = "", superClassName = "";
        switch(decl.wGetEntityOrd()) {
            case ModelsEntityDescriptorEnum.SimpleEntity_ord:
                SimpleEntity simpleEntity = (SimpleEntity) decl;
                name = simpleEntity.getName().wStringValue();
                superClassName = "AbstractSimpleEntity";
                break;
            case ModelsEntityDescriptorEnum.CompositeEntity_ord:
                CompositeEntity compositeEntity = (CompositeEntity) decl;
                name = compositeEntity.getName().wStringValue();
                superClassName = "AbstractCompositeEntity";
                break;
            case ModelsEntityDescriptorEnum.DataEntity_ord:
                DataEntity dataEntity = (DataEntity) decl;
                name = dataEntity.getName().wStringValue();
                superClassName = "AbstractDataEntity";
                break;
            case ModelsEntityDescriptorEnum.EnumEntity_ord:
                EnumEntity enumEntity = (EnumEntity) decl;
                name = enumEntity.getName().wStringValue();
                superClassName = "AbstractEnumEntity";
                break;
        }
        assertEquals(name, classDecl.getName().wStringValue());
        assertEquals(superClassName, classDecl.getSuperclassType().wStringValue());
    }
}

Example 2 with CompositeEntity

use of org.whole.lang.models.model.CompositeEntity in project whole by wholeplatform.

the class ControlQueriesTest method testChoose3.

@Test
public void testChoose3() {
    Model model = new ModelsModel().create();
    ModelDeclarations decls = model.getDeclarations();
    ITemplateManager tm = ControlQueriesTemplateManager.instance();
    PathExpression query = (PathExpression) tm.create("choose3");
    int i = 0;
    IEntityIterator<IEntity> iterator = BehaviorUtils.compileAndLazyEvaluate(query, model);
    while (iterator.hasNext()) {
        IEntity result = iterator.next();
        IEntity decl = decls.wGet(i++);
        switch(decl.wGetEntityOrd()) {
            case ModelsEntityDescriptorEnum.SimpleEntity_ord:
                Features features = ((SimpleEntity) decl).getFeatures();
                if (!features.isEmpty())
                    assertEquals(features.get(0).getName().wStringValue(), result.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.CompositeEntity_ord:
                CompositeEntity compositeEntity = (CompositeEntity) decl;
                assertEquals(compositeEntity.getComponentType().wStringValue(), result.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.DataEntity_ord:
                DataEntity dataEntity = (DataEntity) decl;
                assertEquals(dataEntity.getDataType().wStringValue(), result.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.EnumEntity_ord:
                EnumEntity enumEntity = (EnumEntity) decl;
                assertEquals(enumEntity.getValues().wGet(0).wStringValue(), result.wStringValue());
                break;
        }
    }
}

Example 3 with CompositeEntity

use of org.whole.lang.models.model.CompositeEntity in project whole by wholeplatform.

the class ControlQueriesTest method testQueryDecl5.

@Test
public void testQueryDecl5() {
    Model model = new ModelsModel().create();
    ModelDeclarations decls = model.getDeclarations();
    IBindingManager bm = BindingManagerFactory.instance.createArguments();
    ITemplateManager tm = ControlQueriesTemplateManager.instance();
    PathExpression query = (PathExpression) tm.create("queryDecl5");
    int count = 0;
    int index = 0;
    for (IEntity p : BehaviorUtils.compileAndLazyEvaluate(query, model, bm)) {
        IEntity decl = decls.wGet(index++);
        switch(decl.wGetEntityOrd()) {
            case ModelsEntityDescriptorEnum.SimpleEntity_ord:
                Features features = ((SimpleEntity) decl).getFeatures();
                if (!features.isEmpty())
                    assertEquals(features.get(0).getName().wStringValue(), p.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.CompositeEntity_ord:
                assertEquals(((CompositeEntity) decl).getComponentType().wStringValue(), p.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.DataEntity_ord:
                assertEquals(((DataEntity) decl).getName().wStringValue(), p.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.EnumEntity_ord:
                assertTrue(Matcher.matchImpl(ModelsEntityDescriptorEnum.EnumEntity, p));
                break;
        }
        count++;
    }
    assertEquals(33, count);
}

Example 4 with CompositeEntity

use of org.whole.lang.models.model.CompositeEntity in project whole by wholeplatform.

the class ControlQueriesTest method testChoose2.

@Test
public void testChoose2() {
    Model model = new ModelsModel().create();
    ModelDeclarations decls = model.getDeclarations();
    ITemplateManager tm = ControlQueriesTemplateManager.instance();
    PathExpression query = (PathExpression) tm.create("choose2");
    int i = 0;
    IEntityIterator<IEntity> iterator = BehaviorUtils.compileAndLazyEvaluate(query, model);
    while (iterator.hasNext()) {
        IEntity result;
        IEntity decl = decls.wGet(i++);
        switch(decl.wGetEntityOrd()) {
            case ModelsEntityDescriptorEnum.SimpleEntity_ord:
                IEntity features = ((SimpleEntity) decl).getFeatures();
                for (int j = 0; j < features.wSize(); j++) {
                    result = iterator.next();
                    assertEquals(((Feature) features.wGet(j)).getName().wStringValue(), result.wStringValue());
                }
                break;
            case ModelsEntityDescriptorEnum.CompositeEntity_ord:
                result = iterator.next();
                CompositeEntity compositeEntity = (CompositeEntity) decl;
                assertEquals(compositeEntity.getComponentType().wStringValue(), result.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.DataEntity_ord:
                result = iterator.next();
                DataEntity dataEntity = (DataEntity) decl;
                assertEquals(dataEntity.getDataType().wStringValue(), result.wStringValue());
                break;
            case ModelsEntityDescriptorEnum.EnumEntity_ord:
                EnumValues enumValues = ((EnumEntity) decl).getValues();
                if (enumValues.wIsEmpty())
                    iterator.next();
                else
                    for (int j = 0; j < enumValues.wSize(); j++) {
                        result = iterator.next();
                        assertEquals(enumValues.wGet(j).wStringValue(), result.wStringValue());
                    }
                break;
        }
    }
}

Example 5 with CompositeEntity

use of org.whole.lang.models.model.CompositeEntity in project whole by wholeplatform.

the class Grammars2ModelsVisitor method visit.

@Override
public void visit(Production entity) {
    ModelsEntityFactory mf = ModelsEntityFactory.instance;
    String eName = getMappedEntityName(entity);
    Rule rule = entity.getRule();
    AbstractPatternFilterIterator<Rule> ruleIterator = IteratorFactory.<Rule>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.Rule);
    ruleIterator.reset(rule);
    while (ruleIterator.hasNext()) {
        rule = ruleIterator.next();
        switch(rule.wGetEntityOrd()) {
            // map productions with a single lexical non-terminal as data entities
            case GrammarsEntityDescriptorEnum.NonTerminal_ord:
                if (!isLexicalNonTerminal((NonTerminal) rule) || !EntityUtils.hasParent(rule) || !Matcher.match(GrammarsEntityDescriptorEnum.Production, rule.wGetParent()) || !Matcher.match(GrammarsEntityDescriptorEnum.DataTerminal, lexiconMap.get(((NonTerminal) rule).getValue()).getRule()))
                    break;
            case GrammarsEntityDescriptorEnum.DataTerminal_ord:
                DataEntity de = getModelDeclaration(eName, ModelsEntityDescriptorEnum.DataEntity);
                Template template = entity.getTemplate();
                if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.DataType, template))
                    de.getDataType().wSetValue(GrammarsUtils.getDataType((DataType) template));
                else if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.CustomDataType, template))
                    de.getDataType().wSetValue(template.wStringValue());
                return;
            case GrammarsEntityDescriptorEnum.Choose_ord:
                boolean isPolymorphic = false;
                AbstractPatternFilterIterator<NonTerminal> ruleIterator2 = IteratorFactory.<NonTerminal>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.NonTerminal);
                ruleIterator2.reset(rule);
                for (NonTerminal nt2 : ruleIterator2) if (!isLexicalNonTerminal(nt2)) {
                    ensureType(getModelDeclaration(getMappedEntityName(nt2)).getTypes(), eName);
                    isPolymorphic = true;
                }
                if (isPolymorphic) {
                    SimpleEntity se = getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
                    se.getModifiers().wAdd(mf.createEntityModifier(EntityModifierEnum._abstract));
                    return;
                } else if (!rule.wIsEmpty() && Matcher.match(GrammarsEntityDescriptorEnum.As, rule.wGet(0))) {
                    EnumEntity ee = getModelDeclaration(eName, ModelsEntityDescriptorEnum.EnumEntity);
                    EnumValues enumValues = ModelsEntityFactory.instance.createEnumValues(0);
                    AbstractPatternFilterIterator<As> ruleIterator3 = IteratorFactory.<As>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.As);
                    ruleIterator3.reset(rule);
                    for (As as : ruleIterator3) enumValues.wAdd(ModelsEntityFactory.instance.createEnumValue(as.getName().getValue()));
                    ee.setValues(enumValues);
                    return;
                }
                // }
                break;
            case GrammarsEntityDescriptorEnum.Repeat_ord:
                if (ruleIterator.skipTo(GrammarsEntityDescriptorEnum.NonTerminal)) {
                    // FIXME wrongly assumes that the separator, if present, is a lexical token
                    if (!EntityUtils.isResolver(((Repeat) rule).getSeparator())) {
                        // if (Matcher.matchImpl(GrammarsEntityDescriptorEnum.NonTerminal, ((Repeat) rule).getSeparator())) {
                        ruleIterator.next();
                        ruleIterator.skipTo(GrammarsEntityDescriptorEnum.NonTerminal);
                    }
                    NonTerminal nt = null;
                    AbstractPatternFilterIterator<NonTerminal> ruleIterator4 = IteratorFactory.<NonTerminal>descendantOrSelfMatcherIterator().withPattern(GrammarsEntityDescriptorEnum.NonTerminal);
                    ruleIterator4.reset(rule);
                    for (NonTerminal nt2 : ruleIterator4) if (!isLexicalNonTerminal(nt2)) {
                        nt = nt2;
                        break;
                    }
                    // by now we assume that the separator, if present, is a lexical token
                    if (nt == null)
                        break;
                    // the above statements replace this code, allowing lexical Repeat rule
                    // NonTerminal nt = ruleIterator.next(GrammarsEntityDescriptorEnum.NonTerminal);
                    // while (isLexicalNonTerminal(nt)) {
                    // nt = ruleIterator.next(GrammarsEntityDescriptorEnum.NonTerminal);
                    // }
                    CompositeEntity ce = getModelDeclaration(eName, ModelsEntityDescriptorEnum.CompositeEntity);
                    ce.setComponentType(mf.createSimpleName(getMappedEntityName(nt)));
                    ce.getComponentModifiers().wAdd(mf.createComponentModifier(ComponentModifierEnum.ordered));
                }
                return;
            case GrammarsEntityDescriptorEnum.As_ord:
                As asRule = (As) rule;
                // normalization invariants assure that this branch is unreachable
                // if (Matcher.match(GrammarsEntityDescriptorEnum.LiteralTerminal, asRule.getRule())) {
                // EnumEntity ee = getModelDeclaration(eName, ModelsEntityDescriptorEnum.EnumEntity);
                // 
                // ee.getValues().wAdd(mf.createEnumValue(getMappedName(asRule)));
                // 
                // while (ruleIterator.skipTo(GrammarsEntityDescriptorEnum.As)) {
                // rule = ruleIterator.next(GrammarsEntityDescriptorEnum.As);
                // asRule = (As) rule;
                // 
                // ee.getValues().wAdd(mf.createEnumValue(getMappedName(asRule)));
                // }
                // } else {
                SimpleEntity se = getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
                Features features = se.getFeatures();
                ensureFeature(features, ruleIterator, asRule);
                while (ruleIterator.hasNext()) {
                    rule = ruleIterator.next();
                    switch(rule.wGetEntityOrd()) {
                        case GrammarsEntityDescriptorEnum.As_ord:
                            asRule = (As) rule;
                            ensureFeature(features, ruleIterator, asRule);
                            break;
                    }
                }
                // }
                return;
            case GrammarsEntityDescriptorEnum.Concatenate_ord:
                break;
        }
    }
    getModelDeclaration(eName, ModelsEntityDescriptorEnum.SimpleEntity);
}