class SupportedColumnTypeWrapper implements Comparable<SupportedColumnTypeWrapper> {

    private static final List<Class> SIMPLE_TYPES_ORDER = Arrays.asList(new Class[] {
        String.class,
        Integer.class,
        Long.class,
        Float.class,
        Double.class,
        Boolean.class,
        BigInteger.class,
        BigDecimal.class,
        Byte.class,
        Short.class,
        Character.class
    });
    private final Class<?> type;

    public SupportedColumnTypeWrapper(Class type) {
        this.type = type;
    }

    /**
     * Build a list of column type wrappers from GraphStore supported types.
     *
     * @param graphModel
     * @return Ordered column type wrappers list
     */
    public static List<SupportedColumnTypeWrapper> buildOrderedSupportedTypesList(GraphModel graphModel) {
        TimeRepresentation timeRepresentation = graphModel.getConfiguration().getTimeRepresentation();
        return buildOrderedSupportedTypesList(timeRepresentation);
    }

    /**
     * Build a list of column type wrappers from GraphStore supported types.
     *
     * @param timeRepresentation
     * @return Ordered column type wrappers list
     */
    public static List<SupportedColumnTypeWrapper> buildOrderedSupportedTypesList(
        TimeRepresentation timeRepresentation) {
        List<SupportedColumnTypeWrapper> supportedTypesWrappers = new ArrayList<>();

        for (Class<?> type : AttributeUtils.getSupportedTypes()) {
            if (type.equals(Map.class) || type.equals(List.class) || type.equals(Set.class)) {
                continue;
                //Not yet supported in Gephi
            }

            if (AttributeUtils.isStandardizedType(type) && Attributes.isTypeAvailable(type, timeRepresentation)) {
                supportedTypesWrappers.add(new SupportedColumnTypeWrapper(type));
            }
        }

        Collections.sort(supportedTypesWrappers);

        return supportedTypesWrappers;
    }

    @Override
    public String toString() {
        if (AttributeUtils.isArrayType(type)) {
            return String.format("%s list", type.getComponentType().getSimpleName());
        } else {
            return type.getSimpleName();
        }
    }

    public Class<?> getType() {
        return type;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 17 * hash + (this.type != null ? this.type.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final SupportedColumnTypeWrapper other = (SupportedColumnTypeWrapper) obj;
        return this.type == other.type || (this.type != null && this.type.equals(other.type));
    }

    /**
     * Order for column types by name. Simple types appear first, then dynamic types and then array/list types.
     *
     * @param other
     * @return
     */
    @Override
    public int compareTo(SupportedColumnTypeWrapper other) {<FILL_FUNCTION_BODY>}
}

        boolean isArray = type.isArray();
        boolean isArrayOther = other.type.isArray();

        if (isArray != isArrayOther) {
            if (isArray) {
                return 1;
            } else {
                return -1;
            }
        } else {
            boolean isDynamic = AttributeUtils.isDynamicType(type);
            boolean isDynamicOther = AttributeUtils.isDynamicType(other.type);

            if (isDynamic != isDynamicOther) {
                if (isDynamic) {
                    return 1;
                } else {
                    return -1;
                }
            } else {
                int i1 = SIMPLE_TYPES_ORDER.indexOf(type);
                int i2 = SIMPLE_TYPES_ORDER.indexOf(other.type);

                if (i1 != -1 && i2 != -1) {
                    return i1 - i2;
                } else {
                    return type.getSimpleName().compareTo(other.type.getSimpleName());
                }
            }
        }
    
<no_super_class>