}
	if !next.hasPrefix(prefix) {
		return metaCacheEntriesSorted{}, io.EOF
	}

	if r.current.name != "" {
		if (inclDeleted || !r.current.isLatestDeletemarker()) && r.current.hasPrefix(prefix) && (inclDirs || r.current.isObject()) {
			res = append(res, r.current)
		}
		r.current.name = ""
		r.current.metadata = nil
	}

	for n < 0 || len(res) < n {
		if more, err := r.mr.ReadBool(); !more {

type xlMetaV1Object struct {
	Version string   `json:"version"` // Version of the current `xl.meta`.
	Format  string   `json:"format"`  // Format of the current `xl.meta`.
	Stat    StatInfo `json:"stat"`    // Stat of the current object `xl.meta`.
	// Erasure coded info for the current object `xl.meta`.
	Erasure ErasureInfo `json:"erasure"`
	// MinIO release tag for current object `xl.meta`.
	Minio struct {
		Release string `json:"release"`

     */
    public void setPageSize(final int pageSize) {
        this.pageSize = pageSize;
    }

    /**
     * Gets the current page number being displayed.
     * If current page number is not set or is invalid, returns the default current page number.
     *
     * @return current page number
     */
    public int getCurrentPageNumber() {
        if (currentPageNumber <= 0) {

     * @return true if a stub model should be allowed, false otherwise
     */
    boolean isAllowStubModel();

    /**
     * Determines whether the project builder should recursively build parent/child projects.
     * When true, the builder will process parent POMs and child modules as needed.
     *
     * @return true if the build should be recursive, false otherwise
     */
    boolean isRecursive();

    /**

	DB.First(&parent1, parent.ID)
	AssertObjEqual(t, parent, parent1, "ID", "FavChildID")
}

func TestSaveHasManyCircularReference(t *testing.T) {
	parent := Parent{}
	DB.Create(&parent)

	child := Child{ParentID: &parent.ID, Parent: &parent, Name: "HasManyCircularReference"}
	child1 := Child{ParentID: &parent.ID, Parent: &parent, Name: "HasManyCircularReference1"}

	parent.Children = []*Child{&child, &child1}

        long result = current.skip(n);
        if (result > 0) {
          return result;
        }
        advance();
      }
    }
    return 0;
  }

  @Override
  public boolean ready() throws IOException {
    return (current != null) && current.ready();
  }

  @Override
  public void close() throws IOException {
    if (current != null) {
      try {
        current.close();

     * @return the current builder
     */
    @Nonnull
    default MessageBuilder info(Object message) {
        return style("." + Constants.MAVEN_STYLE_INFO_NAME + ":-" + Constants.MAVEN_STYLE_INFO_DEFAULT, message);
    }

    /**
     * Append message content in warning style.
     * By default, bold yellow
     *
     * @param message the message to append
     * @return the current builder
     */
    @Nonnull

        String current = getVersion();
        if (current.equals(version) || (version == null && current.isEmpty())) {
            return this;
        }
        return new RelocatedArtifact(artifact, groupId, artifactId, classifier, extension, version, message);
    }

    @Override
    public Artifact setFile(File file) {
        File current = getFile();

    public void renderTo(ClassDoc classDoc, Element parent) {
        Document document = parent.getOwnerDocument();

        Element title = document.createElement("title");
        parent.appendChild(title);
        title.appendChild(document.createTextNode(classDoc.getSimpleName()));

        addApiDocumentationLink(classDoc, parent, document);
        addSubtypeLinks(classDoc, parent, document);

  Lockable {
  internal val fileSystem: FileSystem =
    object : ForwardingFileSystem(fileSystem) {
      override fun sink(
        file: Path,
        mustCreate: Boolean,
      ): Sink {
        file.parent?.let {
          createDirectories(it)
        }
        return super.sink(file, mustCreate)
      }
    }

  /** The maximum number of bytes that this cache should use to store its data. */