<itemvalue="Write operations require an explicit transaction."/>
<itemvalue="recommend"/>
<itemvalue="recommand"/>
<itemvalue="recommands"/>
<itemvalue="add Sort By Internal"/>
<itemvalue="except"/>
<itemvalue="优先级"/>
<itemvalue="staple"/>
<itemvalue="dessert"/>
<itemvalue="condiment"/>
<itemvalue="aquatic"/>
<itemvalue="类别"/>
<itemvalue="Performs the [action] on each header. The [action] function is called with each header's name and a list of the header's values. The casing of the name string is determined by the last [add] or [set] operation for that particular header, which defaults to lower-casing the header name unless explicitly set to preserve the case."/>
<itemvalue="Sets the header [name] to [value]. Removes all existing values for the header named [name] and then [add]s [value] to it."/>
<itemvalue="set"/>
<itemvalue="preserve Header Case"/>
<itemvalue="relaxed Durability"/>
<itemvalue="序号"/>
<itemvalue="Paragraph Syntax"/>
<itemvalue="Fenced Code Block Syntax"/>
<itemvalue="Invokes [action] on each element of this iterable in iteration order. Example: ```dart final numbers = <int>[1, 2, 6, 7]; numbers.forEach(print); 1 2 6 7 ```"/>
<itemvalue="Executes [action] on each element of this stream. Completes the returned [Future] when all elements of this stream have been processed. If this stream emits an error, or if the call to [action] throws, the returned future completes with that error, and processing stops."/>
<itemvalue="summary"/>
<itemvalue="简介"/>
<itemvalue="介绍"/>
<itemvalue="Waits for multiple futures to complete and collects their results. Returns a future which will complete once all the provided futures have completed, either with their results, or with an error if any of the provided futures fail. The value of the returned future will be a list of all the values that were produced in the order that the futures are provided by iterating [futures]. If any future completes with an error, then the returned future completes with that error. If further futures also complete with errors, those errors are discarded. If `eagerError` is true, the returned future completes with an error immediately on the first error from one of the futures. Otherwise all futures must complete before the returned future is completed (still with the first error; the remaining errors are silently dropped). In the case of an error, [cleanUp] (if provided), is invoked on any non-null result of successful futures. This makes it possible to `cleanUp` resources that would otherwise be lost (since the returned future does not provide access to these values). The [cleanUp] function is unused if there is no error. The call to [cleanUp] should not throw. If it does, the error will be an uncaught asynchronous error."/>
<itemvalue="Performs an action for each element of the iterable, in turn. The [action] may be either synchronous or asynchronous. Calls [action] with each element in [elements] in order. If the call to [action] returns a `Future<T>`, the iteration waits until the future is completed before continuing with the next element. Returns a [Future] that completes with `null` when all elements have been processed. Non-[Future] return values, and completion-values of returned [Future]s, are discarded. Any error from [action], synchronous or asynchronous, will stop the iteration and be reported in the returned [Future]."/>
<itemvalue="探针"/>
<itemvalue="锚点"/>
<itemvalue="fixes"/>
<itemvalue="Dish"/>
<itemvalue="Dishes"/>
<itemvalue="公式"/>
<itemvalue="Ingredients"/>
<itemvalue="食材"/>
<itemvalue="Copies this file. If [newPath] is a relative path, it is resolved against the current working directory ([Directory.current]). Returns a `Future<File>` that completes with a [File] for the copied file. If [newPath] identifies an existing file, that file is removed first. If [newPath] identifies an existing directory, the operation fails and the future completes with an exception."/>
<itemvalue="copy"/>
<itemvalue="catch Error"/>
<itemvalue="catch Error"/>
<itemvalue="Integer Division By Zero Exception"/>
<itemvalue="Integer Division By Zero Exception"/>
<itemvalue="NOTE: By default, the Runner class does not use the `MirrorsReflector`, or any reflector, by default. If your application is using any sort of functionality reliant on annotations or reflection, either include the MirrorsReflector, or use a static reflector variant. The following use cases require reflection: Use of Controllers, via @Expose() or @ExposeWS() Use of dependency injection into constructors, whether in controllers or plain `container.make` calls Use of the `ioc` function in any route The `MirrorsReflector` from `package:angel_containermirrors.dart` is by far the most convenient pattern, so use it if possible. However, the following alternatives exist: Generation via `package:angel_container_generator` Creating an instance of `StaticReflector` Manually implementing the `Reflector` interface (cumbersome; not recommended) As of January 4th, 2018, the documentation has not yet been updated to state this, so in the meantime, visit the Angel chat for further questions: https:gitter.imangel_dartdiscussion"/>
<itemvalue="NOTE: By default, the Runner class does not use the `MirrorsReflector`, or any reflector, by default. If your application is using any sort of functionality reliant on annotations or reflection, either include the MirrorsReflector, or use a static reflector variant. The following use cases require reflection: Use of Controllers, via @Expose() or @ExposeWS() Use of dependency injection into constructors, whether in controllers or plain `container.make` calls Use of the `ioc` function in any route The `MirrorsReflector` from `package:angel_containermirrors.dart` is by far the most convenient pattern, so use it if possible. However, the following alternatives exist: Generation via `package:angel_container_generator` Creating an instance of `StaticReflector` Manually implementing the `Reflector` interface (cumbersome; not recommended) As of January 4th, 2018, the documentation has not yet been updated to state this, so in the meantime, visit the Angel chat for further questions: https:gitter.imangel_dartdiscussion"/>
@ -17,41 +55,17 @@
<itemvalue="_unary Operations"/>
<itemvalue="_unary Operations"/>
<itemvalue="Gobbles a list of arguments within the context of a function call or array literal. This function also assumes that the opening character `(` or `[` has already been gobbled, and gobbles expressions and commas until the terminator character `)` or `]` is encountered. e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`"/>
<itemvalue="Gobbles a list of arguments within the context of a function call or array literal. This function also assumes that the opening character `(` or `[` has already been gobbled, and gobbles expressions and commas until the terminator character `)` or `]` is encountered. e.g. `foo(bar, baz)`, `my_func()`, or `[bar, baz]`"/>
<itemvalue="Responsible for parsing a group of things within parentheses `()` This function assumes that it needs to gobble the opening parenthesis and then tries to gobble everything within that parenthesis, assuming that the next thing it should see is the close parenthesis. If not, then the expression probably doesn't have a `)`"/>
<itemvalue="Responsible for parsing a group of things within parentheses `()` This function assumes that it needs to gobble the opening parenthesis and then tries to gobble everything within that parenthesis, assuming that the next thing it should see is the close parenthesis. If not, then the expression probably doesn't have a `)`"/>
<itemvalue="handle multi websocket client at same time."/>
<itemvalue="Advances the iterator to the next element of the iteration. Should be called before reading [current]. It the call to `moveNext` returns `true`, then [current] will contain the next element of the iteration until `moveNext` is called again. If the call returns `false`, there are no further elements and [current] should not be used any more. It is safe to call [moveNext] after it has already returned `false`, but it must keep returning `false` and not have any other effect. A call to `moveNext` may throw for various reasons, including a concurrent change to an underlying collection. If that happens, the iterator may be in an inconsistent state, and any further behavior of the iterator is unspecified, including the effect of reading [current]."/>
<itemvalue="Allows constant time add, remove-at-ends and peek operations."/>
<itemvalue="A [Queue] is a collection that can be manipulated at both ends. One can iterate over the elements of a queue through [forEach] or with an [Iterator]. It is generally not allowed to modify the queue (add or remove entries) while an operation on the queue is being performed, for example during a call to [forEach]. Modifying the queue while it is being iterated will most likely break the iteration. This goes both for using the [iterator] directly, or for iterating an `Iterable` returned by a method like [map] or [where]."/>
<itemvalue="The structure is efficient for any queue or stack usage."/>
<itemvalue="Keeps a cyclic buffer of elements, and grows to a larger buffer when it fills up. This guarantees constant time peek and remove operations, and amortized constant time add operations."/>
