Search in sources :

Example 1 with JFieldRef

use of com.sun.codemodel.JFieldRef in project jsonschema2pojo by joelittlejohn.

the class DynamicPropertiesRule method addGetMethods.

void addGetMethods(JDefinedClass jclass) {
    JFieldRef notFoundVar = getOrAddNotFoundVar(jclass);
    JMethod internalGetMethod = this.getInternalGetMethod(jclass);
    addPublicGetMethod(jclass, internalGetMethod, notFoundVar);
}
Also used : JFieldRef(com.sun.codemodel.JFieldRef) JMethod(com.sun.codemodel.JMethod)

Example 2 with JFieldRef

use of com.sun.codemodel.JFieldRef in project jsonschema2pojo by joelittlejohn.

the class DynamicPropertiesRuleTest method shouldAddNotFoundField.

@Test
public void shouldAddNotFoundField() {
    JFieldRef var = rule.getOrAddNotFoundVar(type);
    assertThat(var, notNullValue());
}
Also used : JFieldRef(com.sun.codemodel.JFieldRef) Test(org.junit.Test)

Example 3 with JFieldRef

use of com.sun.codemodel.JFieldRef in project rest.li by linkedin.

the class JavaRequestBuilderGenerator method generateResourceFacade.

private JDefinedClass generateResourceFacade(ResourceSchema resource, File sourceFile, Map<String, JClass> pathKeyTypes, Map<String, JClass> assocKeyTypes, Map<String, List<String>> pathToAssocKeys) throws JClassAlreadyExistsException, IOException {
    final ValidationResult validationResult = ValidateDataAgainstSchema.validate(resource.data(), resource.schema(), new ValidationOptions(RequiredMode.MUST_BE_PRESENT));
    if (!validationResult.isValid()) {
        throw new IllegalArgumentException(String.format("Resource validation error.  Resource File '%s', Error Details '%s'", sourceFile, validationResult.toString()));
    }
    final String packageName = resource.getNamespace();
    final JPackage clientPackage = (packageName == null || packageName.isEmpty()) ? getPackage() : getPackage(packageName);
    final String className;
    if (_version == RestliVersion.RESTLI_2_0_0) {
        className = getBuilderClassNameByVersion(RestliVersion.RESTLI_2_0_0, null, resource.getName(), true);
    } else {
        className = getBuilderClassNameByVersion(RestliVersion.RESTLI_1_0_0, null, resource.getName(), true);
    }
    final JDefinedClass facadeClass = clientPackage._class(className);
    annotate(facadeClass, sourceFile.getAbsolutePath());
    final JFieldVar baseUriField;
    final JFieldVar requestOptionsField;
    final JExpression baseUriGetter = JExpr.invoke("getBaseUriTemplate");
    final JExpression requestOptionsGetter = JExpr.invoke("getRequestOptions");
    if (_version == RestliVersion.RESTLI_2_0_0) {
        baseUriField = null;
        requestOptionsField = null;
        facadeClass._extends(BuilderBase.class);
    } else {
        // for old builder, instead of extending from RequestBuilderBase, add fields and getters in the class
        baseUriField = facadeClass.field(JMod.PRIVATE | JMod.FINAL, String.class, "_baseUriTemplate");
        requestOptionsField = facadeClass.field(JMod.PRIVATE, RestliRequestOptions.class, "_requestOptions");
        facadeClass.method(JMod.PRIVATE, String.class, "getBaseUriTemplate").body()._return(baseUriField);
        facadeClass.method(JMod.PUBLIC, RestliRequestOptions.class, "getRequestOptions").body()._return(requestOptionsField);
    }
    // make the original resource path available via a private final static variable.
    final JFieldVar originalResourceField = facadeClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, String.class, "ORIGINAL_RESOURCE_PATH");
    final String resourcePath = getResourcePath(resource.getPath());
    originalResourceField.init(JExpr.lit(resourcePath));
    // create reference to RestliRequestOptions.DEFAULT_OPTIONS
    final JClass restliRequestOptionsClass = getCodeModel().ref(RestliRequestOptions.class);
    final JFieldRef defaultOptionsField = restliRequestOptionsClass.staticRef("DEFAULT_OPTIONS");
    if (_version == RestliVersion.RESTLI_1_0_0) {
        // same getPathComponents() logic as in RequestBuilderBase
        final JMethod pathComponentsGetter = facadeClass.method(JMod.PUBLIC, String[].class, "getPathComponents");
        pathComponentsGetter.body()._return(getCodeModel().ref(URIParamUtils.class).staticInvoke("extractPathComponentsFromUriTemplate").arg(baseUriField));
        // method that expresses the following logic
        //   (requestOptions == null) ? return RestliRequestOptions.DEFAULT_OPTIONS : requestOptions;
        final JMethod requestOptionsAssigner = facadeClass.method(JMod.PRIVATE | JMod.STATIC, RestliRequestOptions.class, "assignRequestOptions");
        final JVar requestOptionsAssignerParam = requestOptionsAssigner.param(RestliRequestOptions.class, "requestOptions");
        final JConditional requestNullCheck = requestOptionsAssigner.body()._if(requestOptionsAssignerParam.eq(JExpr._null()));
        requestNullCheck._then().block()._return(defaultOptionsField);
        requestNullCheck._else().block()._return(requestOptionsAssignerParam);
    }
    /*
    There will be 4 constructors:
      ()
      (RestliRequestOptions)
      (String)
      (String, RestliRequestOptions)
    */
    final JMethod noArgConstructor = facadeClass.constructor(JMod.PUBLIC);
    final JMethod requestOptionsOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);
    final JMethod resourceNameOverrideConstructor = facadeClass.constructor(JMod.PUBLIC);
    final JMethod mainConstructor = facadeClass.constructor(JMod.PUBLIC);
    // no-argument constructor, delegates to the request options override constructor
    noArgConstructor.body().invoke(THIS).arg(defaultOptionsField);
    // request options override constructor
    final JVar requestOptionsOverrideOptionsParam = requestOptionsOverrideConstructor.param(RestliRequestOptions.class, "requestOptions");
    if (_version == RestliVersion.RESTLI_2_0_0) {
        requestOptionsOverrideConstructor.body().invoke(SUPER).arg(originalResourceField).arg(requestOptionsOverrideOptionsParam);
    } else {
        requestOptionsOverrideConstructor.body().assign(baseUriField, originalResourceField);
        final JInvocation requestOptionsOverrideAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(requestOptionsOverrideOptionsParam);
        requestOptionsOverrideConstructor.body().assign(requestOptionsField, requestOptionsOverrideAssignRequestOptions);
    }
    // primary resource name override constructor, delegates to the main constructor
    final JVar resourceNameOverrideResourceNameParam = resourceNameOverrideConstructor.param(_stringClass, "primaryResourceName");
    resourceNameOverrideConstructor.body().invoke(THIS).arg(resourceNameOverrideResourceNameParam).arg(defaultOptionsField);
    // main constructor
    final JVar mainConsResourceNameParam = mainConstructor.param(_stringClass, "primaryResourceName");
    final JVar mainConsOptionsParam = mainConstructor.param(RestliRequestOptions.class, "requestOptions");
    final JExpression baseUriExpr;
    if (resourcePath.contains("/")) {
        baseUriExpr = originalResourceField.invoke("replaceFirst").arg(JExpr.lit("[^/]*/")).arg(mainConsResourceNameParam.plus(JExpr.lit("/")));
    } else {
        baseUriExpr = mainConsResourceNameParam;
    }
    if (_version == RestliVersion.RESTLI_2_0_0) {
        mainConstructor.body().invoke(SUPER).arg(baseUriExpr).arg(mainConsOptionsParam);
    } else {
        final JInvocation mainAssignRequestOptions = new JBlock().invoke("assignRequestOptions").arg(mainConsOptionsParam);
        mainConstructor.body().assign(baseUriField, baseUriExpr);
        mainConstructor.body().assign(requestOptionsField, mainAssignRequestOptions);
    }
    final String resourceName = CodeUtil.capitalize(resource.getName());
    final JMethod primaryResourceGetter = facadeClass.method(JMod.PUBLIC | JMod.STATIC, String.class, "getPrimaryResource");
    primaryResourceGetter.body()._return(originalResourceField);
    final List<String> pathKeys = getPathKeys(resourcePath, pathToAssocKeys);
    JClass keyTyperefClass = null;
    final JClass keyClass;
    JClass keyKeyClass = null;
    JClass keyParamsClass = null;
    final Class<?> resourceSchemaClass;
    Map<String, AssocKeyTypeInfo> assocKeyTypeInfos = Collections.emptyMap();
    StringArray supportsList = null;
    RestMethodSchemaArray restMethods = null;
    FinderSchemaArray finders = null;
    ResourceSchemaArray subresources = null;
    ActionSchemaArray resourceActions = null;
    ActionSchemaArray entityActions = null;
    if (resource.getCollection() != null) {
        resourceSchemaClass = CollectionSchema.class;
        final CollectionSchema collection = resource.getCollection();
        final String keyName = collection.getIdentifier().getName();
        // ComplexKeyResource parameterized by those two.
        if (collection.getIdentifier().getParams() == null) {
            keyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;
            final JClass declaredClass = getClassRefForSchema(RestSpecCodec.textToSchema(collection.getIdentifier().getType(), _schemaResolver), facadeClass);
            if (!declaredClass.equals(keyClass)) {
                keyTyperefClass = declaredClass;
            }
        } else {
            keyKeyClass = getJavaBindingType(collection.getIdentifier().getType(), facadeClass).valueClass;
            keyParamsClass = getJavaBindingType(collection.getIdentifier().getParams(), facadeClass).valueClass;
            keyClass = getCodeModel().ref(ComplexResourceKey.class).narrow(keyKeyClass, keyParamsClass);
        }
        pathKeyTypes.put(keyName, keyClass);
        supportsList = collection.getSupports();
        restMethods = collection.getMethods();
        finders = collection.getFinders();
        subresources = collection.getEntity().getSubresources();
        resourceActions = collection.getActions();
        entityActions = collection.getEntity().getActions();
    } else if (resource.getAssociation() != null) {
        resourceSchemaClass = AssociationSchema.class;
        final AssociationSchema association = resource.getAssociation();
        keyClass = getCodeModel().ref(CompoundKey.class);
        supportsList = association.getSupports();
        restMethods = association.getMethods();
        finders = association.getFinders();
        subresources = association.getEntity().getSubresources();
        resourceActions = association.getActions();
        entityActions = association.getEntity().getActions();
        assocKeyTypeInfos = generateAssociationKey(facadeClass, association);
        final String keyName = getAssociationKey(resource, association);
        pathKeyTypes.put(keyName, keyClass);
        final List<String> assocKeys = new ArrayList<String>(4);
        for (Map.Entry<String, AssocKeyTypeInfo> entry : assocKeyTypeInfos.entrySet()) {
            assocKeys.add(entry.getKey());
            assocKeyTypes.put(entry.getKey(), entry.getValue().getBindingType());
        }
        pathToAssocKeys.put(keyName, assocKeys);
    } else if (resource.getSimple() != null) {
        resourceSchemaClass = SimpleSchema.class;
        final SimpleSchema simpleSchema = resource.getSimple();
        keyClass = _voidClass;
        supportsList = simpleSchema.getSupports();
        restMethods = simpleSchema.getMethods();
        subresources = simpleSchema.getEntity().getSubresources();
        resourceActions = simpleSchema.getActions();
    } else if (resource.getActionsSet() != null) {
        resourceSchemaClass = ActionsSetSchema.class;
        final ActionsSetSchema actionsSet = resource.getActionsSet();
        resourceActions = actionsSet.getActions();
        keyClass = _voidClass;
    } else {
        throw new IllegalArgumentException("unsupported resource type for resource: '" + resourceName + '\'');
    }
    generateOptions(facadeClass, baseUriGetter, requestOptionsGetter);
    final JFieldVar resourceSpecField = facadeClass.field(JMod.PRIVATE | JMod.STATIC | JMod.FINAL, _resourceSpecClass, "_resourceSpec");
    if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class || resourceSchemaClass == SimpleSchema.class) {
        final JClass schemaClass = getJavaBindingType(resource.getSchema(), null).schemaClass;
        final Set<ResourceMethod> supportedMethods = getSupportedMethods(supportsList);
        final JInvocation supportedMethodsExpr;
        if (supportedMethods.isEmpty()) {
            supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());
        } else {
            supportedMethodsExpr = _enumSetClass.staticInvoke("of");
            for (ResourceMethod resourceMethod : supportedMethods) {
                validateResourceMethod(resourceSchemaClass, resourceName, resourceMethod);
                supportedMethodsExpr.arg(_resourceMethodClass.staticRef(resourceMethod.name()));
            }
        }
        final JBlock staticInit = facadeClass.init();
        final JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
        final JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
        if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class) {
            final JClass assocKeyClass = getCodeModel().ref(TypeInfo.class);
            final JClass hashMapClass = getCodeModel().ref(HashMap.class).narrow(_stringClass, assocKeyClass);
            final JVar keyPartsVar = staticInit.decl(hashMapClass, "keyParts").init(JExpr._new(hashMapClass));
            for (Map.Entry<String, AssocKeyTypeInfo> typeInfoEntry : assocKeyTypeInfos.entrySet()) {
                final AssocKeyTypeInfo typeInfo = typeInfoEntry.getValue();
                final JInvocation typeArg = JExpr._new(assocKeyClass).arg(typeInfo.getBindingType().dotclass()).arg(typeInfo.getDeclaredType().dotclass());
                staticInit.add(keyPartsVar.invoke("put").arg(typeInfoEntry.getKey()).arg(typeArg));
            }
            staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(keyTyperefClass == null ? keyClass.dotclass() : keyTyperefClass.dotclass()).arg(keyKeyClass == null ? JExpr._null() : keyKeyClass.dotclass()).arg(keyKeyClass == null ? JExpr._null() : keyParamsClass.dotclass()).arg(schemaClass.dotclass()).arg(keyPartsVar));
        } else //simple schema
        {
            staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(schemaClass.dotclass()));
        }
        generateBasicMethods(facadeClass, baseUriGetter, keyClass, schemaClass, supportedMethods, restMethods, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter, resource.data().getDataMap("annotations"));
        if (resourceSchemaClass == CollectionSchema.class || resourceSchemaClass == AssociationSchema.class) {
            generateFinders(facadeClass, baseUriGetter, finders, keyClass, schemaClass, assocKeyTypeInfos, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter);
        }
        generateSubResources(sourceFile, subresources, pathKeyTypes, assocKeyTypes, pathToAssocKeys);
    } else //action set
    {
        final JBlock staticInit = facadeClass.init();
        final JInvocation supportedMethodsExpr = _enumSetClass.staticInvoke("noneOf").arg(_resourceMethodClass.dotclass());
        final JVar methodSchemaMap = methodMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
        final JVar responseSchemaMap = responseMetadataMapInit(facadeClass, resourceActions, entityActions, staticInit);
        staticInit.assign(resourceSpecField, JExpr._new(_resourceSpecImplClass).arg(supportedMethodsExpr).arg(methodSchemaMap).arg(responseSchemaMap).arg(keyClass.dotclass()).arg(JExpr._null()).arg(JExpr._null()).arg(JExpr._null()).arg(getCodeModel().ref(Collections.class).staticInvoke("<String, Class<?>>emptyMap")));
    }
    generateActions(facadeClass, baseUriGetter, resourceActions, entityActions, keyClass, resourceSpecField, resourceName, pathKeys, pathKeyTypes, assocKeyTypes, pathToAssocKeys, requestOptionsGetter);
    generateClassJavadoc(facadeClass, resource);
    if (!checkVersionAndDeprecateBuilderClass(facadeClass, true)) {
        checkRestSpecAndDeprecateRootBuildersClass(facadeClass, resource);
    }
    return facadeClass;
}
Also used : HashMap(java.util.HashMap) ValidationResult(com.linkedin.data.schema.validation.ValidationResult) ValidationOptions(com.linkedin.data.schema.validation.ValidationOptions) ActionsSetSchema(com.linkedin.restli.restspec.ActionsSetSchema) StringArray(com.linkedin.data.template.StringArray) FinderSchemaArray(com.linkedin.restli.restspec.FinderSchemaArray) ActionSchemaArray(com.linkedin.restli.restspec.ActionSchemaArray) JConditional(com.sun.codemodel.JConditional) ArrayList(java.util.ArrayList) DataList(com.linkedin.data.DataList) List(java.util.List) Collections(java.util.Collections) JVar(com.sun.codemodel.JVar) AssociationSchema(com.linkedin.restli.restspec.AssociationSchema) JFieldRef(com.sun.codemodel.JFieldRef) RestMethodSchemaArray(com.linkedin.restli.restspec.RestMethodSchemaArray) CollectionSchema(com.linkedin.restli.restspec.CollectionSchema) RestliRequestOptions(com.linkedin.restli.client.RestliRequestOptions) JDefinedClass(com.sun.codemodel.JDefinedClass) SimpleSchema(com.linkedin.restli.restspec.SimpleSchema) JClass(com.sun.codemodel.JClass) JPackage(com.sun.codemodel.JPackage) ResourceSchemaArray(com.linkedin.restli.restspec.ResourceSchemaArray) JInvocation(com.sun.codemodel.JInvocation) JExpression(com.sun.codemodel.JExpression) JFieldVar(com.sun.codemodel.JFieldVar) URIParamUtils(com.linkedin.restli.internal.common.URIParamUtils) JBlock(com.sun.codemodel.JBlock) JMethod(com.sun.codemodel.JMethod) Map(java.util.Map) DataMap(com.linkedin.data.DataMap) HashMap(java.util.HashMap) ResourceMethod(com.linkedin.restli.common.ResourceMethod)

