How to use

staticInvoke

method

in

com.sun.codemodel.JDefinedClass

/**
 * @see EnumRule
 */
private static JExpression getDefaultEnum(JType fieldType, JsonNode node) {
  JDefinedClass enumClass = (JDefinedClass) fieldType;
  JType backingType = enumClass.fields().get("value").type();
  JInvocation invokeFromValue = enumClass.staticInvoke("fromValue");
  invokeFromValue.arg(getDefaultValue(backingType, node));
  return invokeFromValue;
}

/**
 * @see EnumRule
 */
private static JExpression getDefaultEnum(JType fieldType, JsonNode node) {
  JDefinedClass enumClass = (JDefinedClass) fieldType;
  JType backingType = enumClass.fields().get("value").type();
  JInvocation invokeFromValue = enumClass.staticInvoke("fromValue");
  invokeFromValue.arg(getDefaultValue(backingType, node));
  return invokeFromValue;
}

protected void createDataPoint( @Nonnull JDefinedClass testClass, @Nonnull JClass serializerClass, @Nonnull JClass domainType, @Nonnull DomainObjectDescriptor domainObjectDescriptor ) {
 JFieldVar field = testClass.field( JMod.STATIC | JMod.PUBLIC | JMod.FINAL, codeGenerator.ref( Entry.class ).narrow( domainType.wildcard() ), DATA_POINT_FIELD_NAME );
 field.annotate( codeModel.ref( "org.junit.experimental.theories.DataPoint" ) );
 JInvocation domainObjectCreation = createDomainObjectCreationExpression( domainObjectDescriptor );
 JExpression expected = createExpectedExpression( testClass, domainType );
 field.init( testClass.staticInvoke( METHOD_NAME_CREATE ).arg( domainObjectCreation ).arg( expected ) );
}

private void generateStaticInit(JCodeModel model, JDefinedClass dc, NamespaceManager nsManager) {
  
  JBlock block = dc.init();
  
  List<Namespace> list = new ArrayList<>(nsManager.listNamespaces());
  Collections.sort(list, new Comparator<Namespace>() {
    @Override
    public int compare(Namespace a, Namespace b) {
      return a.getPrefix().compareTo(b.getPrefix());
    }
  });
  
  for (Namespace ns : list) {
    
    JExpression prefixValue = JExpr.lit(ns.getPrefix());
    JExpression nameValue = JExpr.lit(ns.getName());
    
    block.add(dc.staticInvoke("add").arg(prefixValue).arg(nameValue));
  }
  
}

protected void createVersionsDataPoint( @Nonnull JDefinedClass testClass, @Nonnull JClass serializerClass, @Nonnull JClass domainType, @Nonnull DomainObjectDescriptor domainObjectDescriptor ) {
 JFieldVar field = testClass.field( JMod.STATIC | JMod.PUBLIC | JMod.FINAL, codeGenerator.ref( VersionEntry.class ), DATA_POINT_FIELD_NAME );
 field.annotate( codeGenerator.ref( "org.junit.experimental.theories.DataPoint" ) );
 JInvocation versionInvocation = codeGenerator.ref( Version.class ).staticInvoke( METHOD_NAME_VALUE_OF ).arg( JExpr.lit( 1 ) ).arg( JExpr.lit( 0 ) ).arg( JExpr.lit( 0 ) );
 JExpression expected = createExpectedExpression( testClass, domainType );
 field.init( testClass.staticInvoke( METHOD_NAME_CREATE ).arg( versionInvocation ).arg( expected ) );
}

URI targetClass = subclass.getTargetClass();
JDefinedClass reader = produceJsonReader(targetClass, model);
JInvocation parserInvoke = reader.staticInvoke("instance").invoke("read").arg(jsonParser);
fieldCase.body().assign(pojoVar, parserInvoke);
fieldCase.body()._break(outer);

private void generateSize() {
  sizer = generator.sizer().cls().method(JMod.PUBLIC, cm.LONG, "sizeOf" + toJavaClassName(type.getName()));
  sizer.param(getJavaType(), "value");
  size().body()._return(generator.registry().cls().staticInvoke("instance")
      .invoke("sizer").invoke("sizeOf" + toJavaClassName(type.getName())).arg(ref("value")));
}

private JFieldVar addQuickLookupMap(JDefinedClass _enum) {
  JClass lookupType = _enum.owner().ref(Map.class).narrow(_enum.owner().ref(String.class), _enum);
  JFieldVar lookupMap = _enum.field(JMod.PRIVATE | JMod.STATIC, lookupType, "constants");
  JClass lookupImplType = _enum.owner().ref(HashMap.class).narrow(_enum.owner().ref(String.class), _enum);
  lookupMap.init(JExpr._new(lookupImplType));
  JForEach forEach = _enum.init().forEach(_enum, "c", _enum.staticInvoke("values"));
  JInvocation put = forEach.body().invoke(lookupMap, "put");
  put.arg(forEach.var().ref("value"));
  put.arg(forEach.var());
  return lookupMap;
}

getInstance.body()._return( holder.staticInvoke( holderGet ) );
JDocComment jd = getInstance.javadoc();
jd.append( "Singleton instance of BuilderFactory" );

