public void declareException(Class cls) { exceptions.add(cls); method._throws(cls); }
public JMethod _throws(Class<? extends Throwable> exception) { return _throws(outer.owner().ref(exception)); }
public JMethod _throws(Class exception) { return _throws(outer.owner().ref(exception)); }
@Nonnull protected JMethod createGetSerializerMethod( @Nonnull JDefinedClass serializerTestClass, @Nonnull JClass serializerClass, @Nonnull JClass domainType ) { JType returnType = codeGenerator.ref( Serializer.class ).narrow( domainType ); JMethod createSerializerMethod = serializerTestClass.method( JMod.PROTECTED, returnType, METHOD_NAME_GET_SERIALIZER )._throws( Exception.class ); createSerializerMethod.annotate( Override.class ); //Return the serializer createSerializerMethod.body()._return( JExpr._new( serializerClass ) ); return createSerializerMethod; }
protected MethodCreator(ClassOutline classOutline, String name, Class argType, String argName) { this.classOutline = classOutline; this.name = name; this.argType = argType; this.argName = argName; JDefinedClass cls = classOutline.implClass; this.method = cls.method(JMod.PUBLIC, cls.owner().VOID, name) ._throws(IOException.class); this.arg = this.method.param(argType, argName); }
JDefinedClass anonymousFunctionClass = cm.anonymousClass(function.narrow(cassandraRow, activityBatchDailyRealTimeBean)); JMethod callMethod = anonymousFunctionClass.method(JMod.PUBLIC, Activitydaily.class, "call"); callMethod._throws(Exception.class); JVar v1Param = callMethod.param(CassandraRow.class, "v1"); callMethod.body()._return(JExpr._new(cm.ref(Activitydaily.class)));
public JMethod writeConstructor() { if ( writeConstructor == null ) { writeConstructor = cls().method(JMod.PUBLIC, cm.BYTE, "writeConstructor"); writeConstructor._throws(java.lang.Exception.class); writeConstructor.param(java.io.DataOutput.class, "out"); } return writeConstructor; }
public JMethod write() { if ( write == null ) { write = cls().method(JMod.PUBLIC, cm.VOID, "write"); write._throws(java.lang.Exception.class); write.param(java.io.DataOutput.class, "out"); } return write; }
public JMethod read() { if ( read == null ) { read = cls().method(JMod.PUBLIC, cm.VOID, "read"); read._throws(java.lang.Exception.class); read.param(cm.BYTE, "formatCode"); read.param(java.io.DataInput.class, "in"); } return read; }
private JMethod staticRead() { if ( staticRead == null ) { staticRead = cls().method(JMod.PUBLIC | JMod.STATIC, getJavaType(), "read"); staticRead._throws(Exception.class); staticRead.param(DataInput.class, "in"); } return staticRead; }
public JMethod writeBody() { if ( writeBody == null ) { writeBody = cls().method(JMod.PUBLIC, cm.VOID, "writeBody"); writeBody._throws(java.lang.Exception.class); writeBody.param(cm.BYTE, "formatCode"); writeBody.param(java.io.DataOutput.class, "out"); } return writeBody; }
public JMethod encodeTo() { if ( encodeTo == null ) { encodeTo = cls().method(JMod.PUBLIC, cm.VOID, "encodeTo"); encodeTo._throws(java.lang.Exception.class); encodeTo.param(Buffer.class, "buffer"); encodeTo.param(cm.INT, "offset"); } return encodeTo; }
public AttributeParserBuilderImpl(ElementParserBuilderImpl parent) { this.model = parent.getCodeModel(); this.buildContext = parent.getBuildContext(); this.readerClass = parent.getReaderClass(); this.parent = parent; method = buildContext.getNextReadMethod(readerClass); addBasicArgs(method); method._throws(XMLStreamException.class); }
private JMethod staticWrite() { if ( staticWrite == null ) { staticWrite = cls().method(JMod.PUBLIC | JMod.STATIC, cm.VOID, "write"); staticWrite._throws(Exception.class); staticWrite.param(getJavaType(), "value"); staticWrite.param(DataOutput.class, "out"); } return staticWrite; }
public JMethod decodeFrom() { if ( decodeFrom == null ) { decodeFrom = cls().method(JMod.PUBLIC, cm.VOID, "decodeFrom"); decodeFrom._throws(java.lang.Exception.class); decodeFrom.param(cm.BYTE, "formatCode"); decodeFrom.param(Buffer.class, "buffer"); decodeFrom.param(cm.INT, "offset"); } return decodeFrom; }
public AttributeWriterBuilder(ElementWriterBuilderImpl parent, QName name, JType type) { this.parent = parent; this.name = name; this.buildContext = parent.buildContext; method = buildContext.createMethod(parent.getWriterClass(), "write" + capitalize(type.name())); objectVar = addBasicArgs(method, type, "_obj"); method._throws(XMLStreamException.class); this.writerClass = parent.writerClass; this.model = parent.model; currentBlock = method.body(); }
protected void createVersionVerifyMethod( @Nonnull JDefinedClass testClass, @Nonnull JClass serializerClass, @Nonnull DomainObjectDescriptor domainObjectDescriptor ) { JClass domainType = codeGenerator.ref( domainObjectDescriptor.getQualifiedName() ); JMethod method = testClass.method( JMod.PROTECTED, Void.TYPE, METHOD_NAME_VERIFY_DESERIALIZED )._throws( Exception.class ); method.annotate( Override.class ); JVar deserialized = method.param( domainType, PARAM_NAME_DESERIALIZED ); method.param( Version.class, PARAM_NAME_VERSION ); JClass assertClass = codeGenerator.ref( CLASS_NAME_ASSERT ); for ( FieldWithInitializationInfo fieldInfo : domainObjectDescriptor.getFieldInfos() ) { method.body().add( assertClass.staticInvoke( METHOD_NAME_ASSERT_EQUALS ).arg( "daValue" ).arg( deserialized.invoke( fieldInfo.getGetterDeclaration().getSimpleName() ) ) ); } }
protected JVar addBasicArgs(JMethod method, JType sourceObjectType, String sourceVariableName) { xswVar = method.param(XoXMLStreamWriter.class, variableManager.createId("writer")); String rtContextName = variableManager.createId("context"); JVar var = method.param(sourceObjectType, variableManager.createId(sourceVariableName)); rtContextVar = method.param(buildContext.getMarshalContextClass(), rtContextName); for (Class c : exceptions) { method._throws(c); } return var; }
JDefinedClass testCodeClass = codeModel._class(JMod.PUBLIC, "com.testcase.myPackage.TestCode", ClassType.CLASS); JFieldVar a = testCodeClass.field(JMod.PRIVATE, codeModel.INT, "a"); JFieldVar b = testCodeClass.field(JMod.PRIVATE, codeModel.INT, "b"); JMethod testMethod = testCodeClass.method(JMod.PUBLIC, codeModel.VOID, "testMethod"); testMethod.annotate(Test.class); testMethod._throws(Exception1.class)._throws(Exception2.class)._throws(Exception3.class); JBlock body = testMethod.body(); JClass abcRef = codeModel.ref(abc.class); JVar param1Var = body.decl(codeModel.INT, "param1", JExpr.lit(1)); JVar param2Var = body.decl(codeModel.INT, "param2", JExpr.lit(2)); JVar param3Var = body.decl(codeModel.INT, "param3", JExpr.lit(3)); body.assign(a, abcRef.staticInvoke("method1").arg(param1Var).arg(param2Var).arg(param3Var));
protected void writeReadAsType() { if (!addReadAsType) return; JMethod m = getReaderClass().method(JMod.PUBLIC, Object.class, "read"); m.param(XoXMLStreamReader.class, "reader"); m.param(buildContext.getMarshalContextClass(), "context"); JVar typeVar = m.param(QName.class, "type"); m._throws(XMLStreamException.class); JBlock block = m.body(); writeXsiChecks(block, typeVar); block.add(new JBlankLine()); block._return(JExpr._null()); }