private String toArraySizeInBytesVariableExpression(Field field, TypeReference typeReference, VariableLiteral variableLiteral, List<Argument> parserArguments, List<Argument> serializerArguments, boolean suppressPointerAccess, Tracer tracer) {
        tracer = tracer.dive("array size in bytes");
        VariableLiteral va = variableLiteral.getArgs()
            .orElseThrow(() -> new FreemarkerException("ARRAY_SIZE_IN_BYTES needs at least one arg"))
            .stream().findFirst().orElseThrow(IllegalStateException::new)
            .asLiteral()
            .orElseThrow(() -> new FreemarkerException("ARRAY_SIZE_IN_BYTES needs a literal"))
            .asVariableLiteral()
            .orElseThrow(() -> new FreemarkerException("ARRAY_SIZE_IN_BYTES needs a variable literal"));

        // "io" and "m" are always available in every parser.
        boolean isSerializerArg = "read_buffer".equals(va.getName()) || "write_buffer".equals(va.getName()) || "self".equals(va.getName()) || "element".equals(va.getName());
        if (!isSerializerArg && serializerArguments != null) {
            for (Argument serializerArgument : serializerArguments) {
                if (serializerArgument.getName().equals(va.getName())) {
                    isSerializerArg = true;
                    break;
                }
            }
        }

        StringBuilder sb = new StringBuilder();
        if (isSerializerArg) {
            // Access the given variable literal via a serializer argument. This
            // might be the case if the argument is called "read_buffer" or
            // "write_buffer".
            sb.append(va.getName()).append(va.getChild().map(child -> "." + toVariableExpression(field, typeReference, child, parserArguments, serializerArguments, true, suppressPointerAccess, true)).orElse(""));
        } else {
            // Access the given variable literal directly.
            sb.append(toVariableExpression(field, typeReference, va, parserArguments, serializerArguments, true, suppressPointerAccess));
        }

        // We need the getsizeof function from the sys module.
        emitRequiredImport("from plc4py.spi.values.Common import get_size_of_array");
        // Cast the result to the correct type if necessary.
        return tracer + getCastExpressionForTypeReference(typeReference) + "(get_size_of_array(" + sb + "))";
    }
Returns an expression that computes the size in bytes of the given
variable literal in Python.

@param field the field of the given type reference
@param typeReference the type reference of the given data
@param variableLiteral the variable literal to access
@param parserArguments the parser arguments
@param serializerArguments the serializer arguments
@param suppressPointerAccess whether to suppress pointer access
@param tracer the tracer for this expression
@return an expression that computes the size in bytes of the given
variable literal in Python.
code-generation/language-python/src/main/java/org/apache/plc4x/language/python/PythonLanguageTemplateHelper.java