if ( attribute.attribute.type().isArray() ) {
  body.assign(ref("fieldSize"), ref("fieldSize").plus(
      generator.registry().cls().staticInvoke("instance")
          .invoke("sizer")
          .invoke("sizeOfArray")
      generator.registry().cls().staticInvoke("instance")
          .invoke("sizer")
          .invoke("sizeOf" + toJavaClassName(attribute.type))
if ( attribute.attribute.type().isArray() ) {
  body.assign(ref("fieldSize"), ref("fieldSize").plus(
      generator.registry().cls().staticInvoke("instance")
          .invoke("sizer")
          .invoke("sizeOfArray")

SYMBOLIC_ID_SIZE = cls().field(mods, Long.class, "SYMBOLIC_ID_SIZE", generator.registry().cls().staticInvoke("instance").invoke("sizer").invoke("sizeOfSymbol").arg(ref("SYMBOLIC_ID")));
NUMERIC_ID_SIZE = cls().field(mods, Long.class, "NUMERIC_ID_SIZE", generator.registry().cls().staticInvoke("instance").invoke("sizer").invoke("sizeOfULong").arg(ref("NUMERIC_ID")));
    generator.registry().cls().staticInvoke("instance")
        .invoke("getFormatCodeMap")
        .invoke("put")
    generator.registry().cls().staticInvoke("instance")
        .invoke("getSymbolicCodeMap")
        .invoke("put")

JDefinedClass reader = produceJsonReader(subclass, model);
codeCase.body()._return(reader.staticInvoke("instance").invoke("read").arg(jsonParser));

private void initWriteMethods() {
  write().body().staticInvoke(cls(), "write").arg(_this().ref("value")).arg(ref("out"));
  writeConstructor().body()._return(cls().staticInvoke("writeConstructor").arg(_this().ref("value")).arg(ref("out")));
  writeBody().body().staticInvoke(cls(), "writeBody").arg(ref("formatCode")).arg(_this().ref("value")).arg(ref("out"));
  staticWrite().body().decl(cm.BYTE, "formatCode", cls().staticInvoke("writeConstructor").arg(ref("value")).arg(ref("out")));
  staticWrite().body().staticInvoke(cls(), "writeBody").arg(ref("formatCode")).arg(ref("value")).arg(ref("out"));
  staticWriteConstructor = cls().method(JMod.PUBLIC | JMod.STATIC, cm.BYTE, "writeConstructor");
  staticWriteConstructor._throws(Exception.class);
  staticWriteConstructor.param(getJavaType(), "value");
  staticWriteConstructor.param(DataOutput.class, "out");
  staticWriteConstructor.body().decl(cm.BYTE, "formatCode", generator.registry().cls()
      .staticInvoke("instance")
      .invoke("picker")
      .invoke("choose" + toJavaClassName(type.getName() + "Encoding"))
      .arg(ref("value")));
  staticWriteConstructor.body().invoke(ref("out"), "writeByte").arg(ref("formatCode"));
  staticWriteConstructor.body()._return(ref("formatCode"));
  staticWriteBody = cls().method(JMod.PUBLIC | JMod.STATIC, cm.VOID, "writeBody");
  staticWriteBody._throws(Exception.class);
  staticWriteBody.param(cm.BYTE, "formatCode");
  staticWriteBody.param(getJavaType(), "value");
  staticWriteBody.param(DataOutput.class, "out");
}

      return clazz._package().objectFactory().staticInvoke( m );
m.body()._return( JExpr._null() );
this.methodCount = this.methodCount.add( BigInteger.ONE );
return ( mod != JMod.PRIVATE ? clazz._package().objectFactory().staticInvoke( m ) : JExpr.invoke( m ) );

      return classOutline._package().objectFactory().staticInvoke( m ).arg( source );
return ( mod != JMod.PRIVATE ? classOutline._package().objectFactory().staticInvoke( m ).arg( source )
     : JExpr.invoke( m ).arg( source ) );

.staticInvoke("instance")
.invoke("encoder")
.invoke("readNull")
    generator.registry().cls().staticInvoke("instance")
        .invoke("getPrimitiveFormatCodeMap")
        .invoke("put")
    .assign(_this().ref("value"),
        generator.registry().cls()
            .staticInvoke("instance")
            .invoke("encoder")
            .invoke("read" + toJavaClassName(fieldName))
        .staticInvoke("instance")
        .invoke("encoder")
        .invoke("read" + toJavaClassName(fieldName))
    .add(generator.registry().cls().staticInvoke("instance")
        .invoke("encoder")
        .invoke("write" + toJavaClassName(fieldName))

final JVar identifier = getEnum.param(identifierClass, "identifier");
getEnum.body()._return(
    enumClass.staticInvoke("fromValue").arg(identifier));

      return clazz._package().objectFactory().staticInvoke( m );
m.body()._return( JExpr._null() );
this.methodCount = this.methodCount.add( BigInteger.ONE );
return ( mod != JMod.PRIVATE ? clazz._package().objectFactory().staticInvoke( m ) : JExpr.invoke( m ) );

 return fieldOutline.parent()._package().objectFactory().staticInvoke( m );
? fieldOutline.parent()._package().objectFactory().staticInvoke( m ) : JExpr.invoke( m ) );

} else {
  JDefinedClass objectReader = produceJsonReader(valueClassId, model);
  objectCase.body().add(setVar.invoke("add").arg(objectReader.staticInvoke("instance").invoke("read").arg(jsonVar)));