Example 4 with JFieldRef

use of com.sun.codemodel.JFieldRef in project drill by apache.

the class ClassGenerator method declare.

public HoldingContainer declare(MajorType t, boolean includeNewInstance) {
    JType holderType = getHolderType(t);
    JVar var;
    if (includeNewInstance) {
        var = getEvalBlock().decl(holderType, "out" + index, JExpr._new(holderType));
    } else {
        var = getEvalBlock().decl(holderType, "out" + index);
    }
    JFieldRef outputSet = null;
    if (t.getMode() == DataMode.OPTIONAL) {
        outputSet = var.ref("isSet");
    }
    index++;
    return new HoldingContainer(t, var, var.ref("value"), outputSet);
}
Also used : JFieldRef(com.sun.codemodel.JFieldRef) JType(com.sun.codemodel.JType) JVar(com.sun.codemodel.JVar)

Aggregations

JFieldRef (com.sun.codemodel.JFieldRef)4 JMethod (com.sun.codemodel.JMethod)2 JVar (com.sun.codemodel.JVar)2 DataList (com.linkedin.data.DataList)1 DataMap (com.linkedin.data.DataMap)1 ValidationOptions (com.linkedin.data.schema.validation.ValidationOptions)1 ValidationResult (com.linkedin.data.schema.validation.ValidationResult)1 StringArray (com.linkedin.data.template.StringArray)1 RestliRequestOptions (com.linkedin.restli.client.RestliRequestOptions)1 ResourceMethod (com.linkedin.restli.common.ResourceMethod)1 URIParamUtils (com.linkedin.restli.internal.common.URIParamUtils)1 ActionSchemaArray (com.linkedin.restli.restspec.ActionSchemaArray)1 ActionsSetSchema (com.linkedin.restli.restspec.ActionsSetSchema)1 AssociationSchema (com.linkedin.restli.restspec.AssociationSchema)1 CollectionSchema (com.linkedin.restli.restspec.CollectionSchema)1 FinderSchemaArray (com.linkedin.restli.restspec.FinderSchemaArray)1 ResourceSchemaArray (com.linkedin.restli.restspec.ResourceSchemaArray)1 RestMethodSchemaArray (com.linkedin.restli.restspec.RestMethodSchemaArray)1 SimpleSchema (com.linkedin.restli.restspec.SimpleSchema)1 JBlock (com.sun.codemodel.JBlock)1