* If {@code element} is not {@code null}, child configuration element with the specified name will
     * be unmarshalled.
     *
     * @param configuration The configuration to unmarshal, may be {@code null}.
     * @param element Configuration element name to unmarshal or {@code null} to unmarshal entire configuration.

 *
 * <ul>
 *   <li>does not allow parallel edges
 *   <li>does not allow self-loops
 *   <li>orders {@link Network#nodes()} and {@link Network#edges()} in the order in which the
 *       elements were added (insertion order)
 * </ul>
 *
 * <p>{@code Network}s built by this class also guarantee that each collection-returning accessor
 * returns a <b>(live) unmodifiable view</b>; see <a

        return as(type, tagged.getBaseObject());
    }

    /**
     * Gets an element from a DLSequence at the specified index and casts it to the specified type
     * @param <T> the target ASN.1 primitive type
     * @param type the target class type
     * @param sequence the DLSequence
     * @param index the element index
     * @return sequence element cast to type
     * @throws PACDecodingException if types are incompatible
     */

                new TestStringSortedSetGenerator() {
                  @Override
                  protected SortedSet<String> create(String[] elements) {
                    return new StandardImplForwardingSortedSet<>(
                        new SafeTreeSet<String>(asList(elements)));
                  }

                  @Override
                  public List<String> order(List<String> insertionOrder) {

  @Override
  void setCountCheckReturnValue(E element, int count) {
    assertTrue(
        "setCount() with the correct expected present count should return true",
        setCount(element, count));
  }

  @Override
  void setCountNoCheckReturnValue(E element, int count) {
    setCount(element, count);
  }

  @CanIgnoreReturnValue
  private boolean setCount(E element, int count) {

// CHECKSTYLE_OFF: RegexpHeader
/**
 * This package contains non-functional annotations which are
 * used to tag various elements and help users understanding
 * how those types should be used.
 *
 * @since 4.0.0
 */
@Experimental

@app.get("/items/", tags=["items"])
async def read_items():
    return [{"name": "Foo", "price": 42}]


@app.get("/users/", tags=["users"])
async def read_users():
    return [{"username": "johndoe"}]


@app.get("/elements/", tags=["items"], deprecated=True)
async def read_elements():

                Collections.reverse(list);
                return list;
              }

              @Override
              public Set<E> create(Object... elements) {
                NavigableSet<E> navigableSet = (NavigableSet<E>) delegate.create(elements);
                return navigableSet.descendingSet();
              }
            })
        .named(parentBuilder.getName() + " descending")

    return rowKeyToIndex.containsKey(rowKey);
  }

  @Override
  public boolean containsValue(@Nullable Object value) {
    for (@Nullable V[] row : array) {
      for (V element : row) {
        if (Objects.equals(value, element)) {
          return true;
        }
      }
    }
    return false;
  }

  @Override
  public @Nullable V get(@Nullable Object rowKey, @Nullable Object columnKey) {

            // Verify only one plugin remains
            Editor editor = new Editor(document);
            Element root = editor.root();
            Element build = DomUtils.findChildElement(root, "build");
            Element pluginManagement = DomUtils.findChildElement(build, "pluginManagement");
            Element plugins = DomUtils.findChildElement(pluginManagement, "plugins");