Examples with ImportGroup org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup used on opensource projects

Example 1 with ImportGroup

use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup in project legend-pure by finos.

the class PropertyInstanceBuilder method createMilestonedProperties.

static ListIterable<AbstractProperty<?>> createMilestonedProperties(CoreInstance sourceProperty, CoreInstance propertyOwner, ListIterable<MilestonePropertyCodeBlock> propertyCodeBlocks, Context context, ProcessorSupport processorSupport, ModelRepository modelRepository) {
    CoreInstance rawType = sourceProperty instanceof AbstractProperty ? ((AbstractProperty<?>) sourceProperty)._genericType()._rawTypeCoreInstance() : null;
    ImportGroup importId = rawType instanceof org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportStub ? ((org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportStub) rawType)._importGroup() : null;
    return createM3MilestonedProperties(propertyOwner, importId, propertyCodeBlocks, context, processorSupport, modelRepository);
}

Example 2 with ImportGroup

use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup in project legend-pure by finos.

the class TestImports method testGetImportGroupBaseName.

@Test
public void testGetImportGroupBaseName() {
    String sourceId = "/platform/pure/graph.pure";
    Source source = this.runtime.getSourceById(sourceId);
    Assert.assertNotNull("Could not find source: " + sourceId, source);
    String importGroupName = Source.importForSourceName(sourceId, 1);
    CoreInstance imports = this.processorSupport.package_getByUserPath("system::imports");
    CoreInstance importGroup = imports.getValueInValueForMetaPropertyToMany(M3Properties.children, importGroupName);
    Assert.assertNotNull("Could not find import group: " + importGroupName, importGroup);
    Assert.assertEquals(Source.formatForImportGroupId(sourceId), Imports.getImportGroupBaseName(importGroup));
}

Example 3 with ImportGroup

use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup in project legend-pure by finos.

the class AntlrContextToM3CoreInstance method simpleProperty.

private void simpleProperty(PropertyContext ctx, MutableList<Property<? extends CoreInstance, ?>> properties, MutableList<String> typeParameterNames, MutableList<String> multiplicityParameterNames, ImportStub isOwner, ImportGroup importId, boolean addLines) {
    ListIterable<CoreInstance> stereotypes = null;
    ListIterable<TaggedValue> tags = null;
    DefaultValue defaultValue = null;
    GenericType genericType;
    Multiplicity multiplicity;
    String aggregation;
    String propertyName = ctx.identifier().getText();
    if (ctx.stereotypes() != null) {
        stereotypes = this.stereotypes(ctx.stereotypes(), importId);
    }
    if (ctx.taggedValues() != null) {
        tags = this.taggedValues(ctx.taggedValues(), importId);
    }
    if (ctx.aggregation() != null) {
        if ("(composite)".equals(ctx.aggregation().getText())) {
            aggregation = "Composite";
        } else if ("(shared)".equals(ctx.aggregation().getText())) {
            aggregation = "Shared";
        } else {
            aggregation = "None";
        }
    } else {
        aggregation = "None";
    }
    if (ctx.defaultValue() != null) {
        defaultValue = defaultValue(ctx.defaultValue(), importId, propertyName);
    }
    genericType = this.type(ctx.propertyReturnType().type(), typeParameterNames, "", importId, addLines);
    multiplicity = this.buildMultiplicity(ctx.propertyReturnType().multiplicity().multiplicityArgument());
    Enumeration<?> agg = (Enumeration<?>) this.processorSupport.package_getByUserPath(M3Paths.AggregationKind);
    Enum aggKind = (Enum) agg._values().detect(v -> aggregation.equals(((Enum) v).getName()));
    SourceInformation propertySourceInfo = this.sourceInformation.getPureSourceInformation(ctx.identifier().getStart(), ctx.identifier().getStart(), ctx.getStop());
    PropertyInstance propertyInstance = PropertyInstance.createPersistent(this.repository, propertyName, propertySourceInfo, aggKind, genericType, multiplicity, null);
    propertyInstance._stereotypesCoreInstance(stereotypes);
    propertyInstance._taggedValues(tags);
    propertyInstance._name(propertyName);
    propertyInstance._defaultValue(defaultValue);
    GenericTypeInstance classifierGT = GenericTypeInstance.createPersistent(this.repository, propertySourceInfo);
    ClassInstance propertyType = (ClassInstance) this.processorSupport.package_getByUserPath(M3Paths.Property);
    classifierGT._rawTypeCoreInstance(propertyType);
    classifierGT._multiplicityArguments(Lists.mutable.of(multiplicity));
    GenericTypeInstance classifierGTTA = GenericTypeInstance.createPersistent(this.repository);
    classifierGTTA._rawTypeCoreInstance(isOwner);
    if (!typeParameterNames.isEmpty()) {
        MutableList<GenericType> typeArgs = Lists.mutable.of();
        for (String typeParamName : typeParameterNames) {
            TypeParameterInstance tp = TypeParameterInstance.createPersistent(this.repository, typeParamName);
            GenericTypeInstance gt = GenericTypeInstance.createPersistent(this.repository);
            gt._typeParameter(tp);
            typeArgs.add(gt);
        }
        classifierGTTA._typeArguments(typeArgs);
    }
    if (!multiplicityParameterNames.isEmpty()) {
        MutableList<Multiplicity> multParameters = Lists.mutable.of();
        for (String multiplicityParam : multiplicityParameterNames) {
            MultiplicityInstance mult = MultiplicityInstance.createPersistent(this.repository, null, null);
            mult._multiplicityParameter(multiplicityParam);
            multParameters.add(mult);
        }
        classifierGTTA._multiplicityArguments(multParameters);
    }
    // Clone generic type
    // TODO - do we need a deep clone?
    GenericTypeInstance ngt = GenericTypeInstance.createPersistent(this.repository, genericType.getSourceInformation());
    CoreInstance rawType = genericType._rawTypeCoreInstance();
    if (rawType != null) {
        if (rawType instanceof ImportStub) {
            ImportStub gtis = (ImportStub) rawType;
            ImportStubInstance is = ImportStubInstance.createPersistent(this.repository, gtis.getSourceInformation(), gtis._idOrPath(), gtis._importGroup());
            // ImportStubInstance is = ImportStubInstance.createPersistent(this.repository, gtis.getSourceInformation(), ((ImportStubInstance)gtis)._idOrPathAsCoreInstance().getName(), (ImportGroup)gtis._importGroup());
            ngt._rawTypeCoreInstance(is);
        } else {
            ngt._rawTypeCoreInstance(rawType);
        }
    }
    if (!genericType._typeArguments().isEmpty()) {
        ngt._typeArguments(genericType._typeArguments());
    }
    ngt._typeParameter(genericType._typeParameter());
    if (!genericType._multiplicityArguments().isEmpty()) {
        ngt._multiplicityArguments(genericType._multiplicityArguments());
    }
    classifierGT._typeArguments(Lists.mutable.<GenericType>of(classifierGTTA, ngt));
    propertyInstance._classifierGenericType(classifierGT);
    properties.add(propertyInstance);
}

