class AttributeNonNullBuilder implements CategoryBuilder {

    private final static Category NONNULL = new Category(
        NbBundle.getMessage(AttributeEqualBuilder.class, "AttributeNonNullBuilder.name"),
        null,
        FilterLibrary.ATTRIBUTES);

    @Override
    public Category getCategory() {
        return NONNULL;
    }

    @Override
    public FilterBuilder[] getBuilders(Workspace workspace) {<FILL_FUNCTION_BODY>}

    private static class AttributeNonNullFilterBuilder extends AbstractAttributeFilterBuilder {

        public AttributeNonNullFilterBuilder(Column column) {
            super(column,
                NONNULL,
                NbBundle.getMessage(AttributeEqualBuilder.class, "AttributeNonNullBuilder.description"),
                null);
        }

        @Override
        public AttributeNonNullFilter getFilter(Workspace workspace) {
            return AttributeUtils.isNodeColumn(column) ? new AttributeNonNullFilter.Node(column) :
                new AttributeNonNullFilter.Edge(column);
        }

        @Override
        public JPanel getPanel(Filter filter) {
            return null;
        }
    }

    public static abstract class AttributeNonNullFilter<K extends Element> extends AbstractAttributeFilter<K> {

        public AttributeNonNullFilter(Column column) {
            super(NbBundle.getMessage(AttributeEqualBuilder.class, "AttributeNonNullBuilder.name"),
                column);
        }

        @Override
        public boolean init(Graph graph) {
            if (AttributeUtils.isNodeColumn(column)) {
                return graph.getNodeCount() != 0;
            } else if (AttributeUtils.isEdgeColumn(column)) {
                return graph.getEdgeCount() != 0;
            }
            return true;
        }

        @Override
        public boolean evaluate(Graph graph, Element element) {
            return element.getAttribute(column) != null;
        }

        @Override
        public void finish() {
        }

        public static class Node extends AttributeNonNullFilter<org.gephi.graph.api.Node> implements NodeFilter {

            public Node(Column column) {
                super(column);
            }
        }

        public static class Edge extends AttributeNonNullFilter<org.gephi.graph.api.Edge> implements EdgeFilter {

            public Edge(Column column) {
                super(column);
            }
        }
    }
}

        List<FilterBuilder> builders = new ArrayList<>();
        GraphModel am = Lookup.getDefault().lookup(GraphController.class).getGraphModel(workspace);
        for (Column col : am.getNodeTable()) {
            if (!col.isProperty()) {
                AttributeNonNullFilterBuilder b = new AttributeNonNullFilterBuilder(col);
                builders.add(b);
            }
        }
        for (Column col : am.getEdgeTable()) {
            if (!col.isProperty()) {
                AttributeNonNullFilterBuilder b = new AttributeNonNullFilterBuilder(col);
                builders.add(b);
            }
        }
        return builders.toArray(new FilterBuilder[0]);
    
<no_super_class>