*
     * @return The current session, never {@code null}.
     */
    MavenSession getSession();

    /**
     * Gets the current project (if any).
     *
     * @return The current project or {@code null} if not applicable.
     */
    MavenProject getProject();

    /**
     * Gets the current mojo execution (if any).
     *
     * @return The current mojo execution or {@code null} if not applicable.

                runningInstallTask.get() -> "from current time because installing"
                runningDocsTestTask.get() -> "from current time because testing docs"
                runningOnCi.get() -> "from current time because CI"
                else -> "from current date"
            }
        }

    private

	for len(r.current) <= r.recordsRead {
		if r.err != nil {
			return nil, r.err
		}
		// Move to next block
		item, ok := <-r.queue
		if !ok {
			r.err = io.EOF
			return nil, r.err
		}

		r.csvDstPool.Put(r.current)
		r.current = <-item.dst
		r.err = item.err
		r.recordsRead = 0
	}
	csvRecord := r.current[r.recordsRead]
	r.recordsRead++

            .toString()
            .contains("java.util.Map.java.util.Map")) {
          CURRENT = JAVA8;
        } else {
          CURRENT = JAVA9;
        }
      } else if (new TypeCapture<int[]>() {}.capture() instanceof Class) {
        CURRENT = JAVA7;
      } else {
        CURRENT = JAVA6;
      }
    }

    abstract Type newArrayType(Type componentType);

        this.manager = manager;
        this.strategy = LoadBalancingStrategy.ADAPTIVE;
        this.roundRobinCounter = new AtomicInteger(0);
    }

    /**
     * Get current load balancing strategy
     *
     * @return current strategy
     */
    public LoadBalancingStrategy getStrategy() {
        return strategy;
    }

    /**
     * Set load balancing strategy
     *

	}
	for _, g := range pickRelevantGoroutines() {
		snapshot.relevantRoutines[g] = true
	}
	return snapshot
}

// CompareCurrentSnapshot - Compares the initial relevant stack trace with the current one (during the time of invocation).
func (initialSnapShot LeakDetect) CompareCurrentSnapshot() []string {
	var stackDiff []string
	for _, g := range pickRelevantGoroutines() {

     * @param parentKey the parent key path
     * @param textBuilder the string builder for text content
     * @param metadataMap the map for metadata extraction
     * @param depth the current depth in the JSON structure
     */
    protected void extractContent(final JsonNode node, final String parentKey, final StringBuilder textBuilder,
            final Map<String, List<String>> metadataMap, final int depth) {

    }

    /**
     * Sets an object in the current request attributes.
     *
     * @param name The attribute name
     * @param value The attribute value
     */
    public static void setObject(final String name, final Object value) {
        LaRequestUtil.getOptionalRequest().ifPresent(req -> req.setAttribute(name, value));
    }

    /**
     * Gets an object from the current request attributes.
     *

	for len(r.current) <= r.recordsRead {
		if r.err != nil {
			return nil, r.err
		}
		// Move to next block
		item, ok := <-r.queue
		if !ok {
			r.err = io.EOF
			return nil, r.err
		}
		r.kvDstPool.Put(r.current)
		r.current = <-item.dst
		r.err = item.err
		r.recordsRead = 0
	}
	kvRecord := r.current[r.recordsRead]
	r.recordsRead++

	if err != nil && err != ErrWriteTooLong {
		tw.err = err
	}
	return n, err
}

// readFrom populates the content of the current file by reading from r.
// The bytes read must match the number of remaining bytes in the current file.
//
// If the current file is sparse and r is an io.ReadSeeker,
// then readFrom uses Seek to skip past holes defined in Header.SparseHoles,
// assuming that skipped regions are all NULs.