Example 4 with ImportGroup

use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup in project legend-pure by finos.

the class AntlrContextToM3CoreInstance method treePathDerivedComplexProperty.

private NewPropertyRouteNode treePathDerivedComplexProperty(DerivedPropertyContext ctx, LambdaContext lambdaContext, ImportGroup importId, String space) {
    String propertyName = ctx.alias() != null ? ctx.alias().identifier().getText() : ctx.propertyRef().identifier().getText();
    boolean includeAll = ctx.treePathClassBody() != null && ctx.treePathClassBody().simplePropertyFilter() != null && ctx.treePathClassBody().simplePropertyFilter().STAR() != null;
    NewPropertyRouteNode dpRouteNode = NewPropertyRouteNodeInstance.createPersistent(this.repository, this.sourceInformation.getPureSourceInformation(ctx.getStart(), ctx.propertyRef().getStart(), ctx.getStop()), null, String.valueOf(includeAll), propertyName, ctx.propertyRef().identifier().getText(), null, null);
    ListIterable<ValueSpecification> codeSpecifications = this.codeBlock(ctx.codeBlock(), Lists.mutable.empty(), importId, lambdaContext, true, space);
    dpRouteNode._specifications(codeSpecifications);
    NewPropertyRouteNodeFunctionDefinition<?, ?> functionDefinition = NewPropertyRouteNodeFunctionDefinitionInstance.createPersistent(this.repository, this.sourceInformation.getPureSourceInformation(ctx.codeBlock().getStart()), dpRouteNode);
    functionDefinition._expressionSequence(codeSpecifications);
    dpRouteNode._functionDefinition(functionDefinition);
    if (ctx.treePathClassBody() != null) {
        this.treepathBody(ctx.treePathClassBody(), dpRouteNode, importId, lambdaContext, space);
    }
    if (ctx.taggedValues() != null) {
        dpRouteNode._taggedValues(this.taggedValues(ctx.taggedValues(), importId));
    }
    if (ctx.stereotypes() != null) {
        dpRouteNode._stereotypesCoreInstance(this.stereotypes(ctx.stereotypes(), importId));
    }
    return dpRouteNode;
}

Example 5 with ImportGroup

use of org.finos.legend.pure.m3.coreinstance.meta.pure.metamodel._import.ImportGroup in project legend-pure by finos.

the class AntlrContextToM3CoreInstance method nativeFunction.

private void nativeFunction(NativeFunctionContext ctx, ImportGroup importId, String space, MutableList<CoreInstance> coreInstancesResult) {
    this.functionCounter++;
    NativeFunctionInstance function = NativeFunctionInstance.createPersistent(this.repository, ctx.qualifiedName().identifier().getText() + this.functionCounter, this.sourceInformation.getPureSourceInformation(ctx.NATIVE().getSymbol(), ctx.qualifiedName().identifier().getStart(), ctx.END_LINE().getSymbol()));
    MutableList<String> typeParametersNames = Lists.mutable.empty();
    MutableList<String> multiplicityParametersNames = Lists.mutable.empty();
    if (ctx.typeAndMultiplicityParameters() != null) {
        this.typeParametersAndMultiplicityParameters(ctx.typeAndMultiplicityParameters(), typeParametersNames, multiplicityParametersNames);
    }
    FunctionType signature = functionTypeSignature(ctx.functionTypeSignature(), function, typeParametersNames, multiplicityParametersNames, importId, spacePlusTabs(space, 1));
    function._functionName(ctx.qualifiedName().identifier().getText());
    PackageInstance packageInstance = this.buildPackage(ctx.qualifiedName().packagePath());
    function._package(packageInstance);
    packageInstance._childrenAdd(function);
    GenericTypeInstance genericTypeInstance = GenericTypeInstance.createPersistent(this.repository);
    Type type = (Type) this.processorSupport.package_getByUserPath(M3Paths.NativeFunction);
    genericTypeInstance._rawTypeCoreInstance(type);
    GenericTypeInstance genericTypeInstanceTa = GenericTypeInstance.createPersistent(this.repository);
    genericTypeInstanceTa._rawTypeCoreInstance(signature);
    genericTypeInstance._typeArguments(Lists.mutable.<GenericType>of(genericTypeInstanceTa));
    function._classifierGenericType(genericTypeInstance);
    coreInstancesResult.add(function);
}