// Everybody agreed
			for _, r := range readers {
				r.skip(1)
			}
			if opts.agreed != nil {
				opts.agreed(current)
			}
			continue
		}
		if opts.partial != nil {
			opts.partial(topEntries, errs)
		}
		// Skip the inputs we used.
		for i, r := range readers {
			if topEntries[i].name != "" {
				r.skip(1)
			}
		}
	}
	return nil

                            ioe.printStackTrace(log);
                            continue;
                        }

                        /* An include was loaded successfully. We can skip
                         * all other includes up to the #END_ALTERNATE tag.
                         */

                        alt--;
                        while ((line = br.readLine()) != null) {

FastAPI knows this, and will produce OpenAPI docs that state there is no response body.

///

## About HTTP status codes { #about-http-status-codes }

/// note

If you already know what HTTP status codes are, skip to the next section.

///

In HTTP, you send a numeric status code of 3 digits as part of the response.

These status codes have a name associated to recognize them, but the important part is the number.

In short:

		buf.Next(test.skip)
		bytes, err := buf.Peek(test.n)
		if string(bytes) != test.expected {
			t.Errorf("expected %q, got %q", test.expected, bytes)
		}
		if err != test.err {
			t.Errorf("expected error %v, got %v", test.err, err)
		}
		if buf.Len() != len(test.buffer)-test.skip {
			t.Errorf("bad length after peek: %d, want %d", buf.Len(), len(test.buffer)-test.skip)
		}
	}
}

				return
			}
		case "v":
			z.dataVersion, err = dc.ReadUint8()
			if err != nil {
				err = msgp.WrapError(err, "dataVersion")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *metacache) EncodeMsg(en *msgp.Writer) (err error) {

Cache Events are exposed via the EventListener API.  Typical scenarios are below.

### Cache Hit

In the ideal scenario the cache can fulfill the request without any conditional call to the network.
This will skip the normal events such as DNS, connecting to the network, and downloading the response body.

As recommended by the HTTP RFC the max age of a document is defaulted to 10% of the 

<img src="/img/tutorial/body-fields/image02.png">

## Technical Details { #technical-details }

/// tip

If you are already using **FastAPI** version **0.99.0 or above**, you can probably **skip** these details.

They are more relevant for older versions, before OpenAPI 3.1.0 was available.

You can consider this a brief OpenAPI and JSON Schema **history lesson**. 🤓

///

/// warning

 * we'll make sure to filter the list of packages before generating the file.
 *
 * It is assumed that the layout of the directories follow the JVM conventions. This allows us to effectively skip opening the class files to determine the real package name.
 */
@CacheableTask
abstract class PackageListGenerator : DefaultTask() {

    companion object {
        // Things we do not want to shade

        // 1. It's a merge commit.
        // 2. One of its parent commits is from master only.
        // 3. Another parent commit is not from master but from release branch.
        // Otherwise, skip this commit.
        List<String> p1Branches = branchesOf(parentCommits[0])
        List<String> p2Branches = branchesOf(parentCommits[1])

        println("$commit parents: $parentCommits")

      boolean addToSet = true;
      while (iterator.hasNext()) {
        Class<?> current = iterator.next();
        if (current == itf || itf.isAssignableFrom(current)) {
          // Skip any super interface of the ones that are already included.
          addToSet = false;
          break;
        }
      }
      if (addToSet) {
        interfaceClasses.add(itf);
      }
    }