private Expression serializeForNotNull()

in java/fury-core/src/main/java/org/apache/fury/builder/BaseObjectCodecBuilder.java [403:451]
44 lines of code
23 McCabe index (conditional complexity)

  private Expression serializeForNotNull(
      Expression inputObject,
      Expression buffer,
      TypeRef<?> typeRef,
      Expression serializer,
      boolean generateNewMethod) {
    Class<?> clz = getRawType(typeRef);
    if (isPrimitive(clz) || isBoxed(clz)) {
      // for primitive, inline call here to avoid java boxing, rather call corresponding serializer.
      if (clz == byte.class || clz == Byte.class) {
        return new Invoke(buffer, "writeByte", inputObject);
      } else if (clz == boolean.class || clz == Boolean.class) {
        return new Invoke(buffer, "writeBoolean", inputObject);
      } else if (clz == char.class || clz == Character.class) {
        return new Invoke(buffer, "writeChar", inputObject);
      } else if (clz == short.class || clz == Short.class) {
        return new Invoke(buffer, "writeInt16", inputObject);
      } else if (clz == int.class || clz == Integer.class) {
        String func = fury.compressInt() ? "writeVarInt32" : "writeInt32";
        return new Invoke(buffer, func, inputObject);
      } else if (clz == long.class || clz == Long.class) {
        return LongSerializer.writeInt64(buffer, inputObject, fury.longEncoding(), true);
      } else if (clz == float.class || clz == Float.class) {
        return new Invoke(buffer, "writeFloat32", inputObject);
      } else if (clz == double.class || clz == Double.class) {
        return new Invoke(buffer, "writeFloat64", inputObject);
      } else {
        throw new IllegalStateException("impossible");
      }
    } else {
      if (clz == String.class) {
        return fury.getStringSerializer().writeStringExpr(stringSerializerRef, buffer, inputObject);
      }
      Expression action;
      // this is different from ITERABLE_TYPE in RowCodecBuilder. In row-format we don't need to
      // ensure
      // class consistence, we only need to ensure interface consistence. But in java serialization,
      // we need to ensure class consistence.
      if (useCollectionSerialization(typeRef)) {
        action =
            serializeForCollection(buffer, inputObject, typeRef, serializer, generateNewMethod);
      } else if (useMapSerialization(typeRef)) {
        action = serializeForMap(buffer, inputObject, typeRef, serializer, generateNewMethod);
      } else {
        action = serializeForNotNullObject(inputObject, buffer, typeRef, serializer);
      }
      return action;
    }
  }