class Traverser extends BfsTraverser<BfsTraverser.Node> {

        private final Map<Id, Float> globalCloseness;

        private float startVertexCloseness;

        private Traverser(UserJob<Object> job) {
            super(job);
            this.globalCloseness = new HashMap<>();
        }

        private Object closenessCentrality(Directions direction,
                                           String label,
                                           int depth,
                                           long degree,
                                           long sample,
                                           String sourceLabel,
                                           long sourceSample,
                                           String sourceCLabel,
                                           long topN) {<FILL_FUNCTION_BODY>}

        @Override
        protected Node createStartNode() {
            return new Node(1, 0);
        }

        @Override
        protected Node createNode(Node parentNode) {
            return new Node(parentNode);
        }

        @Override
        protected void meetNode(Id currentVertex, Node currentNode,
                                Id parentVertex, Node parentNode,
                                boolean firstTime) {
            if (firstTime) {
                this.startVertexCloseness += 1.0F / currentNode.distance();
            }
        }

        @Override
        protected void backtrack(Id startVertex, Id currentVertex,
                                 Map<Id, Node> localNodes) {
            throw new NotSupportException("backtrack()");
        }
    }

            assert depth > 0;
            assert degree > 0L || degree == NO_LIMIT;
            assert topN >= 0L || topN == NO_LIMIT;

            Id edgeLabelId = this.getEdgeLabelIdOrNull(label);

            // TODO: sample the startVertices
            Iterator<Vertex> startVertices = this.vertices(sourceLabel,
                                                           sourceCLabel,
                                                           Query.NO_LIMIT);
            while (startVertices.hasNext()) {
                this.startVertexCloseness = 0.0F;
                Id startVertex = ((HugeVertex) startVertices.next()).id();
                this.traverse(startVertex, direction, edgeLabelId,
                              degree, depth);
                this.globalCloseness.put(startVertex,
                                         this.startVertexCloseness);
            }
            if (topN > 0L || topN == NO_LIMIT) {
                return HugeTraverser.topN(this.globalCloseness, true, topN);
            } else {
                return this.globalCloseness;
            }
        
<methods>public non-sealed void <init>() ,public java.lang.String category() ,public void checkParameters(Map<java.lang.String,java.lang.Object>) <variables>private static final Logger LOG