Merge branch 'main' into hardware
This commit is contained in:
Robert Bendun
commit
f3cfd3de1c
28
CHANGELOG.md
28
CHANGELOG.md
|
|
@ -13,6 +13,34 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
|
||||||
- knob and button updates
|
- knob and button updates
|
||||||
- support for CV as MIDI output inside Musique
|
- support for CV as MIDI output inside Musique
|
||||||
|
|
||||||
|
## [0.4.0]
|
||||||
|
|
||||||
|
### Added
|
||||||
|
|
||||||
|
- Builtin function documentation generation from C++ Musique implementation source code
|
||||||
|
- New builtins: digits
|
||||||
|
- Negative numbers!
|
||||||
|
- Version command via `:version` in REPL or `--version`, `-v` in command line.
|
||||||
|
- Introduced start synchronization with builtins: `peers` and `start`
|
||||||
|
- Connection with MIDI ports via parameters dropped in favour of function using context system: `port`
|
||||||
|
- Listing ports via REPL command: `:ports` instead of commandline parameter
|
||||||
|
- Building release with `make musique.zip` using Docker
|
||||||
|
|
||||||
|
### Changed
|
||||||
|
|
||||||
|
- Readme from Polish to English
|
||||||
|
|
||||||
|
### Removed
|
||||||
|
|
||||||
|
- Release script builder
|
||||||
|
|
||||||
|
### Fixed
|
||||||
|
|
||||||
|
- `ceil`, `round`, `floor` didn't behave well with negative numbers
|
||||||
|
- `duration` wasn't filling note length from context and summed all notes inside chord, when it should take max
|
||||||
|
- `try` evaluated arguments too quickly
|
||||||
|
- Nested arithmetic expression with undefined operator reports proper error and don't crash
|
||||||
|
|
||||||
## [0.3.1]
|
## [0.3.1]
|
||||||
|
|
||||||
### Fixed
|
### Fixed
|
||||||
|
|
|
||||||
43
Dockerfile
43
Dockerfile
|
|
@ -1,8 +1,43 @@
|
||||||
FROM ubuntu:20.04
|
FROM ubuntu:20.04 AS linux
|
||||||
|
|
||||||
ARG TZ=Europe/Warsaw
|
ARG TZ=Europe/Warsaw
|
||||||
|
ARG VERSION
|
||||||
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
|
RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone
|
||||||
|
RUN apt update && apt install -y make software-properties-common zip unzip git
|
||||||
RUN apt update && apt upgrade -y && apt install -y build-essential software-properties-common zip unzip
|
|
||||||
RUN add-apt-repository ppa:ubuntu-toolchain-r/test
|
RUN add-apt-repository ppa:ubuntu-toolchain-r/test
|
||||||
RUN apt install -y gcc-11 g++-11 libasound2-dev
|
RUN apt install -y gcc-11 g++-11 libasound2-dev
|
||||||
|
RUN mkdir -p /src/
|
||||||
|
WORKDIR /src/
|
||||||
|
COPY config.mk Makefile /src/
|
||||||
|
COPY .git /src/.git/
|
||||||
|
COPY musique /src/musique/
|
||||||
|
COPY lib /src/lib/
|
||||||
|
COPY scripts /src/scripts/
|
||||||
|
RUN make clean && make CC=gcc-11 CXX=g++-11 VERSION="$VERSION"
|
||||||
|
|
||||||
|
|
||||||
|
FROM ubuntu:22.04 AS windows
|
||||||
|
ARG VERSION
|
||||||
|
RUN apt update && apt install -y git make gcc-mingw-w64-x86-64 g++-mingw-w64-x86-64
|
||||||
|
RUN mkdir -p /src/
|
||||||
|
WORKDIR /src/
|
||||||
|
COPY config.mk Makefile /src/
|
||||||
|
COPY .git /src/.git/
|
||||||
|
COPY musique /src/musique/
|
||||||
|
COPY lib /src/lib/
|
||||||
|
COPY scripts /src/scripts/
|
||||||
|
RUN make clean && make os=windows CC=x86_64-w64-mingw32-gcc-posix CXX=x86_64-w64-mingw32-g++-posix VERSION="$VERSION"
|
||||||
|
|
||||||
|
|
||||||
|
FROM ubuntu:22.04 AS release
|
||||||
|
RUN apt update && apt install -y zip pandoc python3 python-is-python3 pandoc
|
||||||
|
COPY CHANGELOG.md LICENSE /musique/
|
||||||
|
COPY examples /musique/examples/
|
||||||
|
COPY --from=windows /src/bin/musique.exe /musique/musique-windows.exe
|
||||||
|
COPY --from=linux /src/bin/musique /musique/musique-linux
|
||||||
|
|
||||||
|
COPY doc /doc/
|
||||||
|
COPY scripts /scripts/
|
||||||
|
RUN python /scripts/language-cmp-cheatsheet.py /doc/musique-vs-languages-cheatsheet.template \
|
||||||
|
&& bash -c 'cp /{doc,musique}/musique-vs-languages-cheatsheet.html'
|
||||||
|
RUN pandoc -o /musique/wprowadzenie.html /doc/wprowadzenie.md -s --toc
|
||||||
|
RUN zip -r musique.zip /musique/
|
||||||
|
|
|
||||||
11
Makefile
11
Makefile
|
|
@ -39,7 +39,16 @@ doc/musique-vs-languages-cheatsheet.html: doc/musique-vs-languages-cheatsheet.te
|
||||||
doc/wprowadzenie.html: doc/wprowadzenie.md
|
doc/wprowadzenie.html: doc/wprowadzenie.md
|
||||||
pandoc -o $@ $< -s --toc
|
pandoc -o $@ $< -s --toc
|
||||||
|
|
||||||
.PHONY: clean doc doc-open all test unit-tests release install
|
doc/functions.html: musique/interpreter/builtin_functions.cc scripts/document-builtin.py
|
||||||
|
scripts/document-builtin.py -o $@ $<
|
||||||
|
|
||||||
|
musique.zip:
|
||||||
|
docker build -t musique-builder --build-arg "VERSION=$(VERSION)" .
|
||||||
|
docker create --name musique musique-builder
|
||||||
|
docker cp musique:/musique.zip musique.zip
|
||||||
|
docker rm -f musique
|
||||||
|
|
||||||
|
.PHONY: clean doc doc-open all test unit-tests release install musique.zip
|
||||||
|
|
||||||
$(shell mkdir -p $(subst musique/,bin/$(os)/,$(shell find musique/* -type d)))
|
$(shell mkdir -p $(subst musique/,bin/$(os)/,$(shell find musique/* -type d)))
|
||||||
$(shell mkdir -p $(subst musique/,bin/$(os)/debug/,$(shell find musique/* -type d)))
|
$(shell mkdir -p $(subst musique/,bin/$(os)/debug/,$(shell find musique/* -type d)))
|
||||||
|
|
|
||||||
55
README.md
55
README.md
|
|
@ -1,62 +1,22 @@
|
||||||
# Musique interpreter
|
# Musique interpreter
|
||||||
|
|
||||||
Interpreter języka Musique. Możliwy do wykorzystywania jako:
|
Reference implementation of Musique programming language.
|
||||||
|
|
||||||
- biblioteka interpretera języka dołączana do innego projektu (podobnie jak Lua);
|
## Building
|
||||||
- REPL działający w systemie GNU/Linux + ALSA wykonujący język Musique.
|
|
||||||
|
|
||||||
## Wymagane pakiety systemowe
|
Reference [`build_instructions.md`](./build_instructions.md).
|
||||||
|
|
||||||
Do poprawnego skompilowania i uruchomienia interpretera języka Musique należy posiadać zainstalowane następujące pakiety (lub ich odpowiedniki) – dla systemu GNU/Linux Ubuntu Desktop 22.04 są to:
|
## Syntax highlighting
|
||||||
|
|
||||||
- `build-essential` – pakiet zawierający podstawowe narzędzia do pracy z kodem źródłowym, takie jak m.in. kompilator;
|
|
||||||
- `libasound2-dev` – pakiet zawierający biblioteki programistyczne pakietu `libasound2`.
|
|
||||||
|
|
||||||
Można je zainstalować korzystając z polecenia:
|
|
||||||
|
|
||||||
```
|
|
||||||
$ sudo apt update
|
|
||||||
$ sudo apt install -y build-essential libasound2-dev
|
|
||||||
```
|
|
||||||
|
|
||||||
## Budowanie interpretera
|
|
||||||
|
|
||||||
- Aby wybudować wersję Linux+ALSA: `make`
|
|
||||||
- Aby wybudować wersję Windows: `make os=windows`
|
|
||||||
|
|
||||||
Żeby zainstalować interpreter języka Musique w systemie, należy dodatkowo wykonać polecenie:
|
|
||||||
|
|
||||||
```
|
|
||||||
# make install
|
|
||||||
```
|
|
||||||
|
|
||||||
*Uwaga*: powyższe polecenie instalacyjne musi zostać wykonane jako uprzywilejowany użytkownik (np. wykorzystując polecenie `sudo`).
|
|
||||||
|
|
||||||
## Dostępne komendy
|
|
||||||
|
|
||||||
- `make` - Buduje interpreter `bin/musique` (tryb release)
|
|
||||||
- `make debug` - Buduje interpreter `bin/debug/musique` (tryb debug)
|
|
||||||
- `make clean` - Usuwa reprodukowalne elementy projektu (automatycznie stworzone pliki binarne czy raporty)
|
|
||||||
|
|
||||||
### Dokumentacja
|
|
||||||
|
|
||||||
- `make doc` - Tworzy `doc/build/html/` zawierający dokumentację projektu
|
|
||||||
|
|
||||||
### Testowanie
|
|
||||||
|
|
||||||
- `make test` - Uruchom wszystkie dostępne testy automatyczne
|
|
||||||
|
|
||||||
## Kolorowanie składni
|
|
||||||
|
|
||||||
### Vim / Neovim
|
### Vim / Neovim
|
||||||
|
|
||||||
Skopiuj plik [etc/editor/musique.vim](etc/editor/musique.vim) do folderu `syntax` wewnątrz twojej konfiguracji Vima (Neovima). Np:
|
Copy [editor/musique.vim](editor/musique.vim) to `syntax` directory inside your Vim (Neovim) configuration.
|
||||||
|
|
||||||
```console
|
```console
|
||||||
$ cp editor/musique.vim ~/.config/nvim/syntax/
|
$ cp editor/musique.vim ~/.config/nvim/syntax/
|
||||||
```
|
```
|
||||||
|
|
||||||
Następnie musisz dodać ustawienie typu pliku na podstawie rozszerzenia wewnątrz twojej konfiguracji:
|
Next, you can add bindings for filetype:
|
||||||
|
|
||||||
```vim
|
```vim
|
||||||
au BufRead,BufNewFile *.mq set filetype=musique
|
au BufRead,BufNewFile *.mq set filetype=musique
|
||||||
|
|
@ -64,7 +24,7 @@ au BufRead,BufNewFile *.mq set filetype=musique
|
||||||
|
|
||||||
### Visual Studio Code
|
### Visual Studio Code
|
||||||
|
|
||||||
Skopiuj katalog [editor/vscode-musique](editor/vscode-musique) do folderu `<user home>/.vscode/extensions` i uruchom ponownie program VSCode.
|
Copy [editor/vscode-musique](editor/vscode-musique) directory to `<user home>/.vscode/extensions` and restart VS Code.
|
||||||
|
|
||||||
# Thanks to
|
# Thanks to
|
||||||
|
|
||||||
|
|
@ -72,5 +32,6 @@ Skopiuj katalog [editor/vscode-musique](editor/vscode-musique) do folderu `<user
|
||||||
- Creator of [bestline](https://github.com/jart/bestline) - [Justine Tunney](https://justinetunney.com/)
|
- Creator of [bestline](https://github.com/jart/bestline) - [Justine Tunney](https://justinetunney.com/)
|
||||||
- Creator of [rtmidi](https://github.com/thestk/rtmidi/) - [Gary P. Scavone](http://www.music.mcgill.ca/~gary/)
|
- Creator of [rtmidi](https://github.com/thestk/rtmidi/) - [Gary P. Scavone](http://www.music.mcgill.ca/~gary/)
|
||||||
- Creators of [serial](https://github.com/wjwwood/serial) - [William Woodall](https://github.com/wjwwood/) and [John Harrison](https://github.com/ashgti)
|
- Creators of [serial](https://github.com/wjwwood/serial) - [William Woodall](https://github.com/wjwwood/) and [John Harrison](https://github.com/ashgti)
|
||||||
|
- Creators of [link](https://github.com/Ableton/link)
|
||||||
|
|
||||||
and all contributors that created libraries above.
|
and all contributors that created libraries above.
|
||||||
|
|
|
||||||
|
|
@ -2,7 +2,7 @@
|
||||||
|
|
||||||
## Linux
|
## Linux
|
||||||
|
|
||||||
Consult README.md.
|
Use your local C++ compiler (supporting C++20) and ALSA dev libraries or included Dockerfile.
|
||||||
|
|
||||||
## MacOS
|
## MacOS
|
||||||
|
|
||||||
|
|
@ -23,5 +23,5 @@ Windows support is provided via cross compilation. Mingw GCC C++ compiler is req
|
||||||
$ make os=windows
|
$ make os=windows
|
||||||
```
|
```
|
||||||
|
|
||||||
will create `bin/musique.exe` that can be used on x86_64 Windows operating systems.
|
will create `bin/musique.exe` that can be used on x86_64 Windows operating systems or use included Dockerfile
|
||||||
|
|
||||||
|
|
|
||||||
14
config.mk
14
config.mk
|
|
@ -1,7 +1,19 @@
|
||||||
MAKEFLAGS="-j $(grep -c ^processor /proc/cpuinfo)"
|
MAKEFLAGS="-j $(grep -c ^processor /proc/cpuinfo)"
|
||||||
|
|
||||||
|
MAJOR := 4
|
||||||
|
MINOR := 0
|
||||||
|
PATCH := 0
|
||||||
|
COMMIT := gc$(shell git rev-parse --short HEAD 2>/dev/null)
|
||||||
|
|
||||||
|
ifeq ($(COMMIT),gc)
|
||||||
|
COMMIT = gcunknown
|
||||||
|
endif
|
||||||
|
|
||||||
|
VERSION := $(MAJOR).$(MINOR).$(PATCH)-dev+$(COMMIT)
|
||||||
|
|
||||||
CXXFLAGS:=$(CXXFLAGS) -std=c++20 -Wall -Wextra -Werror=switch -Werror=return-type -Werror=unused-result
|
CXXFLAGS:=$(CXXFLAGS) -std=c++20 -Wall -Wextra -Werror=switch -Werror=return-type -Werror=unused-result
|
||||||
CPPFLAGS:=$(CPPFLAGS) -Ilib/expected/ -I. -Ilib/bestline/ -Ilib/rtmidi/ -Ilib/serial/include/
|
CPPFLAGS:=$(CPPFLAGS) -DMusique_Version='"$(VERSION)"' \
|
||||||
|
-Ilib/expected/ -I. -Ilib/bestline/ -Ilib/rtmidi/ -Ilib/link/include -Ilib/asio/include/ -Ilib/serial/include/
|
||||||
LDFLAGS=-flto
|
LDFLAGS=-flto
|
||||||
LDLIBS= -lpthread
|
LDLIBS= -lpthread
|
||||||
|
|
||||||
|
|
|
||||||
115
doc/functions.md
115
doc/functions.md
|
|
@ -1,115 +0,0 @@
|
||||||
# Lista wbudowanych funkcji języka Musique
|
|
||||||
|
|
||||||
* `bmp value` – zmienia wartość BMP z domyślnej na `value`;
|
|
||||||
-`value` musi być liczbą całkowitą, domyślnie `120`;
|
|
||||||
|
|
||||||
* `call function args` – funkcja wywołująca funkcję `function`, która przekazuje `function` `args` jako argumenty wywoływanej fukncji;
|
|
||||||
|
|
||||||
* `ceil value` – operacja podobna do matematycznej funkcji podłogi (zaokrąglenie liczby do pierwszej liczby całkowitej mniejszej lub równej tej liczbie);
|
|
||||||
- `value` – musi być to wartość o typie Number lub tablica takich wartości;
|
|
||||||
|
|
||||||
* `chord (notes)` – konstruuje akord z `notes`:
|
|
||||||
- `notes` – `notes` definiowane są następująco: `(<litera_nuty> <numer_oktawy> <czas_trwania>)`:
|
|
||||||
- np. `(c 4 1)` – dźwięk C w 4 oktawie, o długości całej nuty;
|
|
||||||
|
|
||||||
* `down value` – sekwencyjnie zwraca liczby całkowite, począwszy od `value` do 0:
|
|
||||||
- `value` – musi być liczbą całkowitą;
|
|
||||||
|
|
||||||
* `flat args` – łączy `args` w tablicę bez zagnieżdżeń (tzn. "odpakowuje" zawartość zagnieżdżonych tablic i zawiera je w pojedyńczej tabeli):
|
|
||||||
- `args` - tablica, w tym tablica z zagnieżdżeniami;
|
|
||||||
|
|
||||||
* `floor value` – operacja podobna do matematycznej funkcji podłogi (zaokrąglenie liczby do pierwszej liczby całkowitej większej lub równej tej liczbie);
|
|
||||||
- `value` – musi być to zmienna o typie Number lub tablica takich zmiennych;
|
|
||||||
|
|
||||||
* `fold args` – używa elementów tablicy jako argumentów podanej funkcji:
|
|
||||||
- `args` – postaci `tablica funkcja` lub `tablica wartość_startowa funkcja`;
|
|
||||||
|
|
||||||
* `for vect` – iteruje po elementach wektora `vect`:
|
|
||||||
- `vect` - kontener wartości, musi posiadać typ Vector;
|
|
||||||
|
|
||||||
* `hash vect` – standardowa funkcja haszująca, zwraca jeden hash połączonych wartości z `vect`:
|
|
||||||
- `vect` - kontener wartości, mogą być dowolnego typu;
|
|
||||||
|
|
||||||
* `if cond [if_true] [if_false]` – wyrażenie warunkowe: jeżeli `cond` będzie prawdą, zostanie wykonany kod z `[if_true]`, w przeciwnym wypadku wykonany zostanie kod z `[if_false]` – fragment `[if_false]` jest opcjonalny;
|
|
||||||
|
|
||||||
* `incoming args` – pozwala na rozpatrzenie przychodzących komunikatów MIDI (`note_on` i `note_off`), odpowiednio;
|
|
||||||
- `args` – konstrukcja `komunikat, nuta`;
|
|
||||||
|
|
||||||
* `instrument args` – pozwala na zmianę instrumentu:
|
|
||||||
- `args` – może przyjmować sam numer programu, lub parę `numer_programu, kanał`;
|
|
||||||
|
|
||||||
* `len args` – zwraca długość kontenera `args`, a jeżeli `args` nie jest wektorem ustawia domyślną długość trwania dźwięku, domyślnie ćwierćnuta;
|
|
||||||
|
|
||||||
* `max args` – zwraca maksimum z `args`;
|
|
||||||
|
|
||||||
* `min args` – zwraca minimum z `args`;
|
|
||||||
|
|
||||||
* `mix args` – algorytmicznie miesza wszystkie elementy z `args`:
|
|
||||||
- `args` – tablica elementów, może być tablicą z zagnieżdżeniami;
|
|
||||||
|
|
||||||
* `note_off args` – w zależności od kształtu `args`:
|
|
||||||
- jeżeli `args` są w postaci `(kanał, nuta)` – wyłącza nutę na danym kanale:
|
|
||||||
- `kanał` – liczba całkowita;
|
|
||||||
- `nuta` – postać podobna do `notes` z `chord notes`;
|
|
||||||
- jeżeli `args` są w postaci `(kanał, akord)` – wyłącza wszystkie nuty z danego akordu na danym kanale;
|
|
||||||
|
|
||||||
* `note_on args` – analogicznie do `note_off args`;
|
|
||||||
|
|
||||||
* `nprimes value` – generuje `value` kolejnych liczb pierwszych:
|
|
||||||
- `value` – musi być typu Number;
|
|
||||||
|
|
||||||
* `oct value` – analogicznie do `bpm value`, wartość domyślna to 4;
|
|
||||||
|
|
||||||
* `par args` – gra współbieżnie pierwszy dźwięk z `args` z pozostałymi dźwiękami z `args`:
|
|
||||||
- `args` – postać `(note, ...)`, powinien być rozmiaru co najmniej 2:
|
|
||||||
- `note` – postać podobna do `notes` z `chords notes`;
|
|
||||||
|
|
||||||
* `partition args` – dzieli `args` na dwie grupy wedle danej funkcji:
|
|
||||||
- `args` – powinno przyjąć formę `(funkcja, tablica())`
|
|
||||||
|
|
||||||
* `permute args` – permutuje `args`:
|
|
||||||
- `args` – tablica obiektów;
|
|
||||||
|
|
||||||
* `pgmchange args` – analogicznie do `instrument args`;
|
|
||||||
|
|
||||||
* `play args` – gra `args`:
|
|
||||||
- `args` – mogą być to pojedyncze nuty, tablica nut oraz bloki kodu (nuty analogicznie jak w `chord notes`);
|
|
||||||
|
|
||||||
* `program_change args` – analogicznie do `instrument args`;
|
|
||||||
|
|
||||||
* `range args` – zwraca tablicę wartości liczbowych w podanych w `args` zakresie:
|
|
||||||
- `args` – postać `stop`, `start stop` lub `start stop step`;
|
|
||||||
|
|
||||||
* `reverse args` – odwraca kolejność elementów `args`;
|
|
||||||
- `args` – powinna być to tablica;
|
|
||||||
|
|
||||||
* `rotate args` – przenosi na koniec tablicy wskazaną ilość elementów:
|
|
||||||
- `args` – musi być postaci `liczba tablica`;
|
|
||||||
|
|
||||||
* `round value` – zaokrągla wartość zgodnie z reguałmi matematyki:
|
|
||||||
- `value` – musi być to wartość liczbowa;
|
|
||||||
|
|
||||||
* `shuffle args` – tasuje elementy `args`:
|
|
||||||
- `args` – powinna być to tablica;
|
|
||||||
|
|
||||||
* `sim` – #TODO
|
|
||||||
|
|
||||||
* `sort args` – sortuje elementy `args`:
|
|
||||||
- `args` – powinna być to tablica;
|
|
||||||
|
|
||||||
* `try args` – próbuje wykonać wszystkie bloki kodu poza ostatnim, a jeżeli w trakcie tej próby natrafi na błąd, wykonuje ostatni blok:
|
|
||||||
- `args` – musi być to co najmniej jeden blok kodu Musique;
|
|
||||||
|
|
||||||
* `typeof variable` – zwraca typ wskazanej `variable`;
|
|
||||||
|
|
||||||
* `uniq args` – zwraca tablicę elementów, z której usunięto następujące po sobie powtórzenia:
|
|
||||||
- `args` – powinna być to tablica;
|
|
||||||
|
|
||||||
* `unique args` – zwraca tablicę elementów, z której usunięto powtórzenia:
|
|
||||||
- `args` – powinna być to tablica;
|
|
||||||
|
|
||||||
* `up value` – analogicznie do `down value`;
|
|
||||||
|
|
||||||
* `update args` – aktualizuje element tablicy do nowej wartości:
|
|
||||||
- `args` – postaci `tablica indeks wartość`;
|
|
||||||
|
|
||||||
|
|
@ -74,7 +74,7 @@ r add 1, 3
|
||||||
|
|
||||||
n Wywołanie funkcji
|
n Wywołanie funkcji
|
||||||
n nie przymujących argumentów
|
n nie przymujących argumentów
|
||||||
m constant := (say 42, 10);
|
m constant := (say 42, 10),
|
||||||
m say (call foo)
|
m say (call foo)
|
||||||
p def constant():
|
p def constant():
|
||||||
p print(42)
|
p print(42)
|
||||||
|
|
@ -199,7 +199,7 @@ c w SonicPi nie ma domyślnej długości nuty;
|
||||||
c za każdym razem trzeba ją definiować
|
c za każdym razem trzeba ją definiować
|
||||||
|
|
||||||
n Zmiana oktawy do 4tej
|
n Zmiana oktawy do 4tej
|
||||||
m oct 4;
|
m oct 4,
|
||||||
c w SonicPi domyślna oktawa
|
c w SonicPi domyślna oktawa
|
||||||
c jest ustalona jako 4
|
c jest ustalona jako 4
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -0,0 +1,4 @@
|
||||||
|
Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
|
||||||
|
Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
|
@ -0,0 +1,23 @@
|
||||||
|
Boost Software License - Version 1.0 - August 17th, 2003
|
||||||
|
|
||||||
|
Permission is hereby granted, free of charge, to any person or organization
|
||||||
|
obtaining a copy of the software and accompanying documentation covered by
|
||||||
|
this license (the "Software") to use, reproduce, display, distribute,
|
||||||
|
execute, and transmit the Software, and to prepare derivative works of the
|
||||||
|
Software, and to permit third-parties to whom the Software is furnished to
|
||||||
|
do so, all subject to the following:
|
||||||
|
|
||||||
|
The copyright notices in the Software and this entire statement, including
|
||||||
|
the above license grant, this restriction and the following disclaimer,
|
||||||
|
must be included in all copies of the Software, in whole or in part, and
|
||||||
|
all derivative works of the Software, unless such copies or derivative
|
||||||
|
works are solely in the form of machine-executable object code generated by
|
||||||
|
a source language processor.
|
||||||
|
|
||||||
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||||
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||||
|
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||||
|
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||||
|
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||||
|
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||||
|
DEALINGS IN THE SOFTWARE.
|
||||||
|
|
@ -0,0 +1,2 @@
|
||||||
|
Makefile
|
||||||
|
Makefile.in
|
||||||
|
|
@ -0,0 +1,658 @@
|
||||||
|
# find . -name "*.*pp" | sed -e 's/^\.\///' | sed -e 's/^.*$/ & \\/' | sort
|
||||||
|
nobase_include_HEADERS = \
|
||||||
|
asio/any_io_executor.hpp \
|
||||||
|
asio/associated_allocator.hpp \
|
||||||
|
asio/associated_cancellation_slot.hpp \
|
||||||
|
asio/associated_executor.hpp \
|
||||||
|
asio/associator.hpp \
|
||||||
|
asio/async_result.hpp \
|
||||||
|
asio/awaitable.hpp \
|
||||||
|
asio/basic_datagram_socket.hpp \
|
||||||
|
asio/basic_deadline_timer.hpp \
|
||||||
|
asio/basic_file.hpp \
|
||||||
|
asio/basic_io_object.hpp \
|
||||||
|
asio/basic_random_access_file.hpp \
|
||||||
|
asio/basic_raw_socket.hpp \
|
||||||
|
asio/basic_readable_pipe.hpp \
|
||||||
|
asio/basic_seq_packet_socket.hpp \
|
||||||
|
asio/basic_serial_port.hpp \
|
||||||
|
asio/basic_signal_set.hpp \
|
||||||
|
asio/basic_socket_acceptor.hpp \
|
||||||
|
asio/basic_socket.hpp \
|
||||||
|
asio/basic_socket_iostream.hpp \
|
||||||
|
asio/basic_socket_streambuf.hpp \
|
||||||
|
asio/basic_streambuf_fwd.hpp \
|
||||||
|
asio/basic_streambuf.hpp \
|
||||||
|
asio/basic_stream_file.hpp \
|
||||||
|
asio/basic_stream_socket.hpp \
|
||||||
|
asio/basic_waitable_timer.hpp \
|
||||||
|
asio/basic_writable_pipe.hpp \
|
||||||
|
asio/bind_allocator.hpp \
|
||||||
|
asio/bind_cancellation_slot.hpp \
|
||||||
|
asio/bind_executor.hpp \
|
||||||
|
asio/buffered_read_stream_fwd.hpp \
|
||||||
|
asio/buffered_read_stream.hpp \
|
||||||
|
asio/buffered_stream_fwd.hpp \
|
||||||
|
asio/buffered_stream.hpp \
|
||||||
|
asio/buffered_write_stream_fwd.hpp \
|
||||||
|
asio/buffered_write_stream.hpp \
|
||||||
|
asio/buffer.hpp \
|
||||||
|
asio/buffer_registration.hpp \
|
||||||
|
asio/buffers_iterator.hpp \
|
||||||
|
asio/cancellation_signal.hpp \
|
||||||
|
asio/cancellation_state.hpp \
|
||||||
|
asio/cancellation_type.hpp \
|
||||||
|
asio/co_spawn.hpp \
|
||||||
|
asio/completion_condition.hpp \
|
||||||
|
asio/compose.hpp \
|
||||||
|
asio/connect.hpp \
|
||||||
|
asio/connect_pipe.hpp \
|
||||||
|
asio/coroutine.hpp \
|
||||||
|
asio/deadline_timer.hpp \
|
||||||
|
asio/defer.hpp \
|
||||||
|
asio/detached.hpp \
|
||||||
|
asio/detail/array_fwd.hpp \
|
||||||
|
asio/detail/array.hpp \
|
||||||
|
asio/detail/assert.hpp \
|
||||||
|
asio/detail/atomic_count.hpp \
|
||||||
|
asio/detail/base_from_cancellation_state.hpp \
|
||||||
|
asio/detail/base_from_completion_cond.hpp \
|
||||||
|
asio/detail/bind_handler.hpp \
|
||||||
|
asio/detail/blocking_executor_op.hpp \
|
||||||
|
asio/detail/buffered_stream_storage.hpp \
|
||||||
|
asio/detail/buffer_resize_guard.hpp \
|
||||||
|
asio/detail/buffer_sequence_adapter.hpp \
|
||||||
|
asio/detail/bulk_executor_op.hpp \
|
||||||
|
asio/detail/call_stack.hpp \
|
||||||
|
asio/detail/chrono.hpp \
|
||||||
|
asio/detail/chrono_time_traits.hpp \
|
||||||
|
asio/detail/completion_handler.hpp \
|
||||||
|
asio/detail/concurrency_hint.hpp \
|
||||||
|
asio/detail/conditionally_enabled_event.hpp \
|
||||||
|
asio/detail/conditionally_enabled_mutex.hpp \
|
||||||
|
asio/detail/config.hpp \
|
||||||
|
asio/detail/consuming_buffers.hpp \
|
||||||
|
asio/detail/cstddef.hpp \
|
||||||
|
asio/detail/cstdint.hpp \
|
||||||
|
asio/detail/date_time_fwd.hpp \
|
||||||
|
asio/detail/deadline_timer_service.hpp \
|
||||||
|
asio/detail/dependent_type.hpp \
|
||||||
|
asio/detail/descriptor_ops.hpp \
|
||||||
|
asio/detail/descriptor_read_op.hpp \
|
||||||
|
asio/detail/descriptor_write_op.hpp \
|
||||||
|
asio/detail/dev_poll_reactor.hpp \
|
||||||
|
asio/detail/epoll_reactor.hpp \
|
||||||
|
asio/detail/eventfd_select_interrupter.hpp \
|
||||||
|
asio/detail/event.hpp \
|
||||||
|
asio/detail/executor_function.hpp \
|
||||||
|
asio/detail/executor_op.hpp \
|
||||||
|
asio/detail/fd_set_adapter.hpp \
|
||||||
|
asio/detail/fenced_block.hpp \
|
||||||
|
asio/detail/functional.hpp \
|
||||||
|
asio/detail/future.hpp \
|
||||||
|
asio/detail/gcc_arm_fenced_block.hpp \
|
||||||
|
asio/detail/gcc_hppa_fenced_block.hpp \
|
||||||
|
asio/detail/gcc_sync_fenced_block.hpp \
|
||||||
|
asio/detail/gcc_x86_fenced_block.hpp \
|
||||||
|
asio/detail/global.hpp \
|
||||||
|
asio/detail/handler_alloc_helpers.hpp \
|
||||||
|
asio/detail/handler_cont_helpers.hpp \
|
||||||
|
asio/detail/handler_invoke_helpers.hpp \
|
||||||
|
asio/detail/handler_tracking.hpp \
|
||||||
|
asio/detail/handler_type_requirements.hpp \
|
||||||
|
asio/detail/handler_work.hpp \
|
||||||
|
asio/detail/hash_map.hpp \
|
||||||
|
asio/detail/impl/buffer_sequence_adapter.ipp \
|
||||||
|
asio/detail/impl/descriptor_ops.ipp \
|
||||||
|
asio/detail/impl/dev_poll_reactor.hpp \
|
||||||
|
asio/detail/impl/dev_poll_reactor.ipp \
|
||||||
|
asio/detail/impl/epoll_reactor.hpp \
|
||||||
|
asio/detail/impl/epoll_reactor.ipp \
|
||||||
|
asio/detail/impl/eventfd_select_interrupter.ipp \
|
||||||
|
asio/detail/impl/handler_tracking.ipp \
|
||||||
|
asio/detail/impl/io_uring_descriptor_service.ipp \
|
||||||
|
asio/detail/impl/io_uring_file_service.ipp \
|
||||||
|
asio/detail/impl/io_uring_service.hpp \
|
||||||
|
asio/detail/impl/io_uring_service.ipp \
|
||||||
|
asio/detail/impl/io_uring_socket_service_base.ipp \
|
||||||
|
asio/detail/impl/kqueue_reactor.hpp \
|
||||||
|
asio/detail/impl/kqueue_reactor.ipp \
|
||||||
|
asio/detail/impl/null_event.ipp \
|
||||||
|
asio/detail/impl/pipe_select_interrupter.ipp \
|
||||||
|
asio/detail/impl/posix_event.ipp \
|
||||||
|
asio/detail/impl/posix_mutex.ipp \
|
||||||
|
asio/detail/impl/posix_serial_port_service.ipp \
|
||||||
|
asio/detail/impl/posix_thread.ipp \
|
||||||
|
asio/detail/impl/posix_tss_ptr.ipp \
|
||||||
|
asio/detail/impl/reactive_descriptor_service.ipp \
|
||||||
|
asio/detail/impl/reactive_socket_service_base.ipp \
|
||||||
|
asio/detail/impl/resolver_service_base.ipp \
|
||||||
|
asio/detail/impl/scheduler.ipp \
|
||||||
|
asio/detail/impl/select_reactor.hpp \
|
||||||
|
asio/detail/impl/select_reactor.ipp \
|
||||||
|
asio/detail/impl/service_registry.hpp \
|
||||||
|
asio/detail/impl/service_registry.ipp \
|
||||||
|
asio/detail/impl/signal_set_service.ipp \
|
||||||
|
asio/detail/impl/socket_ops.ipp \
|
||||||
|
asio/detail/impl/socket_select_interrupter.ipp \
|
||||||
|
asio/detail/impl/strand_executor_service.hpp \
|
||||||
|
asio/detail/impl/strand_executor_service.ipp \
|
||||||
|
asio/detail/impl/strand_service.hpp \
|
||||||
|
asio/detail/impl/strand_service.ipp \
|
||||||
|
asio/detail/impl/thread_context.ipp \
|
||||||
|
asio/detail/impl/throw_error.ipp \
|
||||||
|
asio/detail/impl/timer_queue_ptime.ipp \
|
||||||
|
asio/detail/impl/timer_queue_set.ipp \
|
||||||
|
asio/detail/impl/win_event.ipp \
|
||||||
|
asio/detail/impl/win_iocp_file_service.ipp \
|
||||||
|
asio/detail/impl/win_iocp_handle_service.ipp \
|
||||||
|
asio/detail/impl/win_iocp_io_context.hpp \
|
||||||
|
asio/detail/impl/win_iocp_io_context.ipp \
|
||||||
|
asio/detail/impl/win_iocp_serial_port_service.ipp \
|
||||||
|
asio/detail/impl/win_iocp_socket_service_base.ipp \
|
||||||
|
asio/detail/impl/win_mutex.ipp \
|
||||||
|
asio/detail/impl/win_object_handle_service.ipp \
|
||||||
|
asio/detail/impl/winrt_ssocket_service_base.ipp \
|
||||||
|
asio/detail/impl/winrt_timer_scheduler.hpp \
|
||||||
|
asio/detail/impl/winrt_timer_scheduler.ipp \
|
||||||
|
asio/detail/impl/winsock_init.ipp \
|
||||||
|
asio/detail/impl/win_static_mutex.ipp \
|
||||||
|
asio/detail/impl/win_thread.ipp \
|
||||||
|
asio/detail/impl/win_tss_ptr.ipp \
|
||||||
|
asio/detail/io_control.hpp \
|
||||||
|
asio/detail/io_object_impl.hpp \
|
||||||
|
asio/detail/io_uring_descriptor_read_at_op.hpp \
|
||||||
|
asio/detail/io_uring_descriptor_read_op.hpp \
|
||||||
|
asio/detail/io_uring_descriptor_service.hpp \
|
||||||
|
asio/detail/io_uring_descriptor_write_at_op.hpp \
|
||||||
|
asio/detail/io_uring_descriptor_write_op.hpp \
|
||||||
|
asio/detail/io_uring_file_service.hpp \
|
||||||
|
asio/detail/io_uring_null_buffers_op.hpp \
|
||||||
|
asio/detail/io_uring_operation.hpp \
|
||||||
|
asio/detail/io_uring_service.hpp \
|
||||||
|
asio/detail/io_uring_socket_accept_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_connect_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_recvfrom_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_recvmsg_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_recv_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_send_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_sendto_op.hpp \
|
||||||
|
asio/detail/io_uring_socket_service_base.hpp \
|
||||||
|
asio/detail/io_uring_socket_service.hpp \
|
||||||
|
asio/detail/io_uring_wait_op.hpp \
|
||||||
|
asio/detail/is_buffer_sequence.hpp \
|
||||||
|
asio/detail/is_executor.hpp \
|
||||||
|
asio/detail/keyword_tss_ptr.hpp \
|
||||||
|
asio/detail/kqueue_reactor.hpp \
|
||||||
|
asio/detail/limits.hpp \
|
||||||
|
asio/detail/local_free_on_block_exit.hpp \
|
||||||
|
asio/detail/macos_fenced_block.hpp \
|
||||||
|
asio/detail/memory.hpp \
|
||||||
|
asio/detail/mutex.hpp \
|
||||||
|
asio/detail/non_const_lvalue.hpp \
|
||||||
|
asio/detail/noncopyable.hpp \
|
||||||
|
asio/detail/null_event.hpp \
|
||||||
|
asio/detail/null_fenced_block.hpp \
|
||||||
|
asio/detail/null_global.hpp \
|
||||||
|
asio/detail/null_mutex.hpp \
|
||||||
|
asio/detail/null_reactor.hpp \
|
||||||
|
asio/detail/null_signal_blocker.hpp \
|
||||||
|
asio/detail/null_socket_service.hpp \
|
||||||
|
asio/detail/null_static_mutex.hpp \
|
||||||
|
asio/detail/null_thread.hpp \
|
||||||
|
asio/detail/null_tss_ptr.hpp \
|
||||||
|
asio/detail/object_pool.hpp \
|
||||||
|
asio/detail/old_win_sdk_compat.hpp \
|
||||||
|
asio/detail/operation.hpp \
|
||||||
|
asio/detail/op_queue.hpp \
|
||||||
|
asio/detail/pipe_select_interrupter.hpp \
|
||||||
|
asio/detail/pop_options.hpp \
|
||||||
|
asio/detail/posix_event.hpp \
|
||||||
|
asio/detail/posix_fd_set_adapter.hpp \
|
||||||
|
asio/detail/posix_global.hpp \
|
||||||
|
asio/detail/posix_mutex.hpp \
|
||||||
|
asio/detail/posix_serial_port_service.hpp \
|
||||||
|
asio/detail/posix_signal_blocker.hpp \
|
||||||
|
asio/detail/posix_static_mutex.hpp \
|
||||||
|
asio/detail/posix_thread.hpp \
|
||||||
|
asio/detail/posix_tss_ptr.hpp \
|
||||||
|
asio/detail/push_options.hpp \
|
||||||
|
asio/detail/reactive_descriptor_service.hpp \
|
||||||
|
asio/detail/reactive_null_buffers_op.hpp \
|
||||||
|
asio/detail/reactive_socket_accept_op.hpp \
|
||||||
|
asio/detail/reactive_socket_connect_op.hpp \
|
||||||
|
asio/detail/reactive_socket_recvfrom_op.hpp \
|
||||||
|
asio/detail/reactive_socket_recvmsg_op.hpp \
|
||||||
|
asio/detail/reactive_socket_recv_op.hpp \
|
||||||
|
asio/detail/reactive_socket_send_op.hpp \
|
||||||
|
asio/detail/reactive_socket_sendto_op.hpp \
|
||||||
|
asio/detail/reactive_socket_service_base.hpp \
|
||||||
|
asio/detail/reactive_socket_service.hpp \
|
||||||
|
asio/detail/reactive_wait_op.hpp \
|
||||||
|
asio/detail/reactor.hpp \
|
||||||
|
asio/detail/reactor_op.hpp \
|
||||||
|
asio/detail/reactor_op_queue.hpp \
|
||||||
|
asio/detail/recycling_allocator.hpp \
|
||||||
|
asio/detail/regex_fwd.hpp \
|
||||||
|
asio/detail/resolve_endpoint_op.hpp \
|
||||||
|
asio/detail/resolve_op.hpp \
|
||||||
|
asio/detail/resolve_query_op.hpp \
|
||||||
|
asio/detail/resolver_service_base.hpp \
|
||||||
|
asio/detail/resolver_service.hpp \
|
||||||
|
asio/detail/scheduler.hpp \
|
||||||
|
asio/detail/scheduler_operation.hpp \
|
||||||
|
asio/detail/scheduler_task.hpp \
|
||||||
|
asio/detail/scheduler_thread_info.hpp \
|
||||||
|
asio/detail/scoped_lock.hpp \
|
||||||
|
asio/detail/scoped_ptr.hpp \
|
||||||
|
asio/detail/select_interrupter.hpp \
|
||||||
|
asio/detail/select_reactor.hpp \
|
||||||
|
asio/detail/service_registry.hpp \
|
||||||
|
asio/detail/signal_blocker.hpp \
|
||||||
|
asio/detail/signal_handler.hpp \
|
||||||
|
asio/detail/signal_init.hpp \
|
||||||
|
asio/detail/signal_op.hpp \
|
||||||
|
asio/detail/signal_set_service.hpp \
|
||||||
|
asio/detail/socket_holder.hpp \
|
||||||
|
asio/detail/socket_ops.hpp \
|
||||||
|
asio/detail/socket_option.hpp \
|
||||||
|
asio/detail/socket_select_interrupter.hpp \
|
||||||
|
asio/detail/socket_types.hpp \
|
||||||
|
asio/detail/solaris_fenced_block.hpp \
|
||||||
|
asio/detail/source_location.hpp \
|
||||||
|
asio/detail/static_mutex.hpp \
|
||||||
|
asio/detail/std_event.hpp \
|
||||||
|
asio/detail/std_fenced_block.hpp \
|
||||||
|
asio/detail/std_global.hpp \
|
||||||
|
asio/detail/std_mutex.hpp \
|
||||||
|
asio/detail/std_static_mutex.hpp \
|
||||||
|
asio/detail/std_thread.hpp \
|
||||||
|
asio/detail/strand_executor_service.hpp \
|
||||||
|
asio/detail/strand_service.hpp \
|
||||||
|
asio/detail/string_view.hpp \
|
||||||
|
asio/detail/thread_context.hpp \
|
||||||
|
asio/detail/thread_group.hpp \
|
||||||
|
asio/detail/thread.hpp \
|
||||||
|
asio/detail/thread_info_base.hpp \
|
||||||
|
asio/detail/throw_error.hpp \
|
||||||
|
asio/detail/throw_exception.hpp \
|
||||||
|
asio/detail/timer_queue_base.hpp \
|
||||||
|
asio/detail/timer_queue.hpp \
|
||||||
|
asio/detail/timer_queue_ptime.hpp \
|
||||||
|
asio/detail/timer_queue_set.hpp \
|
||||||
|
asio/detail/timer_scheduler_fwd.hpp \
|
||||||
|
asio/detail/timer_scheduler.hpp \
|
||||||
|
asio/detail/tss_ptr.hpp \
|
||||||
|
asio/detail/type_traits.hpp \
|
||||||
|
asio/detail/variadic_templates.hpp \
|
||||||
|
asio/detail/wait_handler.hpp \
|
||||||
|
asio/detail/wait_op.hpp \
|
||||||
|
asio/detail/winapp_thread.hpp \
|
||||||
|
asio/detail/wince_thread.hpp \
|
||||||
|
asio/detail/win_event.hpp \
|
||||||
|
asio/detail/win_fd_set_adapter.hpp \
|
||||||
|
asio/detail/win_fenced_block.hpp \
|
||||||
|
asio/detail/win_global.hpp \
|
||||||
|
asio/detail/win_iocp_file_service.hpp \
|
||||||
|
asio/detail/win_iocp_handle_read_op.hpp \
|
||||||
|
asio/detail/win_iocp_handle_service.hpp \
|
||||||
|
asio/detail/win_iocp_handle_write_op.hpp \
|
||||||
|
asio/detail/win_iocp_io_context.hpp \
|
||||||
|
asio/detail/win_iocp_null_buffers_op.hpp \
|
||||||
|
asio/detail/win_iocp_operation.hpp \
|
||||||
|
asio/detail/win_iocp_overlapped_op.hpp \
|
||||||
|
asio/detail/win_iocp_overlapped_ptr.hpp \
|
||||||
|
asio/detail/win_iocp_serial_port_service.hpp \
|
||||||
|
asio/detail/win_iocp_socket_accept_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_connect_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_recvfrom_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_recvmsg_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_recv_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_send_op.hpp \
|
||||||
|
asio/detail/win_iocp_socket_service_base.hpp \
|
||||||
|
asio/detail/win_iocp_socket_service.hpp \
|
||||||
|
asio/detail/win_iocp_thread_info.hpp \
|
||||||
|
asio/detail/win_iocp_wait_op.hpp \
|
||||||
|
asio/detail/win_mutex.hpp \
|
||||||
|
asio/detail/win_object_handle_service.hpp \
|
||||||
|
asio/detail/winrt_async_manager.hpp \
|
||||||
|
asio/detail/winrt_async_op.hpp \
|
||||||
|
asio/detail/winrt_resolve_op.hpp \
|
||||||
|
asio/detail/winrt_resolver_service.hpp \
|
||||||
|
asio/detail/winrt_socket_connect_op.hpp \
|
||||||
|
asio/detail/winrt_socket_recv_op.hpp \
|
||||||
|
asio/detail/winrt_socket_send_op.hpp \
|
||||||
|
asio/detail/winrt_ssocket_service_base.hpp \
|
||||||
|
asio/detail/winrt_ssocket_service.hpp \
|
||||||
|
asio/detail/winrt_timer_scheduler.hpp \
|
||||||
|
asio/detail/winrt_utils.hpp \
|
||||||
|
asio/detail/winsock_init.hpp \
|
||||||
|
asio/detail/win_static_mutex.hpp \
|
||||||
|
asio/detail/win_thread.hpp \
|
||||||
|
asio/detail/win_tss_ptr.hpp \
|
||||||
|
asio/detail/work_dispatcher.hpp \
|
||||||
|
asio/detail/wrapped_handler.hpp \
|
||||||
|
asio/dispatch.hpp \
|
||||||
|
asio/error_code.hpp \
|
||||||
|
asio/error.hpp \
|
||||||
|
asio/execution.hpp \
|
||||||
|
asio/execution_context.hpp \
|
||||||
|
asio/execution/allocator.hpp \
|
||||||
|
asio/execution/any_executor.hpp \
|
||||||
|
asio/execution/bad_executor.hpp \
|
||||||
|
asio/execution/blocking.hpp \
|
||||||
|
asio/execution/blocking_adaptation.hpp \
|
||||||
|
asio/execution/bulk_execute.hpp \
|
||||||
|
asio/execution/bulk_guarantee.hpp \
|
||||||
|
asio/execution/connect.hpp \
|
||||||
|
asio/execution/context.hpp \
|
||||||
|
asio/execution/context_as.hpp \
|
||||||
|
asio/execution/detail/as_invocable.hpp \
|
||||||
|
asio/execution/detail/as_operation.hpp \
|
||||||
|
asio/execution/detail/as_receiver.hpp \
|
||||||
|
asio/execution/detail/bulk_sender.hpp \
|
||||||
|
asio/execution/detail/submit_receiver.hpp \
|
||||||
|
asio/execution/detail/void_receiver.hpp \
|
||||||
|
asio/execution/execute.hpp \
|
||||||
|
asio/execution/executor.hpp \
|
||||||
|
asio/execution/impl/bad_executor.ipp \
|
||||||
|
asio/execution/impl/receiver_invocation_error.ipp \
|
||||||
|
asio/execution/invocable_archetype.hpp \
|
||||||
|
asio/execution/mapping.hpp \
|
||||||
|
asio/execution/occupancy.hpp \
|
||||||
|
asio/execution/operation_state.hpp \
|
||||||
|
asio/execution/outstanding_work.hpp \
|
||||||
|
asio/execution/prefer_only.hpp \
|
||||||
|
asio/execution/receiver.hpp \
|
||||||
|
asio/execution/receiver_invocation_error.hpp \
|
||||||
|
asio/execution/relationship.hpp \
|
||||||
|
asio/execution/schedule.hpp \
|
||||||
|
asio/execution/scheduler.hpp \
|
||||||
|
asio/execution/sender.hpp \
|
||||||
|
asio/execution/set_done.hpp \
|
||||||
|
asio/execution/set_error.hpp \
|
||||||
|
asio/execution/set_value.hpp \
|
||||||
|
asio/execution/start.hpp \
|
||||||
|
asio/execution/submit.hpp \
|
||||||
|
asio/executor.hpp \
|
||||||
|
asio/executor_work_guard.hpp \
|
||||||
|
asio/experimental/append.hpp \
|
||||||
|
asio/experimental/as_single.hpp \
|
||||||
|
asio/experimental/as_tuple.hpp \
|
||||||
|
asio/experimental/awaitable_operators.hpp \
|
||||||
|
asio/experimental/basic_channel.hpp \
|
||||||
|
asio/experimental/basic_concurrent_channel.hpp \
|
||||||
|
asio/experimental/cancellation_condition.hpp \
|
||||||
|
asio/experimental/channel.hpp \
|
||||||
|
asio/experimental/channel_error.hpp \
|
||||||
|
asio/experimental/channel_traits.hpp \
|
||||||
|
asio/experimental/co_spawn.hpp \
|
||||||
|
asio/experimental/concurrent_channel.hpp \
|
||||||
|
asio/experimental/coro.hpp \
|
||||||
|
asio/experimental/coro_traits.hpp \
|
||||||
|
asio/experimental/deferred.hpp \
|
||||||
|
asio/experimental/detail/channel_handler.hpp \
|
||||||
|
asio/experimental/detail/channel_message.hpp \
|
||||||
|
asio/experimental/detail/channel_operation.hpp \
|
||||||
|
asio/experimental/detail/channel_payload.hpp \
|
||||||
|
asio/experimental/detail/channel_receive_op.hpp \
|
||||||
|
asio/experimental/detail/channel_send_functions.hpp \
|
||||||
|
asio/experimental/detail/channel_send_op.hpp \
|
||||||
|
asio/experimental/detail/channel_service.hpp \
|
||||||
|
asio/experimental/detail/completion_handler_erasure.hpp \
|
||||||
|
asio/experimental/detail/coro_promise_allocator.hpp \
|
||||||
|
asio/experimental/detail/has_signature.hpp \
|
||||||
|
asio/experimental/detail/impl/channel_service.hpp \
|
||||||
|
asio/experimental/detail/partial_promise.hpp \
|
||||||
|
asio/experimental/impl/append.hpp \
|
||||||
|
asio/experimental/impl/as_single.hpp \
|
||||||
|
asio/experimental/impl/as_tuple.hpp \
|
||||||
|
asio/experimental/impl/channel_error.ipp \
|
||||||
|
asio/experimental/impl/coro.hpp \
|
||||||
|
asio/experimental/impl/deferred.hpp \
|
||||||
|
asio/experimental/impl/parallel_group.hpp \
|
||||||
|
asio/experimental/impl/prepend.hpp \
|
||||||
|
asio/experimental/impl/promise.hpp \
|
||||||
|
asio/experimental/impl/use_coro.hpp \
|
||||||
|
asio/experimental/parallel_group.hpp \
|
||||||
|
asio/experimental/prepend.hpp \
|
||||||
|
asio/experimental/promise.hpp \
|
||||||
|
asio/experimental/use_coro.hpp \
|
||||||
|
asio/file_base.hpp \
|
||||||
|
asio/generic/basic_endpoint.hpp \
|
||||||
|
asio/generic/datagram_protocol.hpp \
|
||||||
|
asio/generic/detail/endpoint.hpp \
|
||||||
|
asio/generic/detail/impl/endpoint.ipp \
|
||||||
|
asio/generic/raw_protocol.hpp \
|
||||||
|
asio/generic/seq_packet_protocol.hpp \
|
||||||
|
asio/generic/stream_protocol.hpp \
|
||||||
|
asio/handler_alloc_hook.hpp \
|
||||||
|
asio/handler_continuation_hook.hpp \
|
||||||
|
asio/handler_invoke_hook.hpp \
|
||||||
|
asio/high_resolution_timer.hpp \
|
||||||
|
asio.hpp \
|
||||||
|
asio/impl/any_io_executor.ipp \
|
||||||
|
asio/impl/awaitable.hpp \
|
||||||
|
asio/impl/buffered_read_stream.hpp \
|
||||||
|
asio/impl/buffered_write_stream.hpp \
|
||||||
|
asio/impl/cancellation_signal.ipp \
|
||||||
|
asio/impl/co_spawn.hpp \
|
||||||
|
asio/impl/compose.hpp \
|
||||||
|
asio/impl/connect.hpp \
|
||||||
|
asio/impl/connect_pipe.hpp \
|
||||||
|
asio/impl/connect_pipe.ipp \
|
||||||
|
asio/impl/defer.hpp \
|
||||||
|
asio/impl/detached.hpp \
|
||||||
|
asio/impl/dispatch.hpp \
|
||||||
|
asio/impl/error_code.ipp \
|
||||||
|
asio/impl/error.ipp \
|
||||||
|
asio/impl/execution_context.hpp \
|
||||||
|
asio/impl/execution_context.ipp \
|
||||||
|
asio/impl/executor.hpp \
|
||||||
|
asio/impl/executor.ipp \
|
||||||
|
asio/impl/handler_alloc_hook.ipp \
|
||||||
|
asio/impl/io_context.hpp \
|
||||||
|
asio/impl/io_context.ipp \
|
||||||
|
asio/impl/multiple_exceptions.ipp \
|
||||||
|
asio/impl/post.hpp \
|
||||||
|
asio/impl/read_at.hpp \
|
||||||
|
asio/impl/read.hpp \
|
||||||
|
asio/impl/read_until.hpp \
|
||||||
|
asio/impl/redirect_error.hpp \
|
||||||
|
asio/impl/serial_port_base.hpp \
|
||||||
|
asio/impl/serial_port_base.ipp \
|
||||||
|
asio/impl/spawn.hpp \
|
||||||
|
asio/impl/src.hpp \
|
||||||
|
asio/impl/system_context.hpp \
|
||||||
|
asio/impl/system_context.ipp \
|
||||||
|
asio/impl/system_executor.hpp \
|
||||||
|
asio/impl/thread_pool.hpp \
|
||||||
|
asio/impl/thread_pool.ipp \
|
||||||
|
asio/impl/use_awaitable.hpp \
|
||||||
|
asio/impl/use_future.hpp \
|
||||||
|
asio/impl/write_at.hpp \
|
||||||
|
asio/impl/write.hpp \
|
||||||
|
asio/io_context.hpp \
|
||||||
|
asio/io_context_strand.hpp \
|
||||||
|
asio/io_service.hpp \
|
||||||
|
asio/io_service_strand.hpp \
|
||||||
|
asio/ip/address.hpp \
|
||||||
|
asio/ip/address_v4.hpp \
|
||||||
|
asio/ip/address_v4_iterator.hpp \
|
||||||
|
asio/ip/address_v4_range.hpp \
|
||||||
|
asio/ip/address_v6.hpp \
|
||||||
|
asio/ip/address_v6_iterator.hpp \
|
||||||
|
asio/ip/address_v6_range.hpp \
|
||||||
|
asio/ip/bad_address_cast.hpp \
|
||||||
|
asio/ip/basic_endpoint.hpp \
|
||||||
|
asio/ip/basic_resolver_entry.hpp \
|
||||||
|
asio/ip/basic_resolver.hpp \
|
||||||
|
asio/ip/basic_resolver_iterator.hpp \
|
||||||
|
asio/ip/basic_resolver_query.hpp \
|
||||||
|
asio/ip/basic_resolver_results.hpp \
|
||||||
|
asio/ip/detail/endpoint.hpp \
|
||||||
|
asio/ip/detail/impl/endpoint.ipp \
|
||||||
|
asio/ip/detail/socket_option.hpp \
|
||||||
|
asio/ip/host_name.hpp \
|
||||||
|
asio/ip/icmp.hpp \
|
||||||
|
asio/ip/impl/address.hpp \
|
||||||
|
asio/ip/impl/address.ipp \
|
||||||
|
asio/ip/impl/address_v4.hpp \
|
||||||
|
asio/ip/impl/address_v4.ipp \
|
||||||
|
asio/ip/impl/address_v6.hpp \
|
||||||
|
asio/ip/impl/address_v6.ipp \
|
||||||
|
asio/ip/impl/basic_endpoint.hpp \
|
||||||
|
asio/ip/impl/host_name.ipp \
|
||||||
|
asio/ip/impl/network_v4.hpp \
|
||||||
|
asio/ip/impl/network_v4.ipp \
|
||||||
|
asio/ip/impl/network_v6.hpp \
|
||||||
|
asio/ip/impl/network_v6.ipp \
|
||||||
|
asio/ip/multicast.hpp \
|
||||||
|
asio/ip/network_v4.hpp \
|
||||||
|
asio/ip/network_v6.hpp \
|
||||||
|
asio/ip/resolver_base.hpp \
|
||||||
|
asio/ip/resolver_query_base.hpp \
|
||||||
|
asio/ip/tcp.hpp \
|
||||||
|
asio/ip/udp.hpp \
|
||||||
|
asio/ip/unicast.hpp \
|
||||||
|
asio/ip/v6_only.hpp \
|
||||||
|
asio/is_applicable_property.hpp \
|
||||||
|
asio/is_executor.hpp \
|
||||||
|
asio/is_read_buffered.hpp \
|
||||||
|
asio/is_write_buffered.hpp \
|
||||||
|
asio/local/basic_endpoint.hpp \
|
||||||
|
asio/local/connect_pair.hpp \
|
||||||
|
asio/local/datagram_protocol.hpp \
|
||||||
|
asio/local/detail/endpoint.hpp \
|
||||||
|
asio/local/detail/impl/endpoint.ipp \
|
||||||
|
asio/local/stream_protocol.hpp \
|
||||||
|
asio/multiple_exceptions.hpp \
|
||||||
|
asio/packaged_task.hpp \
|
||||||
|
asio/placeholders.hpp \
|
||||||
|
asio/posix/basic_descriptor.hpp \
|
||||||
|
asio/posix/basic_stream_descriptor.hpp \
|
||||||
|
asio/posix/descriptor_base.hpp \
|
||||||
|
asio/posix/descriptor.hpp \
|
||||||
|
asio/posix/stream_descriptor.hpp \
|
||||||
|
asio/post.hpp \
|
||||||
|
asio/prefer.hpp \
|
||||||
|
asio/query.hpp \
|
||||||
|
asio/random_access_file.hpp \
|
||||||
|
asio/read_at.hpp \
|
||||||
|
asio/read.hpp \
|
||||||
|
asio/read_until.hpp \
|
||||||
|
asio/readable_pipe.hpp \
|
||||||
|
asio/recycling_allocator.hpp \
|
||||||
|
asio/redirect_error.hpp \
|
||||||
|
asio/registered_buffer.hpp \
|
||||||
|
asio/require.hpp \
|
||||||
|
asio/require_concept.hpp \
|
||||||
|
asio/serial_port_base.hpp \
|
||||||
|
asio/serial_port.hpp \
|
||||||
|
asio/signal_set.hpp \
|
||||||
|
asio/socket_base.hpp \
|
||||||
|
asio/spawn.hpp \
|
||||||
|
asio/ssl/context_base.hpp \
|
||||||
|
asio/ssl/context.hpp \
|
||||||
|
asio/ssl/detail/buffered_handshake_op.hpp \
|
||||||
|
asio/ssl/detail/engine.hpp \
|
||||||
|
asio/ssl/detail/handshake_op.hpp \
|
||||||
|
asio/ssl/detail/impl/engine.ipp \
|
||||||
|
asio/ssl/detail/impl/openssl_init.ipp \
|
||||||
|
asio/ssl/detail/io.hpp \
|
||||||
|
asio/ssl/detail/openssl_init.hpp \
|
||||||
|
asio/ssl/detail/openssl_types.hpp \
|
||||||
|
asio/ssl/detail/password_callback.hpp \
|
||||||
|
asio/ssl/detail/read_op.hpp \
|
||||||
|
asio/ssl/detail/shutdown_op.hpp \
|
||||||
|
asio/ssl/detail/stream_core.hpp \
|
||||||
|
asio/ssl/detail/verify_callback.hpp \
|
||||||
|
asio/ssl/detail/write_op.hpp \
|
||||||
|
asio/ssl/error.hpp \
|
||||||
|
asio/ssl.hpp \
|
||||||
|
asio/ssl/host_name_verification.hpp \
|
||||||
|
asio/ssl/impl/context.hpp \
|
||||||
|
asio/ssl/impl/context.ipp \
|
||||||
|
asio/ssl/impl/error.ipp \
|
||||||
|
asio/ssl/impl/host_name_verification.ipp \
|
||||||
|
asio/ssl/impl/rfc2818_verification.ipp \
|
||||||
|
asio/ssl/impl/src.hpp \
|
||||||
|
asio/ssl/rfc2818_verification.hpp \
|
||||||
|
asio/ssl/stream_base.hpp \
|
||||||
|
asio/ssl/stream.hpp \
|
||||||
|
asio/ssl/verify_context.hpp \
|
||||||
|
asio/ssl/verify_mode.hpp \
|
||||||
|
asio/static_thread_pool.hpp \
|
||||||
|
asio/steady_timer.hpp \
|
||||||
|
asio/strand.hpp \
|
||||||
|
asio/streambuf.hpp \
|
||||||
|
asio/stream_file.hpp \
|
||||||
|
asio/system_context.hpp \
|
||||||
|
asio/system_error.hpp \
|
||||||
|
asio/system_executor.hpp \
|
||||||
|
asio/system_timer.hpp \
|
||||||
|
asio/this_coro.hpp \
|
||||||
|
asio/thread.hpp \
|
||||||
|
asio/thread_pool.hpp \
|
||||||
|
asio/time_traits.hpp \
|
||||||
|
asio/traits/bulk_execute_free.hpp \
|
||||||
|
asio/traits/bulk_execute_member.hpp \
|
||||||
|
asio/traits/connect_free.hpp \
|
||||||
|
asio/traits/connect_member.hpp \
|
||||||
|
asio/traits/equality_comparable.hpp \
|
||||||
|
asio/traits/execute_free.hpp \
|
||||||
|
asio/traits/execute_member.hpp \
|
||||||
|
asio/traits/prefer_free.hpp \
|
||||||
|
asio/traits/prefer_member.hpp \
|
||||||
|
asio/traits/query_free.hpp \
|
||||||
|
asio/traits/query_member.hpp \
|
||||||
|
asio/traits/query_static_constexpr_member.hpp \
|
||||||
|
asio/traits/require_concept_free.hpp \
|
||||||
|
asio/traits/require_concept_member.hpp \
|
||||||
|
asio/traits/require_free.hpp \
|
||||||
|
asio/traits/require_member.hpp \
|
||||||
|
asio/traits/schedule_free.hpp \
|
||||||
|
asio/traits/schedule_member.hpp \
|
||||||
|
asio/traits/set_done_free.hpp \
|
||||||
|
asio/traits/set_done_member.hpp \
|
||||||
|
asio/traits/set_error_free.hpp \
|
||||||
|
asio/traits/set_error_member.hpp \
|
||||||
|
asio/traits/set_value_free.hpp \
|
||||||
|
asio/traits/set_value_member.hpp \
|
||||||
|
asio/traits/start_free.hpp \
|
||||||
|
asio/traits/start_member.hpp \
|
||||||
|
asio/traits/static_query.hpp \
|
||||||
|
asio/traits/static_require.hpp \
|
||||||
|
asio/traits/static_require_concept.hpp \
|
||||||
|
asio/traits/submit_free.hpp \
|
||||||
|
asio/traits/submit_member.hpp \
|
||||||
|
asio/ts/buffer.hpp \
|
||||||
|
asio/ts/executor.hpp \
|
||||||
|
asio/ts/internet.hpp \
|
||||||
|
asio/ts/io_context.hpp \
|
||||||
|
asio/ts/netfwd.hpp \
|
||||||
|
asio/ts/net.hpp \
|
||||||
|
asio/ts/socket.hpp \
|
||||||
|
asio/ts/timer.hpp \
|
||||||
|
asio/unyield.hpp \
|
||||||
|
asio/use_awaitable.hpp \
|
||||||
|
asio/use_future.hpp \
|
||||||
|
asio/uses_executor.hpp \
|
||||||
|
asio/version.hpp \
|
||||||
|
asio/wait_traits.hpp \
|
||||||
|
asio/windows/basic_object_handle.hpp \
|
||||||
|
asio/windows/basic_overlapped_handle.hpp \
|
||||||
|
asio/windows/basic_random_access_handle.hpp \
|
||||||
|
asio/windows/basic_stream_handle.hpp \
|
||||||
|
asio/windows/object_handle.hpp \
|
||||||
|
asio/windows/overlapped_handle.hpp \
|
||||||
|
asio/windows/overlapped_ptr.hpp \
|
||||||
|
asio/windows/random_access_handle.hpp \
|
||||||
|
asio/windows/stream_handle.hpp \
|
||||||
|
asio/writable_pipe.hpp \
|
||||||
|
asio/write_at.hpp \
|
||||||
|
asio/write.hpp \
|
||||||
|
asio/yield.hpp
|
||||||
|
|
||||||
|
MAINTAINERCLEANFILES = \
|
||||||
|
$(srcdir)/Makefile.in
|
||||||
|
|
@ -0,0 +1,203 @@
|
||||||
|
//
|
||||||
|
// asio.hpp
|
||||||
|
// ~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_HPP
|
||||||
|
#define ASIO_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/associated_allocator.hpp"
|
||||||
|
#include "asio/associated_executor.hpp"
|
||||||
|
#include "asio/associated_cancellation_slot.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/awaitable.hpp"
|
||||||
|
#include "asio/basic_datagram_socket.hpp"
|
||||||
|
#include "asio/basic_deadline_timer.hpp"
|
||||||
|
#include "asio/basic_file.hpp"
|
||||||
|
#include "asio/basic_io_object.hpp"
|
||||||
|
#include "asio/basic_random_access_file.hpp"
|
||||||
|
#include "asio/basic_raw_socket.hpp"
|
||||||
|
#include "asio/basic_readable_pipe.hpp"
|
||||||
|
#include "asio/basic_seq_packet_socket.hpp"
|
||||||
|
#include "asio/basic_serial_port.hpp"
|
||||||
|
#include "asio/basic_signal_set.hpp"
|
||||||
|
#include "asio/basic_socket.hpp"
|
||||||
|
#include "asio/basic_socket_acceptor.hpp"
|
||||||
|
#include "asio/basic_socket_iostream.hpp"
|
||||||
|
#include "asio/basic_socket_streambuf.hpp"
|
||||||
|
#include "asio/basic_stream_file.hpp"
|
||||||
|
#include "asio/basic_stream_socket.hpp"
|
||||||
|
#include "asio/basic_streambuf.hpp"
|
||||||
|
#include "asio/basic_waitable_timer.hpp"
|
||||||
|
#include "asio/basic_writable_pipe.hpp"
|
||||||
|
#include "asio/bind_allocator.hpp"
|
||||||
|
#include "asio/bind_cancellation_slot.hpp"
|
||||||
|
#include "asio/bind_executor.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/buffer_registration.hpp"
|
||||||
|
#include "asio/buffered_read_stream_fwd.hpp"
|
||||||
|
#include "asio/buffered_read_stream.hpp"
|
||||||
|
#include "asio/buffered_stream_fwd.hpp"
|
||||||
|
#include "asio/buffered_stream.hpp"
|
||||||
|
#include "asio/buffered_write_stream_fwd.hpp"
|
||||||
|
#include "asio/buffered_write_stream.hpp"
|
||||||
|
#include "asio/buffers_iterator.hpp"
|
||||||
|
#include "asio/cancellation_signal.hpp"
|
||||||
|
#include "asio/cancellation_state.hpp"
|
||||||
|
#include "asio/cancellation_type.hpp"
|
||||||
|
#include "asio/co_spawn.hpp"
|
||||||
|
#include "asio/completion_condition.hpp"
|
||||||
|
#include "asio/compose.hpp"
|
||||||
|
#include "asio/connect.hpp"
|
||||||
|
#include "asio/connect_pipe.hpp"
|
||||||
|
#include "asio/coroutine.hpp"
|
||||||
|
#include "asio/deadline_timer.hpp"
|
||||||
|
#include "asio/defer.hpp"
|
||||||
|
#include "asio/detached.hpp"
|
||||||
|
#include "asio/dispatch.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/error_code.hpp"
|
||||||
|
#include "asio/execution.hpp"
|
||||||
|
#include "asio/execution/allocator.hpp"
|
||||||
|
#include "asio/execution/any_executor.hpp"
|
||||||
|
#include "asio/execution/blocking.hpp"
|
||||||
|
#include "asio/execution/blocking_adaptation.hpp"
|
||||||
|
#include "asio/execution/bulk_execute.hpp"
|
||||||
|
#include "asio/execution/bulk_guarantee.hpp"
|
||||||
|
#include "asio/execution/connect.hpp"
|
||||||
|
#include "asio/execution/context.hpp"
|
||||||
|
#include "asio/execution/context_as.hpp"
|
||||||
|
#include "asio/execution/execute.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/execution/invocable_archetype.hpp"
|
||||||
|
#include "asio/execution/mapping.hpp"
|
||||||
|
#include "asio/execution/occupancy.hpp"
|
||||||
|
#include "asio/execution/operation_state.hpp"
|
||||||
|
#include "asio/execution/outstanding_work.hpp"
|
||||||
|
#include "asio/execution/prefer_only.hpp"
|
||||||
|
#include "asio/execution/receiver.hpp"
|
||||||
|
#include "asio/execution/receiver_invocation_error.hpp"
|
||||||
|
#include "asio/execution/relationship.hpp"
|
||||||
|
#include "asio/execution/schedule.hpp"
|
||||||
|
#include "asio/execution/scheduler.hpp"
|
||||||
|
#include "asio/execution/sender.hpp"
|
||||||
|
#include "asio/execution/set_done.hpp"
|
||||||
|
#include "asio/execution/set_error.hpp"
|
||||||
|
#include "asio/execution/set_value.hpp"
|
||||||
|
#include "asio/execution/start.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/executor.hpp"
|
||||||
|
#include "asio/executor_work_guard.hpp"
|
||||||
|
#include "asio/file_base.hpp"
|
||||||
|
#include "asio/generic/basic_endpoint.hpp"
|
||||||
|
#include "asio/generic/datagram_protocol.hpp"
|
||||||
|
#include "asio/generic/raw_protocol.hpp"
|
||||||
|
#include "asio/generic/seq_packet_protocol.hpp"
|
||||||
|
#include "asio/generic/stream_protocol.hpp"
|
||||||
|
#include "asio/handler_alloc_hook.hpp"
|
||||||
|
#include "asio/handler_continuation_hook.hpp"
|
||||||
|
#include "asio/handler_invoke_hook.hpp"
|
||||||
|
#include "asio/high_resolution_timer.hpp"
|
||||||
|
#include "asio/io_context.hpp"
|
||||||
|
#include "asio/io_context_strand.hpp"
|
||||||
|
#include "asio/io_service.hpp"
|
||||||
|
#include "asio/io_service_strand.hpp"
|
||||||
|
#include "asio/ip/address.hpp"
|
||||||
|
#include "asio/ip/address_v4.hpp"
|
||||||
|
#include "asio/ip/address_v4_iterator.hpp"
|
||||||
|
#include "asio/ip/address_v4_range.hpp"
|
||||||
|
#include "asio/ip/address_v6.hpp"
|
||||||
|
#include "asio/ip/address_v6_iterator.hpp"
|
||||||
|
#include "asio/ip/address_v6_range.hpp"
|
||||||
|
#include "asio/ip/network_v4.hpp"
|
||||||
|
#include "asio/ip/network_v6.hpp"
|
||||||
|
#include "asio/ip/bad_address_cast.hpp"
|
||||||
|
#include "asio/ip/basic_endpoint.hpp"
|
||||||
|
#include "asio/ip/basic_resolver.hpp"
|
||||||
|
#include "asio/ip/basic_resolver_entry.hpp"
|
||||||
|
#include "asio/ip/basic_resolver_iterator.hpp"
|
||||||
|
#include "asio/ip/basic_resolver_query.hpp"
|
||||||
|
#include "asio/ip/host_name.hpp"
|
||||||
|
#include "asio/ip/icmp.hpp"
|
||||||
|
#include "asio/ip/multicast.hpp"
|
||||||
|
#include "asio/ip/resolver_base.hpp"
|
||||||
|
#include "asio/ip/resolver_query_base.hpp"
|
||||||
|
#include "asio/ip/tcp.hpp"
|
||||||
|
#include "asio/ip/udp.hpp"
|
||||||
|
#include "asio/ip/unicast.hpp"
|
||||||
|
#include "asio/ip/v6_only.hpp"
|
||||||
|
#include "asio/is_applicable_property.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
#include "asio/is_read_buffered.hpp"
|
||||||
|
#include "asio/is_write_buffered.hpp"
|
||||||
|
#include "asio/local/basic_endpoint.hpp"
|
||||||
|
#include "asio/local/connect_pair.hpp"
|
||||||
|
#include "asio/local/datagram_protocol.hpp"
|
||||||
|
#include "asio/local/stream_protocol.hpp"
|
||||||
|
#include "asio/multiple_exceptions.hpp"
|
||||||
|
#include "asio/packaged_task.hpp"
|
||||||
|
#include "asio/placeholders.hpp"
|
||||||
|
#include "asio/posix/basic_descriptor.hpp"
|
||||||
|
#include "asio/posix/basic_stream_descriptor.hpp"
|
||||||
|
#include "asio/posix/descriptor.hpp"
|
||||||
|
#include "asio/posix/descriptor_base.hpp"
|
||||||
|
#include "asio/posix/stream_descriptor.hpp"
|
||||||
|
#include "asio/post.hpp"
|
||||||
|
#include "asio/prefer.hpp"
|
||||||
|
#include "asio/query.hpp"
|
||||||
|
#include "asio/random_access_file.hpp"
|
||||||
|
#include "asio/read.hpp"
|
||||||
|
#include "asio/read_at.hpp"
|
||||||
|
#include "asio/read_until.hpp"
|
||||||
|
#include "asio/readable_pipe.hpp"
|
||||||
|
#include "asio/recycling_allocator.hpp"
|
||||||
|
#include "asio/redirect_error.hpp"
|
||||||
|
#include "asio/registered_buffer.hpp"
|
||||||
|
#include "asio/require.hpp"
|
||||||
|
#include "asio/require_concept.hpp"
|
||||||
|
#include "asio/serial_port.hpp"
|
||||||
|
#include "asio/serial_port_base.hpp"
|
||||||
|
#include "asio/signal_set.hpp"
|
||||||
|
#include "asio/socket_base.hpp"
|
||||||
|
#include "asio/static_thread_pool.hpp"
|
||||||
|
#include "asio/steady_timer.hpp"
|
||||||
|
#include "asio/strand.hpp"
|
||||||
|
#include "asio/stream_file.hpp"
|
||||||
|
#include "asio/streambuf.hpp"
|
||||||
|
#include "asio/system_context.hpp"
|
||||||
|
#include "asio/system_error.hpp"
|
||||||
|
#include "asio/system_executor.hpp"
|
||||||
|
#include "asio/system_timer.hpp"
|
||||||
|
#include "asio/this_coro.hpp"
|
||||||
|
#include "asio/thread.hpp"
|
||||||
|
#include "asio/thread_pool.hpp"
|
||||||
|
#include "asio/time_traits.hpp"
|
||||||
|
#include "asio/use_awaitable.hpp"
|
||||||
|
#include "asio/use_future.hpp"
|
||||||
|
#include "asio/uses_executor.hpp"
|
||||||
|
#include "asio/version.hpp"
|
||||||
|
#include "asio/wait_traits.hpp"
|
||||||
|
#include "asio/windows/basic_object_handle.hpp"
|
||||||
|
#include "asio/windows/basic_overlapped_handle.hpp"
|
||||||
|
#include "asio/windows/basic_random_access_handle.hpp"
|
||||||
|
#include "asio/windows/basic_stream_handle.hpp"
|
||||||
|
#include "asio/windows/object_handle.hpp"
|
||||||
|
#include "asio/windows/overlapped_handle.hpp"
|
||||||
|
#include "asio/windows/overlapped_ptr.hpp"
|
||||||
|
#include "asio/windows/random_access_handle.hpp"
|
||||||
|
#include "asio/windows/stream_handle.hpp"
|
||||||
|
#include "asio/writable_pipe.hpp"
|
||||||
|
#include "asio/write.hpp"
|
||||||
|
#include "asio/write_at.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_HPP
|
||||||
|
|
@ -0,0 +1,303 @@
|
||||||
|
//
|
||||||
|
// any_io_executor.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_ANY_IO_EXECUTOR_HPP
|
||||||
|
#define ASIO_ANY_IO_EXECUTOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
# include "asio/executor.hpp"
|
||||||
|
#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
# include "asio/execution.hpp"
|
||||||
|
# include "asio/execution_context.hpp"
|
||||||
|
#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
|
||||||
|
typedef executor any_io_executor;
|
||||||
|
|
||||||
|
#else // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
|
||||||
|
/// Polymorphic executor type for use with I/O objects.
|
||||||
|
/**
|
||||||
|
* The @c any_io_executor type is a polymorphic executor that supports the set
|
||||||
|
* of properties required by I/O objects. It is defined as the
|
||||||
|
* execution::any_executor class template parameterised as follows:
|
||||||
|
* @code execution::any_executor<
|
||||||
|
* execution::context_as_t<execution_context&>,
|
||||||
|
* execution::blocking_t::never_t,
|
||||||
|
* execution::prefer_only<execution::blocking_t::possibly_t>,
|
||||||
|
* execution::prefer_only<execution::outstanding_work_t::tracked_t>,
|
||||||
|
* execution::prefer_only<execution::outstanding_work_t::untracked_t>,
|
||||||
|
* execution::prefer_only<execution::relationship_t::fork_t>,
|
||||||
|
* execution::prefer_only<execution::relationship_t::continuation_t>
|
||||||
|
* > @endcode
|
||||||
|
*/
|
||||||
|
class any_io_executor :
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
public execution::any_executor<...>
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
public execution::any_executor<
|
||||||
|
execution::context_as_t<execution_context&>,
|
||||||
|
execution::blocking_t::never_t,
|
||||||
|
execution::prefer_only<execution::blocking_t::possibly_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::tracked_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::untracked_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::fork_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::continuation_t>
|
||||||
|
>
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef execution::any_executor<
|
||||||
|
execution::context_as_t<execution_context&>,
|
||||||
|
execution::blocking_t::never_t,
|
||||||
|
execution::prefer_only<execution::blocking_t::possibly_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::tracked_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::untracked_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::fork_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::continuation_t>
|
||||||
|
> base_type;
|
||||||
|
|
||||||
|
typedef void supportable_properties_type(
|
||||||
|
execution::context_as_t<execution_context&>,
|
||||||
|
execution::blocking_t::never_t,
|
||||||
|
execution::prefer_only<execution::blocking_t::possibly_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::tracked_t>,
|
||||||
|
execution::prefer_only<execution::outstanding_work_t::untracked_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::fork_t>,
|
||||||
|
execution::prefer_only<execution::relationship_t::continuation_t>
|
||||||
|
);
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Default constructor.
|
||||||
|
ASIO_DECL any_io_executor() ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
/// Construct in an empty state. Equivalent effects to default constructor.
|
||||||
|
ASIO_DECL any_io_executor(nullptr_t) ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
/// Copy constructor.
|
||||||
|
ASIO_DECL any_io_executor(const any_io_executor& e) ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move constructor.
|
||||||
|
ASIO_DECL any_io_executor(any_io_executor&& e) ASIO_NOEXCEPT;
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Construct to point to the same target as another any_executor.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <class... OtherSupportableProperties>
|
||||||
|
any_io_executor(execution::any_executor<OtherSupportableProperties...> e);
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename OtherAnyExecutor>
|
||||||
|
any_io_executor(OtherAnyExecutor e,
|
||||||
|
typename constraint<
|
||||||
|
conditional<
|
||||||
|
!is_same<OtherAnyExecutor, any_io_executor>::value
|
||||||
|
&& is_base_of<execution::detail::any_executor_base,
|
||||||
|
OtherAnyExecutor>::value,
|
||||||
|
typename execution::detail::supportable_properties<
|
||||||
|
0, supportable_properties_type>::template
|
||||||
|
is_valid_target<OtherAnyExecutor>,
|
||||||
|
false_type
|
||||||
|
>::type::value
|
||||||
|
>::type = 0)
|
||||||
|
: base_type(ASIO_MOVE_CAST(OtherAnyExecutor)(e))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Construct a polymorphic wrapper for the specified executor.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <ASIO_EXECUTION_EXECUTOR Executor>
|
||||||
|
any_io_executor(Executor e);
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <ASIO_EXECUTION_EXECUTOR Executor>
|
||||||
|
any_io_executor(Executor e,
|
||||||
|
typename constraint<
|
||||||
|
conditional<
|
||||||
|
!is_same<Executor, any_io_executor>::value
|
||||||
|
&& !is_base_of<execution::detail::any_executor_base,
|
||||||
|
Executor>::value,
|
||||||
|
execution::detail::is_valid_target_executor<
|
||||||
|
Executor, supportable_properties_type>,
|
||||||
|
false_type
|
||||||
|
>::type::value
|
||||||
|
>::type = 0)
|
||||||
|
: base_type(ASIO_MOVE_CAST(Executor)(e))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Assignment operator.
|
||||||
|
ASIO_DECL any_io_executor& operator=(
|
||||||
|
const any_io_executor& e) ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move assignment operator.
|
||||||
|
ASIO_DECL any_io_executor& operator=(
|
||||||
|
any_io_executor&& e) ASIO_NOEXCEPT;
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Assignment operator that sets the polymorphic wrapper to the empty state.
|
||||||
|
ASIO_DECL any_io_executor& operator=(nullptr_t);
|
||||||
|
|
||||||
|
/// Destructor.
|
||||||
|
ASIO_DECL ~any_io_executor();
|
||||||
|
|
||||||
|
/// Swap targets with another polymorphic wrapper.
|
||||||
|
ASIO_DECL void swap(any_io_executor& other) ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
/// Obtain a polymorphic wrapper with the specified property.
|
||||||
|
/**
|
||||||
|
* Do not call this function directly. It is intended for use with the
|
||||||
|
* asio::require and asio::prefer customisation points.
|
||||||
|
*
|
||||||
|
* For example:
|
||||||
|
* @code any_io_executor ex = ...;
|
||||||
|
* auto ex2 = asio::require(ex, execution::blocking.possibly); @endcode
|
||||||
|
*/
|
||||||
|
template <typename Property>
|
||||||
|
any_io_executor require(const Property& p,
|
||||||
|
typename constraint<
|
||||||
|
traits::require_member<const base_type&, const Property&>::is_valid
|
||||||
|
>::type = 0) const
|
||||||
|
{
|
||||||
|
return static_cast<const base_type&>(*this).require(p);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a polymorphic wrapper with the specified property.
|
||||||
|
/**
|
||||||
|
* Do not call this function directly. It is intended for use with the
|
||||||
|
* asio::prefer customisation point.
|
||||||
|
*
|
||||||
|
* For example:
|
||||||
|
* @code any_io_executor ex = ...;
|
||||||
|
* auto ex2 = asio::prefer(ex, execution::blocking.possibly); @endcode
|
||||||
|
*/
|
||||||
|
template <typename Property>
|
||||||
|
any_io_executor prefer(const Property& p,
|
||||||
|
typename constraint<
|
||||||
|
traits::prefer_member<const base_type&, const Property&>::is_valid
|
||||||
|
>::type = 0) const
|
||||||
|
{
|
||||||
|
return static_cast<const base_type&>(*this).prefer(p);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::require(
|
||||||
|
const execution::blocking_t::never_t&, int) const;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::prefer(
|
||||||
|
const execution::blocking_t::possibly_t&, int) const;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::prefer(
|
||||||
|
const execution::outstanding_work_t::tracked_t&, int) const;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::prefer(
|
||||||
|
const execution::outstanding_work_t::untracked_t&, int) const;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::prefer(
|
||||||
|
const execution::relationship_t::fork_t&, int) const;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
ASIO_DECL any_io_executor any_io_executor::prefer(
|
||||||
|
const execution::relationship_t::continuation_t&, int) const;
|
||||||
|
|
||||||
|
namespace traits {
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct equality_comparable<any_io_executor>
|
||||||
|
{
|
||||||
|
static const bool is_valid = true;
|
||||||
|
static const bool is_noexcept = true;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_DEDUCED_EQUALITY_COMPARABLE_TRAIT)
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
template <typename F>
|
||||||
|
struct execute_member<any_io_executor, F>
|
||||||
|
{
|
||||||
|
static const bool is_valid = true;
|
||||||
|
static const bool is_noexcept = false;
|
||||||
|
typedef void result_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_DEDUCED_EXECUTE_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
template <typename Prop>
|
||||||
|
struct query_member<any_io_executor, Prop> :
|
||||||
|
query_member<any_io_executor::base_type, Prop>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_DEDUCED_QUERY_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
template <typename Prop>
|
||||||
|
struct require_member<any_io_executor, Prop> :
|
||||||
|
require_member<any_io_executor::base_type, Prop>
|
||||||
|
{
|
||||||
|
typedef any_io_executor result_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_DEDUCED_REQUIRE_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
template <typename Prop>
|
||||||
|
struct prefer_member<any_io_executor, Prop> :
|
||||||
|
prefer_member<any_io_executor::base_type, Prop>
|
||||||
|
{
|
||||||
|
typedef any_io_executor result_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_DEDUCED_PREFER_MEMBER_TRAIT)
|
||||||
|
|
||||||
|
} // namespace traits
|
||||||
|
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HEADER_ONLY) \
|
||||||
|
&& !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
# include "asio/impl/any_io_executor.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
// && !defined(ASIO_USE_TS_EXECUTOR_AS_DEFAULT)
|
||||||
|
|
||||||
|
#endif // ASIO_ANY_IO_EXECUTOR_HPP
|
||||||
|
|
@ -0,0 +1,177 @@
|
||||||
|
//
|
||||||
|
// associated_allocator.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_ASSOCIATED_ALLOCATOR_HPP
|
||||||
|
#define ASIO_ASSOCIATED_ALLOCATOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <memory>
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/detail/functional.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename T, typename Allocator>
|
||||||
|
struct associated_allocator;
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct has_allocator_type : false_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct has_allocator_type<T,
|
||||||
|
typename void_type<typename T::allocator_type>::type>
|
||||||
|
: true_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E, typename = void, typename = void>
|
||||||
|
struct associated_allocator_impl
|
||||||
|
{
|
||||||
|
typedef E type;
|
||||||
|
|
||||||
|
static type get(const T&, const E& e) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return e;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E>
|
||||||
|
struct associated_allocator_impl<T, E,
|
||||||
|
typename void_type<typename T::allocator_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::allocator_type type;
|
||||||
|
|
||||||
|
static type get(const T& t, const E&) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return t.get_allocator();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E>
|
||||||
|
struct associated_allocator_impl<T, E,
|
||||||
|
typename enable_if<
|
||||||
|
!has_allocator_type<T>::value
|
||||||
|
>::type,
|
||||||
|
typename void_type<
|
||||||
|
typename associator<associated_allocator, T, E>::type
|
||||||
|
>::type> : associator<associated_allocator, T, E>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Traits type used to obtain the allocator associated with an object.
|
||||||
|
/**
|
||||||
|
* A program may specialise this traits type if the @c T template parameter in
|
||||||
|
* the specialisation is a user-defined type. The template parameter @c
|
||||||
|
* Allocator shall be a type meeting the Allocator requirements.
|
||||||
|
*
|
||||||
|
* Specialisations shall meet the following requirements, where @c t is a const
|
||||||
|
* reference to an object of type @c T, and @c a is an object of type @c
|
||||||
|
* Allocator.
|
||||||
|
*
|
||||||
|
* @li Provide a nested typedef @c type that identifies a type meeting the
|
||||||
|
* Allocator requirements.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t) and with return type @c type.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t,a) and with return type @c type.
|
||||||
|
*/
|
||||||
|
template <typename T, typename Allocator = std::allocator<void> >
|
||||||
|
struct associated_allocator
|
||||||
|
{
|
||||||
|
/// If @c T has a nested type @c allocator_type, <tt>T::allocator_type</tt>.
|
||||||
|
/// Otherwise @c Allocator.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef see_below type;
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef typename detail::associated_allocator_impl<T, Allocator>::type type;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// If @c T has a nested type @c allocator_type, returns
|
||||||
|
/// <tt>t.get_allocator()</tt>. Otherwise returns @c a.
|
||||||
|
static type get(const T& t,
|
||||||
|
const Allocator& a = Allocator()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return detail::associated_allocator_impl<T, Allocator>::get(t, a);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated allocator.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_allocator<T>::get(t)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
ASIO_NODISCARD inline typename associated_allocator<T>::type
|
||||||
|
get_associated_allocator(const T& t) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_allocator<T>::get(t);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated allocator.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_allocator<T, Allocator>::get(t, a)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T, typename Allocator>
|
||||||
|
ASIO_NODISCARD inline typename associated_allocator<T, Allocator>::type
|
||||||
|
get_associated_allocator(const T& t, const Allocator& a) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_allocator<T, Allocator>::get(t, a);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename T, typename Allocator = std::allocator<void> >
|
||||||
|
using associated_allocator_t
|
||||||
|
= typename associated_allocator<T, Allocator>::type;
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Specialisation of associated_allocator for @c std::reference_wrapper.
|
||||||
|
template <typename T, typename Allocator>
|
||||||
|
struct associated_allocator<reference_wrapper<T>, Allocator>
|
||||||
|
{
|
||||||
|
/// Forwards @c type to the associator specialisation for the unwrapped type
|
||||||
|
/// @c T.
|
||||||
|
typedef typename associated_allocator<T, Allocator>::type type;
|
||||||
|
|
||||||
|
/// Forwards the request to get the allocator to the associator specialisation
|
||||||
|
/// for the unwrapped type @c T.
|
||||||
|
static type get(reference_wrapper<T> t,
|
||||||
|
const Allocator& a = Allocator()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_allocator<T, Allocator>::get(t.get(), a);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_ASSOCIATED_ALLOCATOR_HPP
|
||||||
|
|
@ -0,0 +1,178 @@
|
||||||
|
//
|
||||||
|
// associated_cancellation_slot.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
|
||||||
|
#define ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/cancellation_signal.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename T, typename CancellationSlot>
|
||||||
|
struct associated_cancellation_slot;
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct has_cancellation_slot_type : false_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct has_cancellation_slot_type<T,
|
||||||
|
typename void_type<typename T::cancellation_slot_type>::type>
|
||||||
|
: true_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename S, typename = void, typename = void>
|
||||||
|
struct associated_cancellation_slot_impl
|
||||||
|
{
|
||||||
|
typedef void asio_associated_cancellation_slot_is_unspecialised;
|
||||||
|
|
||||||
|
typedef S type;
|
||||||
|
|
||||||
|
static type get(const T&, const S& s = S()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename S>
|
||||||
|
struct associated_cancellation_slot_impl<T, S,
|
||||||
|
typename void_type<typename T::cancellation_slot_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::cancellation_slot_type type;
|
||||||
|
|
||||||
|
static type get(const T& t, const S& = S()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return t.get_cancellation_slot();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename S>
|
||||||
|
struct associated_cancellation_slot_impl<T, S,
|
||||||
|
typename enable_if<
|
||||||
|
!has_cancellation_slot_type<T>::value
|
||||||
|
>::type,
|
||||||
|
typename void_type<
|
||||||
|
typename associator<associated_cancellation_slot, T, S>::type
|
||||||
|
>::type> : associator<associated_cancellation_slot, T, S>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Traits type used to obtain the cancellation_slot associated with an object.
|
||||||
|
/**
|
||||||
|
* A program may specialise this traits type if the @c T template parameter in
|
||||||
|
* the specialisation is a user-defined type. The template parameter @c
|
||||||
|
* CancellationSlot shall be a type meeting the CancellationSlot requirements.
|
||||||
|
*
|
||||||
|
* Specialisations shall meet the following requirements, where @c t is a const
|
||||||
|
* reference to an object of type @c T, and @c s is an object of type @c
|
||||||
|
* CancellationSlot.
|
||||||
|
*
|
||||||
|
* @li Provide a nested typedef @c type that identifies a type meeting the
|
||||||
|
* CancellationSlot requirements.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t) and with return type @c type.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t,s) and with return type @c type.
|
||||||
|
*/
|
||||||
|
template <typename T, typename CancellationSlot = cancellation_slot>
|
||||||
|
struct associated_cancellation_slot
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: detail::associated_cancellation_slot_impl<T, CancellationSlot>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// If @c T has a nested type @c cancellation_slot_type,
|
||||||
|
/// <tt>T::cancellation_slot_type</tt>. Otherwise
|
||||||
|
/// @c CancellationSlot.
|
||||||
|
typedef see_below type;
|
||||||
|
|
||||||
|
/// If @c T has a nested type @c cancellation_slot_type, returns
|
||||||
|
/// <tt>t.get_cancellation_slot()</tt>. Otherwise returns @c s.
|
||||||
|
static type get(const T& t,
|
||||||
|
const CancellationSlot& s = CancellationSlot()) ASIO_NOEXCEPT;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated cancellation_slot.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_cancellation_slot<T>::get(t)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
ASIO_NODISCARD inline typename associated_cancellation_slot<T>::type
|
||||||
|
get_associated_cancellation_slot(const T& t) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_cancellation_slot<T>::get(t);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated cancellation_slot.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_cancellation_slot<T,
|
||||||
|
* CancellationSlot>::get(t, st)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T, typename CancellationSlot>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
typename associated_cancellation_slot<T, CancellationSlot>::type
|
||||||
|
get_associated_cancellation_slot(const T& t,
|
||||||
|
const CancellationSlot& st) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_cancellation_slot<T, CancellationSlot>::get(t, st);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename T, typename CancellationSlot = cancellation_slot>
|
||||||
|
using associated_cancellation_slot_t =
|
||||||
|
typename associated_cancellation_slot<T, CancellationSlot>::type;
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T, typename S, typename = void>
|
||||||
|
struct associated_cancellation_slot_forwarding_base
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename S>
|
||||||
|
struct associated_cancellation_slot_forwarding_base<T, S,
|
||||||
|
typename enable_if<
|
||||||
|
is_same<
|
||||||
|
typename associated_cancellation_slot<T,
|
||||||
|
S>::asio_associated_cancellation_slot_is_unspecialised,
|
||||||
|
void
|
||||||
|
>::value
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef void asio_associated_cancellation_slot_is_unspecialised;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_ASSOCIATED_CANCELLATION_SLOT_HPP
|
||||||
|
|
@ -0,0 +1,222 @@
|
||||||
|
//
|
||||||
|
// associated_executor.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_ASSOCIATED_EXECUTOR_HPP
|
||||||
|
#define ASIO_ASSOCIATED_EXECUTOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/detail/functional.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
#include "asio/system_executor.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
struct associated_executor;
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct has_executor_type : false_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct has_executor_type<T,
|
||||||
|
typename void_type<typename T::executor_type>::type>
|
||||||
|
: true_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E, typename = void, typename = void>
|
||||||
|
struct associated_executor_impl
|
||||||
|
{
|
||||||
|
typedef void asio_associated_executor_is_unspecialised;
|
||||||
|
|
||||||
|
typedef E type;
|
||||||
|
|
||||||
|
static type get(const T&, const E& e = E()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return e;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E>
|
||||||
|
struct associated_executor_impl<T, E,
|
||||||
|
typename void_type<typename T::executor_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::executor_type type;
|
||||||
|
|
||||||
|
static type get(const T& t, const E& = E()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return t.get_executor();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E>
|
||||||
|
struct associated_executor_impl<T, E,
|
||||||
|
typename enable_if<
|
||||||
|
!has_executor_type<T>::value
|
||||||
|
>::type,
|
||||||
|
typename void_type<
|
||||||
|
typename associator<associated_executor, T, E>::type
|
||||||
|
>::type> : associator<associated_executor, T, E>
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Traits type used to obtain the executor associated with an object.
|
||||||
|
/**
|
||||||
|
* A program may specialise this traits type if the @c T template parameter in
|
||||||
|
* the specialisation is a user-defined type. The template parameter @c
|
||||||
|
* Executor shall be a type meeting the Executor requirements.
|
||||||
|
*
|
||||||
|
* Specialisations shall meet the following requirements, where @c t is a const
|
||||||
|
* reference to an object of type @c T, and @c e is an object of type @c
|
||||||
|
* Executor.
|
||||||
|
*
|
||||||
|
* @li Provide a nested typedef @c type that identifies a type meeting the
|
||||||
|
* Executor requirements.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t) and with return type @c type.
|
||||||
|
*
|
||||||
|
* @li Provide a noexcept static member function named @c get, callable as @c
|
||||||
|
* get(t,e) and with return type @c type.
|
||||||
|
*/
|
||||||
|
template <typename T, typename Executor = system_executor>
|
||||||
|
struct associated_executor
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: detail::associated_executor_impl<T, Executor>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// If @c T has a nested type @c executor_type, <tt>T::executor_type</tt>.
|
||||||
|
/// Otherwise @c Executor.
|
||||||
|
typedef see_below type;
|
||||||
|
|
||||||
|
/// If @c T has a nested type @c executor_type, returns
|
||||||
|
/// <tt>t.get_executor()</tt>. Otherwise returns @c ex.
|
||||||
|
static type get(const T& t,
|
||||||
|
const Executor& ex = Executor()) ASIO_NOEXCEPT;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated executor.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_executor<T>::get(t)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T>
|
||||||
|
ASIO_NODISCARD inline typename associated_executor<T>::type
|
||||||
|
get_associated_executor(const T& t) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_executor<T>::get(t);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated executor.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_executor<T, Executor>::get(t, ex)</tt>
|
||||||
|
*/
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
ASIO_NODISCARD inline typename associated_executor<T, Executor>::type
|
||||||
|
get_associated_executor(const T& t, const Executor& ex,
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_executor<T, Executor>::get(t, ex);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Helper function to obtain an object's associated executor.
|
||||||
|
/**
|
||||||
|
* @returns <tt>associated_executor<T, typename
|
||||||
|
* ExecutionContext::executor_type>::get(t, ctx.get_executor())</tt>
|
||||||
|
*/
|
||||||
|
template <typename T, typename ExecutionContext>
|
||||||
|
ASIO_NODISCARD inline typename associated_executor<T,
|
||||||
|
typename ExecutionContext::executor_type>::type
|
||||||
|
get_associated_executor(const T& t, ExecutionContext& ctx,
|
||||||
|
typename constraint<is_convertible<ExecutionContext&,
|
||||||
|
execution_context&>::value>::type = 0) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_executor<T,
|
||||||
|
typename ExecutionContext::executor_type>::get(t, ctx.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename T, typename Executor = system_executor>
|
||||||
|
using associated_executor_t = typename associated_executor<T, Executor>::type;
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T, typename E, typename = void>
|
||||||
|
struct associated_executor_forwarding_base
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename E>
|
||||||
|
struct associated_executor_forwarding_base<T, E,
|
||||||
|
typename enable_if<
|
||||||
|
is_same<
|
||||||
|
typename associated_executor<T,
|
||||||
|
E>::asio_associated_executor_is_unspecialised,
|
||||||
|
void
|
||||||
|
>::value
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef void asio_associated_executor_is_unspecialised;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_REFERENCE_WRAPPER) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Specialisation of associated_executor for @c std::reference_wrapper.
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
struct associated_executor<reference_wrapper<T>, Executor>
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: detail::associated_executor_forwarding_base<T, Executor>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
/// Forwards @c type to the associator specialisation for the unwrapped type
|
||||||
|
/// @c T.
|
||||||
|
typedef typename associated_executor<T, Executor>::type type;
|
||||||
|
|
||||||
|
/// Forwards the request to get the executor to the associator specialisation
|
||||||
|
/// for the unwrapped type @c T.
|
||||||
|
static type get(reference_wrapper<T> t,
|
||||||
|
const Executor& ex = Executor()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return associated_executor<T, Executor>::get(t.get(), ex);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_REFERENCE_WRAPPER)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_ASSOCIATED_EXECUTOR_HPP
|
||||||
|
|
@ -0,0 +1,35 @@
|
||||||
|
//
|
||||||
|
// associator.hpp
|
||||||
|
// ~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_ASSOCIATOR_HPP
|
||||||
|
#define ASIO_ASSOCIATOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Used to generically specialise associators for a type.
|
||||||
|
template <template <typename, typename> class Associator,
|
||||||
|
typename T, typename DefaultCandidate>
|
||||||
|
struct associator
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_ASSOCIATOR_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,142 @@
|
||||||
|
//
|
||||||
|
// awaitable.hpp
|
||||||
|
// ~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_AWAITABLE_HPP
|
||||||
|
#define ASIO_AWAITABLE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
# include <coroutine>
|
||||||
|
#else // defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
# include <experimental/coroutine>
|
||||||
|
#endif // defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
|
||||||
|
#include <utility>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
using std::coroutine_handle;
|
||||||
|
using std::suspend_always;
|
||||||
|
#else // defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
using std::experimental::coroutine_handle;
|
||||||
|
using std::experimental::suspend_always;
|
||||||
|
#endif // defined(ASIO_HAS_STD_COROUTINE)
|
||||||
|
|
||||||
|
template <typename> class awaitable_thread;
|
||||||
|
template <typename, typename> class awaitable_frame;
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// The return type of a coroutine or asynchronous operation.
|
||||||
|
template <typename T, typename Executor = any_io_executor>
|
||||||
|
class ASIO_NODISCARD awaitable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the awaited value.
|
||||||
|
typedef T value_type;
|
||||||
|
|
||||||
|
/// The executor type that will be used for the coroutine.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Default constructor.
|
||||||
|
constexpr awaitable() noexcept
|
||||||
|
: frame_(nullptr)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move constructor.
|
||||||
|
awaitable(awaitable&& other) noexcept
|
||||||
|
: frame_(std::exchange(other.frame_, nullptr))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Destructor
|
||||||
|
~awaitable()
|
||||||
|
{
|
||||||
|
if (frame_)
|
||||||
|
frame_->destroy();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move assignment.
|
||||||
|
awaitable& operator=(awaitable&& other) noexcept
|
||||||
|
{
|
||||||
|
if (this != &other)
|
||||||
|
frame_ = std::exchange(other.frame_, nullptr);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Checks if the awaitable refers to a future result.
|
||||||
|
bool valid() const noexcept
|
||||||
|
{
|
||||||
|
return !!frame_;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
// Support for co_await keyword.
|
||||||
|
bool await_ready() const noexcept
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Support for co_await keyword.
|
||||||
|
template <class U>
|
||||||
|
void await_suspend(
|
||||||
|
detail::coroutine_handle<detail::awaitable_frame<U, Executor>> h)
|
||||||
|
{
|
||||||
|
frame_->push_frame(&h.promise());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Support for co_await keyword.
|
||||||
|
T await_resume()
|
||||||
|
{
|
||||||
|
return awaitable(static_cast<awaitable&&>(*this)).frame_->get();
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
private:
|
||||||
|
template <typename> friend class detail::awaitable_thread;
|
||||||
|
template <typename, typename> friend class detail::awaitable_frame;
|
||||||
|
|
||||||
|
// Not copy constructible or copy assignable.
|
||||||
|
awaitable(const awaitable&) = delete;
|
||||||
|
awaitable& operator=(const awaitable&) = delete;
|
||||||
|
|
||||||
|
// Construct the awaitable from a coroutine's frame object.
|
||||||
|
explicit awaitable(detail::awaitable_frame<T, Executor>* a)
|
||||||
|
: frame_(a)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
detail::awaitable_frame<T, Executor>* frame_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/awaitable.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_AWAITABLE_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,709 @@
|
||||||
|
//
|
||||||
|
// basic_deadline_timer.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_DEADLINE_TIMER_HPP
|
||||||
|
#define ASIO_BASIC_DEADLINE_TIMER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/detail/deadline_timer_service.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/time_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Provides waitable timer functionality.
|
||||||
|
/**
|
||||||
|
* The basic_deadline_timer class template provides the ability to perform a
|
||||||
|
* blocking or asynchronous wait for a timer to expire.
|
||||||
|
*
|
||||||
|
* A deadline timer is always in one of two states: "expired" or "not expired".
|
||||||
|
* If the wait() or async_wait() function is called on an expired timer, the
|
||||||
|
* wait operation will complete immediately.
|
||||||
|
*
|
||||||
|
* Most applications will use the asio::deadline_timer typedef.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Examples
|
||||||
|
* Performing a blocking wait:
|
||||||
|
* @code
|
||||||
|
* // Construct a timer without setting an expiry time.
|
||||||
|
* asio::deadline_timer timer(my_context);
|
||||||
|
*
|
||||||
|
* // Set an expiry time relative to now.
|
||||||
|
* timer.expires_from_now(boost::posix_time::seconds(5));
|
||||||
|
*
|
||||||
|
* // Wait for the timer to expire.
|
||||||
|
* timer.wait();
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par
|
||||||
|
* Performing an asynchronous wait:
|
||||||
|
* @code
|
||||||
|
* void handler(const asio::error_code& error)
|
||||||
|
* {
|
||||||
|
* if (!error)
|
||||||
|
* {
|
||||||
|
* // Timer expired.
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* ...
|
||||||
|
*
|
||||||
|
* // Construct a timer with an absolute expiry time.
|
||||||
|
* asio::deadline_timer timer(my_context,
|
||||||
|
* boost::posix_time::time_from_string("2005-12-07 23:59:59.000"));
|
||||||
|
*
|
||||||
|
* // Start an asynchronous wait.
|
||||||
|
* timer.async_wait(handler);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Changing an active deadline_timer's expiry time
|
||||||
|
*
|
||||||
|
* Changing the expiry time of a timer while there are pending asynchronous
|
||||||
|
* waits causes those wait operations to be cancelled. To ensure that the action
|
||||||
|
* associated with the timer is performed only once, use something like this:
|
||||||
|
* used:
|
||||||
|
*
|
||||||
|
* @code
|
||||||
|
* void on_some_event()
|
||||||
|
* {
|
||||||
|
* if (my_timer.expires_from_now(seconds(5)) > 0)
|
||||||
|
* {
|
||||||
|
* // We managed to cancel the timer. Start new asynchronous wait.
|
||||||
|
* my_timer.async_wait(on_timeout);
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* // Too late, timer has already expired!
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* void on_timeout(const asio::error_code& e)
|
||||||
|
* {
|
||||||
|
* if (e != asio::error::operation_aborted)
|
||||||
|
* {
|
||||||
|
* // Timer was not cancelled, take necessary action.
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @li The asio::basic_deadline_timer::expires_from_now() function
|
||||||
|
* cancels any pending asynchronous waits, and returns the number of
|
||||||
|
* asynchronous waits that were cancelled. If it returns 0 then you were too
|
||||||
|
* late and the wait handler has already been executed, or will soon be
|
||||||
|
* executed. If it returns 1 then the wait handler was successfully cancelled.
|
||||||
|
*
|
||||||
|
* @li If a wait handler is cancelled, the asio::error_code passed to
|
||||||
|
* it contains the value asio::error::operation_aborted.
|
||||||
|
*/
|
||||||
|
template <typename Time,
|
||||||
|
typename TimeTraits = asio::time_traits<Time>,
|
||||||
|
typename Executor = any_io_executor>
|
||||||
|
class basic_deadline_timer
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the timer type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The timer type when rebound to the specified executor.
|
||||||
|
typedef basic_deadline_timer<Time, TimeTraits, Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The time traits type.
|
||||||
|
typedef TimeTraits traits_type;
|
||||||
|
|
||||||
|
/// The time type.
|
||||||
|
typedef typename traits_type::time_type time_type;
|
||||||
|
|
||||||
|
/// The duration type.
|
||||||
|
typedef typename traits_type::duration_type duration_type;
|
||||||
|
|
||||||
|
/// Constructor.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer without setting an expiry time. The
|
||||||
|
* expires_at() or expires_from_now() functions must be called to set an
|
||||||
|
* expiry time before the timer can be waited on.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*/
|
||||||
|
explicit basic_deadline_timer(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer without setting an expiry time. The
|
||||||
|
* expires_at() or expires_from_now() functions must be called to set an
|
||||||
|
* expiry time before the timer can be waited on.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_deadline_timer(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, expressed
|
||||||
|
* as an absolute time.
|
||||||
|
*/
|
||||||
|
basic_deadline_timer(const executor_type& ex, const time_type& expiry_time)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, expressed
|
||||||
|
* as an absolute time.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_deadline_timer(ExecutionContext& context, const time_type& expiry_time,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, relative to
|
||||||
|
* now.
|
||||||
|
*/
|
||||||
|
basic_deadline_timer(const executor_type& ex,
|
||||||
|
const duration_type& expiry_time)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_from_now");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, relative to
|
||||||
|
* now.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_deadline_timer(ExecutionContext& context,
|
||||||
|
const duration_type& expiry_time,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_from_now");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_deadline_timer from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a timer from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_deadline_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_deadline_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_deadline_timer(basic_deadline_timer&& other)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_deadline_timer from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a timer from one object to another. Cancels
|
||||||
|
* any outstanding asynchronous operations associated with the target object.
|
||||||
|
*
|
||||||
|
* @param other The other basic_deadline_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_deadline_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_deadline_timer& operator=(basic_deadline_timer&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the timer.
|
||||||
|
/**
|
||||||
|
* This function destroys the timer, cancelling any outstanding asynchronous
|
||||||
|
* wait operations associated with the timer as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_deadline_timer()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel any asynchronous operations that are waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the timer. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel any asynchronous operations that are waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the timer. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancels one asynchronous operation that is waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of one pending asynchronous wait
|
||||||
|
* operation against the timer. Handlers are cancelled in FIFO order. The
|
||||||
|
* handler for the cancelled operation will be invoked with the
|
||||||
|
* asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled. That is,
|
||||||
|
* either 0 or 1.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel_one() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel_one()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().cancel_one(
|
||||||
|
impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel_one");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancels one asynchronous operation that is waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of one pending asynchronous wait
|
||||||
|
* operation against the timer. Handlers are cancelled in FIFO order. The
|
||||||
|
* handler for the cancelled operation will be invoked with the
|
||||||
|
* asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled. That is,
|
||||||
|
* either 0 or 1.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel_one() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel_one(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().cancel_one(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the timer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the timer's current expiry time.
|
||||||
|
* Whether the timer has expired or not does not affect this value.
|
||||||
|
*/
|
||||||
|
time_type expires_at() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_at(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the timer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_at() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_at(const time_type& expiry_time)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().expires_at(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the timer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_at() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_at(const time_type& expiry_time,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_at(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the timer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the timer's current expiry time.
|
||||||
|
* Whether the timer has expired or not does not affect this value.
|
||||||
|
*/
|
||||||
|
duration_type expires_from_now() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_from_now(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the timer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_from_now() is called,
|
||||||
|
* then the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_from_now(const duration_type& expiry_time)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_from_now");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the timer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_from_now() is called,
|
||||||
|
* then the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_from_now(const duration_type& expiry_time,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a blocking wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function is used to wait for the timer to expire. This function
|
||||||
|
* blocks and does not return until the timer has expired.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void wait()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().wait(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "wait");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a blocking wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function is used to wait for the timer to expire. This function
|
||||||
|
* blocks and does not return until the timer has expired.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
void wait(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().wait(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function may be used to initiate an asynchronous wait against the
|
||||||
|
* timer. It is an initiating function for an @ref asynchronous_operation,
|
||||||
|
* and always returns immediately.
|
||||||
|
*
|
||||||
|
* For each call to async_wait(), the completion handler will be called
|
||||||
|
* exactly once. The completion handler will be called when:
|
||||||
|
*
|
||||||
|
* @li The timer has expired.
|
||||||
|
*
|
||||||
|
* @li The timer was cancelled, in which case the handler is passed the error
|
||||||
|
* code asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the timer expires. Potential
|
||||||
|
* completion tokens include @ref use_future, @ref use_awaitable, @ref
|
||||||
|
* yield_context, or a function object with the correct completion signature.
|
||||||
|
* The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error // Result of operation.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code) @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* This asynchronous operation supports cancellation for the following
|
||||||
|
* asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
|
||||||
|
WaitToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
|
||||||
|
void (asio::error_code))
|
||||||
|
async_wait(
|
||||||
|
ASIO_MOVE_ARG(WaitToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WaitToken, void (asio::error_code)>(
|
||||||
|
initiate_async_wait(this), token);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_deadline_timer(const basic_deadline_timer&) ASIO_DELETED;
|
||||||
|
basic_deadline_timer& operator=(
|
||||||
|
const basic_deadline_timer&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_wait
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_wait(basic_deadline_timer* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WaitHandler>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WaitHandler) handler) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WaitHandler.
|
||||||
|
ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WaitHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_wait(
|
||||||
|
self_->impl_.get_implementation(),
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_deadline_timer* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
detail::io_object_impl<
|
||||||
|
detail::deadline_timer_service<TimeTraits>, Executor> impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_DEADLINE_TIMER_HPP
|
||||||
|
|
@ -0,0 +1,829 @@
|
||||||
|
//
|
||||||
|
// basic_file.hpp
|
||||||
|
// ~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_FILE_HPP
|
||||||
|
#define ASIO_BASIC_FILE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_FILE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/cstdint.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/post.hpp"
|
||||||
|
#include "asio/file_base.hpp"
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
# include "asio/detail/win_iocp_file_service.hpp"
|
||||||
|
#elif defined(ASIO_HAS_IO_URING)
|
||||||
|
# include "asio/detail/io_uring_file_service.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_FILE_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_FILE_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_file;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_FILE_FWD_DECL)
|
||||||
|
|
||||||
|
/// Provides file functionality.
|
||||||
|
/**
|
||||||
|
* The basic_file class template provides functionality that is common to both
|
||||||
|
* stream-oriented and random-access files.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*/
|
||||||
|
template <typename Executor>
|
||||||
|
class basic_file
|
||||||
|
: public file_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the file type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The file type when rebound to the specified executor.
|
||||||
|
typedef basic_file<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a file.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IOCP)
|
||||||
|
typedef detail::win_iocp_file_service::native_handle_type native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING)
|
||||||
|
typedef detail::io_uring_file_service::native_handle_type native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*/
|
||||||
|
explicit basic_file(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_file(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file and opens it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*/
|
||||||
|
explicit basic_file(const executor_type& ex,
|
||||||
|
const char* path, file_base::flags open_flags)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file and opens it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_file(ExecutionContext& context,
|
||||||
|
const char* path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file and opens it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*/
|
||||||
|
explicit basic_file(const executor_type& ex,
|
||||||
|
const std::string& path, file_base::flags open_flags)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file and opens it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_file(ExecutionContext& context,
|
||||||
|
const std::string& path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_file on an existing native file handle.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file object to hold an existing native file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file A native file handle.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_file(const executor_type& ex, const native_handle_type& native_file)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(
|
||||||
|
impl_.get_implementation(), native_file, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_file on an existing native file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file object to hold an existing native file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file A native file.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_file(ExecutionContext& context, const native_handle_type& native_file,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(
|
||||||
|
impl_.get_implementation(), native_file, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_file from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_file object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_file(const executor_type&) constructor.
|
||||||
|
*/
|
||||||
|
basic_file(basic_file&& other) ASIO_NOEXCEPT
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_file from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_file object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_file(const executor_type&) constructor.
|
||||||
|
*/
|
||||||
|
basic_file& operator=(basic_file&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
// All files have access to each other's implementations.
|
||||||
|
template <typename Executor1>
|
||||||
|
friend class basic_file;
|
||||||
|
|
||||||
|
/// Move-construct a basic_file from a file of another executor type.
|
||||||
|
/**
|
||||||
|
* This constructor moves a file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_file object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_file(const executor_type&) constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
basic_file(basic_file<Executor1>&& other,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_file from a file of another executor type.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_file object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_file(const executor_type&) constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
basic_file&
|
||||||
|
>::type operator=(basic_file<Executor1> && other)
|
||||||
|
{
|
||||||
|
basic_file tmp(std::move(other));
|
||||||
|
impl_ = std::move(tmp.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the file using the specified path.
|
||||||
|
/**
|
||||||
|
* This function opens the file so that it will use the specified path.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::stream_file file(my_context);
|
||||||
|
* file.open("/path/to/my/file", asio::stream_file::read_only);
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
void open(const char* path, file_base::flags open_flags)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the file using the specified path.
|
||||||
|
/**
|
||||||
|
* This function opens the file so that it will use the specified path.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::stream_file file(my_context);
|
||||||
|
* asio::error_code ec;
|
||||||
|
* file.open("/path/to/my/file", asio::stream_file::read_only, ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID open(const char* path,
|
||||||
|
file_base::flags open_flags, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), path, open_flags, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the file using the specified path.
|
||||||
|
/**
|
||||||
|
* This function opens the file so that it will use the specified path.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::stream_file file(my_context);
|
||||||
|
* file.open("/path/to/my/file", asio::stream_file::read_only);
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
void open(const std::string& path, file_base::flags open_flags)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the file using the specified path.
|
||||||
|
/**
|
||||||
|
* This function opens the file so that it will use the specified path.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::stream_file file(my_context);
|
||||||
|
* asio::error_code ec;
|
||||||
|
* file.open("/path/to/my/file", asio::stream_file::read_only, ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID open(const std::string& path,
|
||||||
|
file_base::flags open_flags, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().open(impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native file to the file.
|
||||||
|
/*
|
||||||
|
* This function opens the file to hold an existing native file.
|
||||||
|
*
|
||||||
|
* @param native_file A native file.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void assign(const native_handle_type& native_file)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(
|
||||||
|
impl_.get_implementation(), native_file, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native file to the file.
|
||||||
|
/*
|
||||||
|
* This function opens the file to hold an existing native file.
|
||||||
|
*
|
||||||
|
* @param native_file A native file.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID assign(const native_handle_type& native_file,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().assign(
|
||||||
|
impl_.get_implementation(), native_file, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine whether the file is open.
|
||||||
|
bool is_open() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().is_open(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the file.
|
||||||
|
/**
|
||||||
|
* This function is used to close the file. Any asynchronous read or write
|
||||||
|
* operations will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. Note that, even if
|
||||||
|
* the function indicates an error, the underlying descriptor is closed.
|
||||||
|
*/
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "close");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the file.
|
||||||
|
/**
|
||||||
|
* This function is used to close the file. Any asynchronous read or write
|
||||||
|
* operations will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any. Note that, even if
|
||||||
|
* the function indicates an error, the underlying descriptor is closed.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::stream_file file(my_context);
|
||||||
|
* ...
|
||||||
|
* asio::error_code ec;
|
||||||
|
* file.close(ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Release ownership of the underlying native file.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read and write
|
||||||
|
* operations to finish immediately, and the handlers for cancelled
|
||||||
|
* operations will be passed the asio::error::operation_aborted error.
|
||||||
|
* Ownership of the native file is then transferred to the caller.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note This function is unsupported on Windows versions prior to Windows
|
||||||
|
* 8.1, and will fail with asio::error::operation_not_supported on
|
||||||
|
* these platforms.
|
||||||
|
*/
|
||||||
|
#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
|
||||||
|
&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
|
||||||
|
__declspec(deprecated("This function always fails with "
|
||||||
|
"operation_not_supported when used on Windows versions "
|
||||||
|
"prior to Windows 8.1."))
|
||||||
|
#endif
|
||||||
|
native_handle_type release()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
native_handle_type s = impl_.get_service().release(
|
||||||
|
impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "release");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Release ownership of the underlying native file.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read and write
|
||||||
|
* operations to finish immediately, and the handlers for cancelled
|
||||||
|
* operations will be passed the asio::error::operation_aborted error.
|
||||||
|
* Ownership of the native file is then transferred to the caller.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @note This function is unsupported on Windows versions prior to Windows
|
||||||
|
* 8.1, and will fail with asio::error::operation_not_supported on
|
||||||
|
* these platforms.
|
||||||
|
*/
|
||||||
|
#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
|
||||||
|
&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0603)
|
||||||
|
__declspec(deprecated("This function always fails with "
|
||||||
|
"operation_not_supported when used on Windows versions "
|
||||||
|
"prior to Windows 8.1."))
|
||||||
|
#endif
|
||||||
|
native_handle_type release(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().release(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the native file representation.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the underlying representation of the
|
||||||
|
* file. This is intended to allow access to native file functionality
|
||||||
|
* that is not otherwise provided.
|
||||||
|
*/
|
||||||
|
native_handle_type native_handle()
|
||||||
|
{
|
||||||
|
return impl_.get_service().native_handle(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the file.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read and write
|
||||||
|
* operations to finish immediately, and the handlers for cancelled
|
||||||
|
* operations will be passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note Calls to cancel() will always fail with
|
||||||
|
* asio::error::operation_not_supported when run on Windows XP, Windows
|
||||||
|
* Server 2003, and earlier versions of Windows, unless
|
||||||
|
* ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
|
||||||
|
* two issues that should be considered before enabling its use:
|
||||||
|
*
|
||||||
|
* @li It will only cancel asynchronous operations that were initiated in the
|
||||||
|
* current thread.
|
||||||
|
*
|
||||||
|
* @li It can appear to complete without error, but the request to cancel the
|
||||||
|
* unfinished operations may be silently ignored by the operating system.
|
||||||
|
* Whether it works or not seems to depend on the drivers that are installed.
|
||||||
|
*
|
||||||
|
* For portable cancellation, consider using the close() function to
|
||||||
|
* simultaneously cancel the outstanding operations and close the file.
|
||||||
|
*
|
||||||
|
* When running on Windows Vista, Windows Server 2008, and later, the
|
||||||
|
* CancelIoEx function is always used. This function does not have the
|
||||||
|
* problems described above.
|
||||||
|
*/
|
||||||
|
#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
|
||||||
|
&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
|
||||||
|
&& !defined(ASIO_ENABLE_CANCELIO)
|
||||||
|
__declspec(deprecated("By default, this function always fails with "
|
||||||
|
"operation_not_supported when used on Windows XP, Windows Server 2003, "
|
||||||
|
"or earlier. Consult documentation for details."))
|
||||||
|
#endif
|
||||||
|
void cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the file.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read and write
|
||||||
|
* operations to finish immediately, and the handlers for cancelled
|
||||||
|
* operations will be passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @note Calls to cancel() will always fail with
|
||||||
|
* asio::error::operation_not_supported when run on Windows XP, Windows
|
||||||
|
* Server 2003, and earlier versions of Windows, unless
|
||||||
|
* ASIO_ENABLE_CANCELIO is defined. However, the CancelIo function has
|
||||||
|
* two issues that should be considered before enabling its use:
|
||||||
|
*
|
||||||
|
* @li It will only cancel asynchronous operations that were initiated in the
|
||||||
|
* current thread.
|
||||||
|
*
|
||||||
|
* @li It can appear to complete without error, but the request to cancel the
|
||||||
|
* unfinished operations may be silently ignored by the operating system.
|
||||||
|
* Whether it works or not seems to depend on the drivers that are installed.
|
||||||
|
*
|
||||||
|
* For portable cancellation, consider using the close() function to
|
||||||
|
* simultaneously cancel the outstanding operations and close the file.
|
||||||
|
*
|
||||||
|
* When running on Windows Vista, Windows Server 2008, and later, the
|
||||||
|
* CancelIoEx function is always used. This function does not have the
|
||||||
|
* problems described above.
|
||||||
|
*/
|
||||||
|
#if defined(ASIO_MSVC) && (ASIO_MSVC >= 1400) \
|
||||||
|
&& (!defined(_WIN32_WINNT) || _WIN32_WINNT < 0x0600) \
|
||||||
|
&& !defined(ASIO_ENABLE_CANCELIO)
|
||||||
|
__declspec(deprecated("By default, this function always fails with "
|
||||||
|
"operation_not_supported when used on Windows XP, Windows Server 2003, "
|
||||||
|
"or earlier. Consult documentation for details."))
|
||||||
|
#endif
|
||||||
|
ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the size of the file.
|
||||||
|
/**
|
||||||
|
* This function determines the size of the file, in bytes.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
uint64_t size() const
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
uint64_t s = impl_.get_service().size(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "size");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the size of the file.
|
||||||
|
/**
|
||||||
|
* This function determines the size of the file, in bytes.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
uint64_t size(asio::error_code& ec) const
|
||||||
|
{
|
||||||
|
return impl_.get_service().size(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Alter the size of the file.
|
||||||
|
/**
|
||||||
|
* This function resizes the file to the specified size, in bytes. If the
|
||||||
|
* current file size exceeds @c n then any extra data is discarded. If the
|
||||||
|
* current size is less than @c n then the file is extended and filled with
|
||||||
|
* zeroes.
|
||||||
|
*
|
||||||
|
* @param n The new size for the file.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void resize(uint64_t n)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().resize(impl_.get_implementation(), n, ec);
|
||||||
|
asio::detail::throw_error(ec, "resize");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Alter the size of the file.
|
||||||
|
/**
|
||||||
|
* This function resizes the file to the specified size, in bytes. If the
|
||||||
|
* current file size exceeds @c n then any extra data is discarded. If the
|
||||||
|
* current size is less than @c n then the file is extended and filled with
|
||||||
|
* zeroes.
|
||||||
|
*
|
||||||
|
* @param n The new size for the file.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID resize(uint64_t n, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().resize(impl_.get_implementation(), n, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Synchronise the file to disk.
|
||||||
|
/**
|
||||||
|
* This function synchronises the file data and metadata to disk. Note that
|
||||||
|
* the semantics of this synchronisation vary between operation systems.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void sync_all()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().sync_all(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "sync_all");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Synchronise the file to disk.
|
||||||
|
/**
|
||||||
|
* This function synchronises the file data and metadata to disk. Note that
|
||||||
|
* the semantics of this synchronisation vary between operation systems.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID sync_all(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().sync_all(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Synchronise the file data to disk.
|
||||||
|
/**
|
||||||
|
* This function synchronises the file data to disk. Note that the semantics
|
||||||
|
* of this synchronisation vary between operation systems.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void sync_data()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().sync_data(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "sync_data");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Synchronise the file data to disk.
|
||||||
|
/**
|
||||||
|
* This function synchronises the file data to disk. Note that the semantics
|
||||||
|
* of this synchronisation vary between operation systems.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID sync_data(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().sync_data(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
/// Protected destructor to prevent deletion through this type.
|
||||||
|
/**
|
||||||
|
* This function destroys the file, cancelling any outstanding asynchronous
|
||||||
|
* operations associated with the file as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_file()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
detail::io_object_impl<detail::win_iocp_file_service, Executor> impl_;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING)
|
||||||
|
detail::io_object_impl<detail::io_uring_file_service, Executor> impl_;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_file(const basic_file&) ASIO_DELETED;
|
||||||
|
basic_file& operator=(const basic_file&) ASIO_DELETED;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_FILE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_FILE_HPP
|
||||||
|
|
@ -0,0 +1,290 @@
|
||||||
|
//
|
||||||
|
// basic_io_object.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_IO_OBJECT_HPP
|
||||||
|
#define ASIO_BASIC_IO_OBJECT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/io_context.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
namespace detail
|
||||||
|
{
|
||||||
|
// Type trait used to determine whether a service supports move.
|
||||||
|
template <typename IoObjectService>
|
||||||
|
class service_has_move
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
typedef IoObjectService service_type;
|
||||||
|
typedef typename service_type::implementation_type implementation_type;
|
||||||
|
|
||||||
|
template <typename T, typename U>
|
||||||
|
static auto asio_service_has_move_eval(T* t, U* u)
|
||||||
|
-> decltype(t->move_construct(*u, *u), char());
|
||||||
|
static char (&asio_service_has_move_eval(...))[2];
|
||||||
|
|
||||||
|
public:
|
||||||
|
static const bool value =
|
||||||
|
sizeof(asio_service_has_move_eval(
|
||||||
|
static_cast<service_type*>(0),
|
||||||
|
static_cast<implementation_type*>(0))) == 1;
|
||||||
|
};
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
/// Base class for all I/O objects.
|
||||||
|
/**
|
||||||
|
* @note All I/O objects are non-copyable. However, when using C++0x, certain
|
||||||
|
* I/O objects do support move construction and move assignment.
|
||||||
|
*/
|
||||||
|
#if !defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename IoObjectService>
|
||||||
|
#else
|
||||||
|
template <typename IoObjectService,
|
||||||
|
bool Movable = detail::service_has_move<IoObjectService>::value>
|
||||||
|
#endif
|
||||||
|
class basic_io_object
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the service that will be used to provide I/O operations.
|
||||||
|
typedef IoObjectService service_type;
|
||||||
|
|
||||||
|
/// The underlying implementation type of I/O object.
|
||||||
|
typedef typename service_type::implementation_type implementation_type;
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use get_executor().) Get the io_context associated with the
|
||||||
|
/// object.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the io_context object that the I/O
|
||||||
|
* object uses to dispatch handlers for asynchronous operations.
|
||||||
|
*
|
||||||
|
* @return A reference to the io_context object that the I/O object will use
|
||||||
|
* to dispatch handlers. Ownership is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
asio::io_context& get_io_context()
|
||||||
|
{
|
||||||
|
return service_.get_io_context();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use get_executor().) Get the io_context associated with the
|
||||||
|
/// object.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the io_context object that the I/O
|
||||||
|
* object uses to dispatch handlers for asynchronous operations.
|
||||||
|
*
|
||||||
|
* @return A reference to the io_context object that the I/O object will use
|
||||||
|
* to dispatch handlers. Ownership is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
asio::io_context& get_io_service()
|
||||||
|
{
|
||||||
|
return service_.get_io_context();
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef asio::io_context::executor_type executor_type;
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return service_.get_io_context().get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
/// Construct a basic_io_object.
|
||||||
|
/**
|
||||||
|
* Performs:
|
||||||
|
* @code get_service().construct(get_implementation()); @endcode
|
||||||
|
*/
|
||||||
|
explicit basic_io_object(asio::io_context& io_context)
|
||||||
|
: service_(asio::use_service<IoObjectService>(io_context))
|
||||||
|
{
|
||||||
|
service_.construct(implementation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_io_object.
|
||||||
|
/**
|
||||||
|
* Performs:
|
||||||
|
* @code get_service().move_construct(
|
||||||
|
* get_implementation(), other.get_implementation()); @endcode
|
||||||
|
*
|
||||||
|
* @note Available only for services that support movability,
|
||||||
|
*/
|
||||||
|
basic_io_object(basic_io_object&& other);
|
||||||
|
|
||||||
|
/// Move-assign a basic_io_object.
|
||||||
|
/**
|
||||||
|
* Performs:
|
||||||
|
* @code get_service().move_assign(get_implementation(),
|
||||||
|
* other.get_service(), other.get_implementation()); @endcode
|
||||||
|
*
|
||||||
|
* @note Available only for services that support movability,
|
||||||
|
*/
|
||||||
|
basic_io_object& operator=(basic_io_object&& other);
|
||||||
|
|
||||||
|
/// Perform a converting move-construction of a basic_io_object.
|
||||||
|
template <typename IoObjectService1>
|
||||||
|
basic_io_object(IoObjectService1& other_service,
|
||||||
|
typename IoObjectService1::implementation_type& other_implementation);
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Protected destructor to prevent deletion through this type.
|
||||||
|
/**
|
||||||
|
* Performs:
|
||||||
|
* @code get_service().destroy(get_implementation()); @endcode
|
||||||
|
*/
|
||||||
|
~basic_io_object()
|
||||||
|
{
|
||||||
|
service_.destroy(implementation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the service associated with the I/O object.
|
||||||
|
service_type& get_service()
|
||||||
|
{
|
||||||
|
return service_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the service associated with the I/O object.
|
||||||
|
const service_type& get_service() const
|
||||||
|
{
|
||||||
|
return service_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the underlying implementation of the I/O object.
|
||||||
|
implementation_type& get_implementation()
|
||||||
|
{
|
||||||
|
return implementation_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the underlying implementation of the I/O object.
|
||||||
|
const implementation_type& get_implementation() const
|
||||||
|
{
|
||||||
|
return implementation_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_io_object(const basic_io_object&);
|
||||||
|
basic_io_object& operator=(const basic_io_object&);
|
||||||
|
|
||||||
|
// The service associated with the I/O object.
|
||||||
|
service_type& service_;
|
||||||
|
|
||||||
|
/// The underlying implementation of the I/O object.
|
||||||
|
implementation_type implementation_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
// Specialisation for movable objects.
|
||||||
|
template <typename IoObjectService>
|
||||||
|
class basic_io_object<IoObjectService, true>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef IoObjectService service_type;
|
||||||
|
typedef typename service_type::implementation_type implementation_type;
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
asio::io_context& get_io_context()
|
||||||
|
{
|
||||||
|
return service_->get_io_context();
|
||||||
|
}
|
||||||
|
|
||||||
|
asio::io_context& get_io_service()
|
||||||
|
{
|
||||||
|
return service_->get_io_context();
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
typedef asio::io_context::executor_type executor_type;
|
||||||
|
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return service_->get_io_context().get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
explicit basic_io_object(asio::io_context& io_context)
|
||||||
|
: service_(&asio::use_service<IoObjectService>(io_context))
|
||||||
|
{
|
||||||
|
service_->construct(implementation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
basic_io_object(basic_io_object&& other)
|
||||||
|
: service_(&other.get_service())
|
||||||
|
{
|
||||||
|
service_->move_construct(implementation_, other.implementation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename IoObjectService1>
|
||||||
|
basic_io_object(IoObjectService1& other_service,
|
||||||
|
typename IoObjectService1::implementation_type& other_implementation)
|
||||||
|
: service_(&asio::use_service<IoObjectService>(
|
||||||
|
other_service.get_io_context()))
|
||||||
|
{
|
||||||
|
service_->converting_move_construct(implementation_,
|
||||||
|
other_service, other_implementation);
|
||||||
|
}
|
||||||
|
|
||||||
|
~basic_io_object()
|
||||||
|
{
|
||||||
|
service_->destroy(implementation_);
|
||||||
|
}
|
||||||
|
|
||||||
|
basic_io_object& operator=(basic_io_object&& other)
|
||||||
|
{
|
||||||
|
service_->move_assign(implementation_,
|
||||||
|
*other.service_, other.implementation_);
|
||||||
|
service_ = other.service_;
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
service_type& get_service()
|
||||||
|
{
|
||||||
|
return *service_;
|
||||||
|
}
|
||||||
|
|
||||||
|
const service_type& get_service() const
|
||||||
|
{
|
||||||
|
return *service_;
|
||||||
|
}
|
||||||
|
|
||||||
|
implementation_type& get_implementation()
|
||||||
|
{
|
||||||
|
return implementation_;
|
||||||
|
}
|
||||||
|
|
||||||
|
const implementation_type& get_implementation() const
|
||||||
|
{
|
||||||
|
return implementation_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_io_object(const basic_io_object&);
|
||||||
|
void operator=(const basic_io_object&);
|
||||||
|
|
||||||
|
IoObjectService* service_;
|
||||||
|
implementation_type implementation_;
|
||||||
|
};
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_IO_OBJECT_HPP
|
||||||
|
|
@ -0,0 +1,689 @@
|
||||||
|
//
|
||||||
|
// basic_random_access_file.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
|
||||||
|
#define ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_FILE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/basic_file.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_random_access_file;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_RANDOM_ACCESS_FILE_FWD_DECL)
|
||||||
|
|
||||||
|
/// Provides random-access file functionality.
|
||||||
|
/**
|
||||||
|
* The basic_random_access_file class template provides asynchronous and
|
||||||
|
* blocking random-access file functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* Synchronous @c read_some_at and @c write_some_at operations are thread safe
|
||||||
|
* with respect to each other, if the underlying operating system calls are
|
||||||
|
* also thread safe. This means that it is permitted to perform concurrent
|
||||||
|
* calls to these synchronous operations on a single file object. Other
|
||||||
|
* synchronous operations, such as @c open or @c close, are not thread safe.
|
||||||
|
*/
|
||||||
|
template <typename Executor>
|
||||||
|
class basic_random_access_file
|
||||||
|
: public basic_file<Executor>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the file type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The file type when rebound to the specified executor.
|
||||||
|
typedef basic_random_access_file<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a file.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef typename basic_file<Executor>::native_handle_type native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_random_access_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it. The file needs to
|
||||||
|
* be opened before data can be read from or or written to it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*/
|
||||||
|
explicit basic_random_access_file(const executor_type& ex)
|
||||||
|
: basic_file<Executor>(ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_random_access_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it. The file needs to
|
||||||
|
* be opened before data can be read from or or written to it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_random_access_file(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_random_access_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_random_access_file(const executor_type& ex,
|
||||||
|
const char* path, file_base::flags open_flags)
|
||||||
|
: basic_file<Executor>(ex, path, open_flags)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_random_access_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_random_access_file(ExecutionContext& context,
|
||||||
|
const char* path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context, path, open_flags)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_random_access_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_random_access_file(const executor_type& ex,
|
||||||
|
const std::string& path, file_base::flags open_flags)
|
||||||
|
: basic_file<Executor>(ex, path, open_flags)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_random_access_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_random_access_file(ExecutionContext& context,
|
||||||
|
const std::string& path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context, path, open_flags)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_random_access_file on an existing native file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a random-access file object to hold an
|
||||||
|
* existing native file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file The new underlying file implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_random_access_file(const executor_type& ex,
|
||||||
|
const native_handle_type& native_file)
|
||||||
|
: basic_file<Executor>(ex, native_file)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_random_access_file on an existing native file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a random-access file object to hold an
|
||||||
|
* existing native file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file The new underlying file implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_random_access_file(ExecutionContext& context,
|
||||||
|
const native_handle_type& native_file,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context, native_file)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_random_access_file from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a random-access file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_random_access_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_random_access_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_random_access_file(basic_random_access_file&& other) ASIO_NOEXCEPT
|
||||||
|
: basic_file<Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_random_access_file from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a random-access file from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_random_access_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_random_access_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_random_access_file& operator=(basic_random_access_file&& other)
|
||||||
|
{
|
||||||
|
basic_file<Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-construct a basic_random_access_file from a file of another executor
|
||||||
|
/// type.
|
||||||
|
/**
|
||||||
|
* This constructor moves a random-access file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_random_access_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_random_access_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
basic_random_access_file(basic_random_access_file<Executor1>&& other,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_random_access_file from a file of another executor
|
||||||
|
/// type.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a random-access file from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_random_access_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_random_access_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
basic_random_access_file&
|
||||||
|
>::type operator=(basic_random_access_file<Executor1>&& other)
|
||||||
|
{
|
||||||
|
basic_file<Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the file.
|
||||||
|
/**
|
||||||
|
* This function destroys the file, cancelling any outstanding asynchronous
|
||||||
|
* operations associated with the file as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_random_access_file()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the handle at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the random-access handle. The
|
||||||
|
* function call will block until one or more bytes of the data has been
|
||||||
|
* written successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be written.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the handle.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the end of the file was reached.
|
||||||
|
*
|
||||||
|
* @note The write_some_at operation may not write all of the data. Consider
|
||||||
|
* using the @ref write_at function if you need to ensure that all data is
|
||||||
|
* written before the blocking operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* handle.write_some_at(42, asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some_at(uint64_t offset,
|
||||||
|
const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().write_some_at(
|
||||||
|
this->impl_.get_implementation(), offset, buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "write_some_at");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the handle at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the random-access handle. The
|
||||||
|
* function call will block until one or more bytes of the data has been
|
||||||
|
* written successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be written.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the handle.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not write all of the data to the
|
||||||
|
* file. Consider using the @ref write_at function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some_at(uint64_t offset,
|
||||||
|
const ConstBufferSequence& buffers, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().write_some_at(
|
||||||
|
this->impl_.get_implementation(), offset, buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously write data to the random-access
|
||||||
|
* handle. It is an initiating function for an @ref asynchronous_operation,
|
||||||
|
* and always returns immediately.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be written.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the handle.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the write completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes written.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The write operation may not write all of the data to the file.
|
||||||
|
* Consider using the @ref async_write_at function if you need to ensure that
|
||||||
|
* all data is written before the asynchronous operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* handle.async_write_some_at(42, asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* This asynchronous operation supports cancellation for the following
|
||||||
|
* asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some_at(uint64_t offset,
|
||||||
|
const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WriteToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_write_some_at(this), token, offset, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the handle at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the random-access handle. The
|
||||||
|
* function call will block until one or more bytes of data has been read
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be read.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the end of the file was reached.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read_at function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* handle.read_some_at(42, asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some_at(uint64_t offset,
|
||||||
|
const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().read_some_at(
|
||||||
|
this->impl_.get_implementation(), offset, buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "read_some_at");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the handle at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the random-access handle. The
|
||||||
|
* function call will block until one or more bytes of data has been read
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be read.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read_at function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some_at(uint64_t offset,
|
||||||
|
const MutableBufferSequence& buffers, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().read_some_at(
|
||||||
|
this->impl_.get_implementation(), offset, buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read at the specified offset.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously read data from the random-access
|
||||||
|
* handle. It is an initiating function for an @ref asynchronous_operation,
|
||||||
|
* and always returns immediately.
|
||||||
|
*
|
||||||
|
* @param offset The offset at which the data will be read.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the read completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes read.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The read operation may not read all of the requested number of bytes.
|
||||||
|
* Consider using the @ref async_read_at function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the asynchronous operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* handle.async_read_some_at(42, asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* This asynchronous operation supports cancellation for the following
|
||||||
|
* asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some_at(uint64_t offset,
|
||||||
|
const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_read_some_at(this), token, offset, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_random_access_file(const basic_random_access_file&) ASIO_DELETED;
|
||||||
|
basic_random_access_file& operator=(
|
||||||
|
const basic_random_access_file&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_write_some_at
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_write_some_at(basic_random_access_file* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WriteHandler, typename ConstBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
|
||||||
|
uint64_t offset, const ConstBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WriteHandler.
|
||||||
|
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WriteHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_write_some_at(
|
||||||
|
self_->impl_.get_implementation(), offset, buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_random_access_file* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class initiate_async_read_some_at
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_read_some_at(basic_random_access_file* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename ReadHandler, typename MutableBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
|
||||||
|
uint64_t offset, const MutableBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a ReadHandler.
|
||||||
|
ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<ReadHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_read_some_at(
|
||||||
|
self_->impl_.get_implementation(), offset, buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_random_access_file* self_;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_FILE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_RANDOM_ACCESS_FILE_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,529 @@
|
||||||
|
//
|
||||||
|
// basic_readable_pipe.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_READABLE_PIPE_HPP
|
||||||
|
#define ASIO_BASIC_READABLE_PIPE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_PIPE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
# include "asio/detail/win_iocp_handle_service.hpp"
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
# include "asio/detail/io_uring_descriptor_service.hpp"
|
||||||
|
#else
|
||||||
|
# include "asio/detail/reactive_descriptor_service.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Provides pipe functionality.
|
||||||
|
/**
|
||||||
|
* The basic_readable_pipe class provides a wrapper over pipe
|
||||||
|
* functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*/
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_readable_pipe
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the pipe type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The pipe type when rebound to the specified executor.
|
||||||
|
typedef basic_readable_pipe<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a pipe.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IOCP)
|
||||||
|
typedef detail::win_iocp_handle_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
typedef detail::io_uring_descriptor_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef detail::reactive_descriptor_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// A basic_readable_pipe is always the lowest layer.
|
||||||
|
typedef basic_readable_pipe lowest_layer_type;
|
||||||
|
|
||||||
|
/// Construct a basic_readable_pipe without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe without opening it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the pipe will use, by default, to dispatch
|
||||||
|
* handlers for any asynchronous operations performed on the pipe.
|
||||||
|
*/
|
||||||
|
explicit basic_readable_pipe(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_readable_pipe without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe without opening it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the pipe will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the pipe.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_readable_pipe(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_readable_pipe on an existing native pipe.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe object to hold an existing native
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the pipe will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_readable_pipe(const executor_type& ex,
|
||||||
|
const native_handle_type& native_pipe)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_readable_pipe on an existing native pipe.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe object to hold an existing native
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the pipe will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_readable_pipe(ExecutionContext& context,
|
||||||
|
const native_handle_type& native_pipe,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_readable_pipe from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a pipe from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_readable_pipe object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_readable_pipe(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_readable_pipe(basic_readable_pipe&& other)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_readable_pipe from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a pipe from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_readable_pipe object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_readable_pipe(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_readable_pipe& operator=(basic_readable_pipe&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the pipe.
|
||||||
|
/**
|
||||||
|
* This function destroys the pipe, cancelling any outstanding
|
||||||
|
* asynchronous wait operations associated with the pipe as if by
|
||||||
|
* calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_readable_pipe()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_readable_pipe cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A reference to the lowest layer in the stack of layers. Ownership
|
||||||
|
* is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a const reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_readable_pipe cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A const reference to the lowest layer in the stack of layers.
|
||||||
|
* Ownership is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native pipe to the pipe.
|
||||||
|
/*
|
||||||
|
* This function opens the pipe to hold an existing native pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void assign(const native_handle_type& native_pipe)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native pipe to the pipe.
|
||||||
|
/*
|
||||||
|
* This function opens the pipe to hold an existing native pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine whether the pipe is open.
|
||||||
|
bool is_open() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().is_open(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to close the pipe. Any asynchronous read operations
|
||||||
|
* will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "close");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to close the pipe. Any asynchronous read operations
|
||||||
|
* will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the native pipe representation.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the underlying representation of the
|
||||||
|
* pipe. This is intended to allow access to native pipe
|
||||||
|
* functionality that is not otherwise provided.
|
||||||
|
*/
|
||||||
|
native_handle_type native_handle()
|
||||||
|
{
|
||||||
|
return impl_.get_service().native_handle(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the pipe.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read operations to finish
|
||||||
|
* immediately, and the handlers for cancelled operations will be passed the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the pipe.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read operations to finish
|
||||||
|
* immediately, and the handlers for cancelled operations will be passed the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the pipe. The function call will
|
||||||
|
* block until one or more bytes of data has been read successfully, or until
|
||||||
|
* an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_readable_pipe.read_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().read_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "read_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the pipe. The function call will
|
||||||
|
* block until one or more bytes of data has been read successfully, or until
|
||||||
|
* an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().read_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously read data from the pipe. It is an
|
||||||
|
* initiating function for an @ref asynchronous_operation, and always returns
|
||||||
|
* immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the read completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes read.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The read operation may not read all of the requested number of bytes.
|
||||||
|
* Consider using the @ref async_read function if you need to ensure that the
|
||||||
|
* requested amount of data is read before the asynchronous operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_readable_pipe.async_read_some(
|
||||||
|
* asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_read_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_readable_pipe(const basic_readable_pipe&) ASIO_DELETED;
|
||||||
|
basic_readable_pipe& operator=(const basic_readable_pipe&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_read_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_read_some(basic_readable_pipe* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename ReadHandler, typename MutableBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
|
||||||
|
const MutableBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a ReadHandler.
|
||||||
|
ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<ReadHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_read_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_readable_pipe* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
|
||||||
|
#else
|
||||||
|
detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
|
||||||
|
#endif
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_PIPE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_READABLE_PIPE_HPP
|
||||||
|
|
@ -0,0 +1,816 @@
|
||||||
|
//
|
||||||
|
// basic_seq_packet_socket.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
|
||||||
|
#define ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/basic_socket.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Protocol, typename Executor = any_io_executor>
|
||||||
|
class basic_seq_packet_socket;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_SEQ_PACKET_SOCKET_FWD_DECL)
|
||||||
|
|
||||||
|
/// Provides sequenced packet socket functionality.
|
||||||
|
/**
|
||||||
|
* The basic_seq_packet_socket class template provides asynchronous and blocking
|
||||||
|
* sequenced packet socket functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* Synchronous @c send, @c receive, and @c connect operations are thread safe
|
||||||
|
* with respect to each other, if the underlying operating system calls are
|
||||||
|
* also thread safe. This means that it is permitted to perform concurrent
|
||||||
|
* calls to these synchronous operations on a single socket object. Other
|
||||||
|
* synchronous operations, such as @c open or @c close, are not thread safe.
|
||||||
|
*/
|
||||||
|
template <typename Protocol, typename Executor>
|
||||||
|
class basic_seq_packet_socket
|
||||||
|
: public basic_socket<Protocol, Executor>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the socket type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The socket type when rebound to the specified executor.
|
||||||
|
typedef basic_seq_packet_socket<Protocol, Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a socket.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef typename basic_socket<Protocol,
|
||||||
|
Executor>::native_handle_type native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// The protocol type.
|
||||||
|
typedef Protocol protocol_type;
|
||||||
|
|
||||||
|
/// The endpoint type.
|
||||||
|
typedef typename Protocol::endpoint endpoint_type;
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket without opening it. The
|
||||||
|
* socket needs to be opened and then connected or accepted before data can
|
||||||
|
* be sent or received on it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the socket will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the socket.
|
||||||
|
*/
|
||||||
|
explicit basic_seq_packet_socket(const executor_type& ex)
|
||||||
|
: basic_socket<Protocol, Executor>(ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket without opening it. The
|
||||||
|
* socket needs to be opened and then connected or accepted before data can
|
||||||
|
* be sent or received on it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the socket will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the socket.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_seq_packet_socket(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: basic_socket<Protocol, Executor>(context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_seq_packet_socket.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a sequenced_packet socket. The socket
|
||||||
|
* needs to be connected or accepted before data can be sent or received on
|
||||||
|
* it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the socket will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param protocol An object specifying protocol parameters to be used.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_seq_packet_socket(const executor_type& ex,
|
||||||
|
const protocol_type& protocol)
|
||||||
|
: basic_socket<Protocol, Executor>(ex, protocol)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_seq_packet_socket.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a sequenced_packet socket. The socket
|
||||||
|
* needs to be connected or accepted before data can be sent or received on
|
||||||
|
* it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the socket will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param protocol An object specifying protocol parameters to be used.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_seq_packet_socket(ExecutionContext& context,
|
||||||
|
const protocol_type& protocol,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_socket<Protocol, Executor>(context, protocol)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket, opening it and binding it to the
|
||||||
|
/// given local endpoint.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket and automatically opens
|
||||||
|
* it bound to the specified endpoint on the local machine. The protocol used
|
||||||
|
* is the protocol associated with the given endpoint.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the socket will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param endpoint An endpoint on the local machine to which the sequenced
|
||||||
|
* packet socket will be bound.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_seq_packet_socket(const executor_type& ex,
|
||||||
|
const endpoint_type& endpoint)
|
||||||
|
: basic_socket<Protocol, Executor>(ex, endpoint)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket, opening it and binding it to the
|
||||||
|
/// given local endpoint.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket and automatically opens
|
||||||
|
* it bound to the specified endpoint on the local machine. The protocol used
|
||||||
|
* is the protocol associated with the given endpoint.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the socket will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param endpoint An endpoint on the local machine to which the sequenced
|
||||||
|
* packet socket will be bound.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_seq_packet_socket(ExecutionContext& context,
|
||||||
|
const endpoint_type& endpoint,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: basic_socket<Protocol, Executor>(context, endpoint)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket on an existing native socket.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket object to hold an
|
||||||
|
* existing native socket.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the socket will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param protocol An object specifying protocol parameters to be used.
|
||||||
|
*
|
||||||
|
* @param native_socket The new underlying socket implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_seq_packet_socket(const executor_type& ex,
|
||||||
|
const protocol_type& protocol, const native_handle_type& native_socket)
|
||||||
|
: basic_socket<Protocol, Executor>(ex, protocol, native_socket)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_seq_packet_socket on an existing native socket.
|
||||||
|
/**
|
||||||
|
* This constructor creates a sequenced packet socket object to hold an
|
||||||
|
* existing native socket.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the socket will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the socket.
|
||||||
|
*
|
||||||
|
* @param protocol An object specifying protocol parameters to be used.
|
||||||
|
*
|
||||||
|
* @param native_socket The new underlying socket implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_seq_packet_socket(ExecutionContext& context,
|
||||||
|
const protocol_type& protocol, const native_handle_type& native_socket,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: basic_socket<Protocol, Executor>(context, protocol, native_socket)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_seq_packet_socket from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a sequenced packet socket from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_seq_packet_socket object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_seq_packet_socket(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_seq_packet_socket(basic_seq_packet_socket&& other) ASIO_NOEXCEPT
|
||||||
|
: basic_socket<Protocol, Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_seq_packet_socket from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a sequenced packet socket from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_seq_packet_socket object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_seq_packet_socket(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_seq_packet_socket& operator=(basic_seq_packet_socket&& other)
|
||||||
|
{
|
||||||
|
basic_socket<Protocol, Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-construct a basic_seq_packet_socket from a socket of another protocol
|
||||||
|
/// type.
|
||||||
|
/**
|
||||||
|
* This constructor moves a sequenced packet socket from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_seq_packet_socket object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_seq_packet_socket(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Protocol1, typename Executor1>
|
||||||
|
basic_seq_packet_socket(basic_seq_packet_socket<Protocol1, Executor1>&& other,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Protocol1, Protocol>::value
|
||||||
|
&& is_convertible<Executor1, Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
: basic_socket<Protocol, Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_seq_packet_socket from a socket of another protocol
|
||||||
|
/// type.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a sequenced packet socket from one object to
|
||||||
|
* another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_seq_packet_socket object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_seq_packet_socket(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Protocol1, typename Executor1>
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Protocol1, Protocol>::value
|
||||||
|
&& is_convertible<Executor1, Executor>::value,
|
||||||
|
basic_seq_packet_socket&
|
||||||
|
>::type operator=(basic_seq_packet_socket<Protocol1, Executor1>&& other)
|
||||||
|
{
|
||||||
|
basic_socket<Protocol, Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the socket.
|
||||||
|
/**
|
||||||
|
* This function destroys the socket, cancelling any outstanding asynchronous
|
||||||
|
* operations associated with the socket as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_seq_packet_socket()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Send some data on the socket.
|
||||||
|
/**
|
||||||
|
* This function is used to send data on the sequenced packet socket. The
|
||||||
|
* function call will block until the data has been sent successfully, or an
|
||||||
|
* until error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be sent on the socket.
|
||||||
|
*
|
||||||
|
* @param flags Flags specifying how the send call is to be made.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes sent.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To send a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* socket.send(asio::buffer(data, size), 0);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on sending multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t send(const ConstBufferSequence& buffers,
|
||||||
|
socket_base::message_flags flags)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().send(
|
||||||
|
this->impl_.get_implementation(), buffers, flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "send");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Send some data on the socket.
|
||||||
|
/**
|
||||||
|
* This function is used to send data on the sequenced packet socket. The
|
||||||
|
* function call will block the data has been sent successfully, or an until
|
||||||
|
* error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be sent on the socket.
|
||||||
|
*
|
||||||
|
* @param flags Flags specifying how the send call is to be made.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes sent. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The send operation may not transmit all of the data to the peer.
|
||||||
|
* Consider using the @ref write function if you need to ensure that all data
|
||||||
|
* is written before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t send(const ConstBufferSequence& buffers,
|
||||||
|
socket_base::message_flags flags, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().send(
|
||||||
|
this->impl_.get_implementation(), buffers, flags, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous send.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously send data on the sequenced packet
|
||||||
|
* socket. It is an initiating function for an @ref asynchronous_operation,
|
||||||
|
* and always returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be sent on the socket. Although
|
||||||
|
* the buffers object may be copied as necessary, ownership of the underlying
|
||||||
|
* memory blocks is retained by the caller, which must guarantee that they
|
||||||
|
* remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param flags Flags specifying how the send call is to be made.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the send completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes sent.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To send a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* socket.async_send(asio::buffer(data, size), 0, handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on sending multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_send(const ConstBufferSequence& buffers,
|
||||||
|
socket_base::message_flags flags,
|
||||||
|
ASIO_MOVE_ARG(WriteToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WriteToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_send(this), token, buffers, flags);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Receive some data on the socket.
|
||||||
|
/**
|
||||||
|
* This function is used to receive data on the sequenced packet socket. The
|
||||||
|
* function call will block until data has been received successfully, or
|
||||||
|
* until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be received.
|
||||||
|
*
|
||||||
|
* @param out_flags After the receive call completes, contains flags
|
||||||
|
* associated with the received data. For example, if the
|
||||||
|
* socket_base::message_end_of_record bit is set then the received data marks
|
||||||
|
* the end of a record.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes received.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To receive into a single data buffer use the @ref buffer function as
|
||||||
|
* follows:
|
||||||
|
* @code
|
||||||
|
* socket.receive(asio::buffer(data, size), out_flags);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on receiving into
|
||||||
|
* multiple buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t receive(const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags& out_flags)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().receive_with_flags(
|
||||||
|
this->impl_.get_implementation(), buffers, 0, out_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "receive");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Receive some data on the socket.
|
||||||
|
/**
|
||||||
|
* This function is used to receive data on the sequenced packet socket. The
|
||||||
|
* function call will block until data has been received successfully, or
|
||||||
|
* until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be received.
|
||||||
|
*
|
||||||
|
* @param in_flags Flags specifying how the receive call is to be made.
|
||||||
|
*
|
||||||
|
* @param out_flags After the receive call completes, contains flags
|
||||||
|
* associated with the received data. For example, if the
|
||||||
|
* socket_base::message_end_of_record bit is set then the received data marks
|
||||||
|
* the end of a record.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes received.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @note The receive operation may not receive all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that the
|
||||||
|
* requested amount of data is read before the blocking operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To receive into a single data buffer use the @ref buffer function as
|
||||||
|
* follows:
|
||||||
|
* @code
|
||||||
|
* socket.receive(asio::buffer(data, size), 0, out_flags);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on receiving into
|
||||||
|
* multiple buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t receive(const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags in_flags,
|
||||||
|
socket_base::message_flags& out_flags)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().receive_with_flags(
|
||||||
|
this->impl_.get_implementation(), buffers, in_flags, out_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "receive");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Receive some data on a connected socket.
|
||||||
|
/**
|
||||||
|
* This function is used to receive data on the sequenced packet socket. The
|
||||||
|
* function call will block until data has been received successfully, or
|
||||||
|
* until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be received.
|
||||||
|
*
|
||||||
|
* @param in_flags Flags specifying how the receive call is to be made.
|
||||||
|
*
|
||||||
|
* @param out_flags After the receive call completes, contains flags
|
||||||
|
* associated with the received data. For example, if the
|
||||||
|
* socket_base::message_end_of_record bit is set then the received data marks
|
||||||
|
* the end of a record.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes received. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The receive operation may not receive all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that the
|
||||||
|
* requested amount of data is read before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t receive(const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags in_flags,
|
||||||
|
socket_base::message_flags& out_flags, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().receive_with_flags(
|
||||||
|
this->impl_.get_implementation(), buffers, in_flags, out_flags, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous receive.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously receive data from the sequenced
|
||||||
|
* packet socket. It is an initiating function for an @ref
|
||||||
|
* asynchronous_operation, and always returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be received.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param out_flags Once the asynchronous operation completes, contains flags
|
||||||
|
* associated with the received data. For example, if the
|
||||||
|
* socket_base::message_end_of_record bit is set then the received data marks
|
||||||
|
* the end of a record. The caller must guarantee that the referenced
|
||||||
|
* variable remains valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the receive completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes received.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To receive into a single data buffer use the @ref buffer function as
|
||||||
|
* follows:
|
||||||
|
* @code
|
||||||
|
* socket.async_receive(asio::buffer(data, size), out_flags, handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on receiving into
|
||||||
|
* multiple buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_receive(const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags& out_flags,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_receive_with_flags(this), token,
|
||||||
|
buffers, socket_base::message_flags(0), &out_flags);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous receive.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously receive data from the sequenced
|
||||||
|
* data socket. It is an initiating function for an @ref
|
||||||
|
* asynchronous_operation, and always returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be received.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param in_flags Flags specifying how the receive call is to be made.
|
||||||
|
*
|
||||||
|
* @param out_flags Once the asynchronous operation completes, contains flags
|
||||||
|
* associated with the received data. For example, if the
|
||||||
|
* socket_base::message_end_of_record bit is set then the received data marks
|
||||||
|
* the end of a record. The caller must guarantee that the referenced
|
||||||
|
* variable remains valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the receive completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes received.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To receive into a single data buffer use the @ref buffer function as
|
||||||
|
* follows:
|
||||||
|
* @code
|
||||||
|
* socket.async_receive(
|
||||||
|
* asio::buffer(data, size),
|
||||||
|
* 0, out_flags, handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on receiving into
|
||||||
|
* multiple buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_receive(const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags in_flags,
|
||||||
|
socket_base::message_flags& out_flags,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_receive_with_flags(this),
|
||||||
|
token, buffers, in_flags, &out_flags);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_seq_packet_socket(const basic_seq_packet_socket&) ASIO_DELETED;
|
||||||
|
basic_seq_packet_socket& operator=(
|
||||||
|
const basic_seq_packet_socket&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_send
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_send(basic_seq_packet_socket* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WriteHandler, typename ConstBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
|
||||||
|
const ConstBufferSequence& buffers,
|
||||||
|
socket_base::message_flags flags) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WriteHandler.
|
||||||
|
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WriteHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_send(
|
||||||
|
self_->impl_.get_implementation(), buffers, flags,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_seq_packet_socket* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class initiate_async_receive_with_flags
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_receive_with_flags(basic_seq_packet_socket* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename ReadHandler, typename MutableBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
|
||||||
|
const MutableBufferSequence& buffers,
|
||||||
|
socket_base::message_flags in_flags,
|
||||||
|
socket_base::message_flags* out_flags) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a ReadHandler.
|
||||||
|
ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<ReadHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_receive_with_flags(
|
||||||
|
self_->impl_.get_implementation(), buffers, in_flags,
|
||||||
|
*out_flags, handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_seq_packet_socket* self_;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_SEQ_PACKET_SOCKET_HPP
|
||||||
|
|
@ -0,0 +1,939 @@
|
||||||
|
//
|
||||||
|
// basic_serial_port.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
// Copyright (c) 2008 Rep Invariant Systems, Inc. (info@repinvariant.com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_SERIAL_PORT_HPP
|
||||||
|
#define ASIO_BASIC_SERIAL_PORT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_SERIAL_PORT) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/serial_port_base.hpp"
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
# include "asio/detail/win_iocp_serial_port_service.hpp"
|
||||||
|
#else
|
||||||
|
# include "asio/detail/posix_serial_port_service.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Provides serial port functionality.
|
||||||
|
/**
|
||||||
|
* The basic_serial_port class provides a wrapper over serial port
|
||||||
|
* functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*/
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_serial_port
|
||||||
|
: public serial_port_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the serial port type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The serial port type when rebound to the specified executor.
|
||||||
|
typedef basic_serial_port<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a serial port.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IOCP)
|
||||||
|
typedef detail::win_iocp_serial_port_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef detail::posix_serial_port_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// A basic_basic_serial_port is always the lowest layer.
|
||||||
|
typedef basic_serial_port lowest_layer_type;
|
||||||
|
|
||||||
|
/// Construct a basic_serial_port without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a serial port without opening it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the serial port will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* serial port.
|
||||||
|
*/
|
||||||
|
explicit basic_serial_port(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_serial_port without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a serial port without opening it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the serial port will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the serial port.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_serial_port(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_serial_port.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a serial port for the specified device
|
||||||
|
* name.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the serial port will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* serial port.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name for this serial
|
||||||
|
* port.
|
||||||
|
*/
|
||||||
|
basic_serial_port(const executor_type& ex, const char* device)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_serial_port.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a serial port for the specified device
|
||||||
|
* name.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the serial port will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the serial port.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name for this serial
|
||||||
|
* port.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_serial_port(ExecutionContext& context, const char* device,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_serial_port.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a serial port for the specified device
|
||||||
|
* name.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the serial port will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* serial port.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name for this serial
|
||||||
|
* port.
|
||||||
|
*/
|
||||||
|
basic_serial_port(const executor_type& ex, const std::string& device)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_serial_port.
|
||||||
|
/**
|
||||||
|
* This constructor creates and opens a serial port for the specified device
|
||||||
|
* name.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the serial port will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the serial port.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name for this serial
|
||||||
|
* port.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_serial_port(ExecutionContext& context, const std::string& device,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_serial_port on an existing native serial port.
|
||||||
|
/**
|
||||||
|
* This constructor creates a serial port object to hold an existing native
|
||||||
|
* serial port.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the serial port will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* serial port.
|
||||||
|
*
|
||||||
|
* @param native_serial_port A native serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_serial_port(const executor_type& ex,
|
||||||
|
const native_handle_type& native_serial_port)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_serial_port, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_serial_port on an existing native serial port.
|
||||||
|
/**
|
||||||
|
* This constructor creates a serial port object to hold an existing native
|
||||||
|
* serial port.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the serial port will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the serial port.
|
||||||
|
*
|
||||||
|
* @param native_serial_port A native serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_serial_port(ExecutionContext& context,
|
||||||
|
const native_handle_type& native_serial_port,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_serial_port, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_serial_port from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a serial port from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_serial_port object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_serial_port(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_serial_port(basic_serial_port&& other)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_serial_port from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a serial port from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_serial_port object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_serial_port(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_serial_port& operator=(basic_serial_port&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the serial port.
|
||||||
|
/**
|
||||||
|
* This function destroys the serial port, cancelling any outstanding
|
||||||
|
* asynchronous wait operations associated with the serial port as if by
|
||||||
|
* calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_serial_port()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_serial_port cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A reference to the lowest layer in the stack of layers. Ownership
|
||||||
|
* is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a const reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_serial_port cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A const reference to the lowest layer in the stack of layers.
|
||||||
|
* Ownership is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the serial port using the specified device name.
|
||||||
|
/**
|
||||||
|
* This function opens the serial port for the specified device name.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void open(const std::string& device)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Open the serial port using the specified device name.
|
||||||
|
/**
|
||||||
|
* This function opens the serial port using the given platform-specific
|
||||||
|
* device name.
|
||||||
|
*
|
||||||
|
* @param device The platform-specific device name.
|
||||||
|
*
|
||||||
|
* @param ec Set the indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID open(const std::string& device,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().open(impl_.get_implementation(), device, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native serial port to the serial port.
|
||||||
|
/*
|
||||||
|
* This function opens the serial port to hold an existing native serial port.
|
||||||
|
*
|
||||||
|
* @param native_serial_port A native serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void assign(const native_handle_type& native_serial_port)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_serial_port, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native serial port to the serial port.
|
||||||
|
/*
|
||||||
|
* This function opens the serial port to hold an existing native serial port.
|
||||||
|
*
|
||||||
|
* @param native_serial_port A native serial port.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID assign(const native_handle_type& native_serial_port,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_serial_port, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine whether the serial port is open.
|
||||||
|
bool is_open() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().is_open(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to close the serial port. Any asynchronous read or
|
||||||
|
* write operations will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "close");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to close the serial port. Any asynchronous read or
|
||||||
|
* write operations will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the native serial port representation.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the underlying representation of the
|
||||||
|
* serial port. This is intended to allow access to native serial port
|
||||||
|
* functionality that is not otherwise provided.
|
||||||
|
*/
|
||||||
|
native_handle_type native_handle()
|
||||||
|
{
|
||||||
|
return impl_.get_service().native_handle(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the serial port.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read or write operations
|
||||||
|
* to finish immediately, and the handlers for cancelled operations will be
|
||||||
|
* passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the serial port.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous read or write operations
|
||||||
|
* to finish immediately, and the handlers for cancelled operations will be
|
||||||
|
* passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Send a break sequence to the serial port.
|
||||||
|
/**
|
||||||
|
* This function causes a break sequence of platform-specific duration to be
|
||||||
|
* sent out the serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void send_break()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().send_break(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "send_break");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Send a break sequence to the serial port.
|
||||||
|
/**
|
||||||
|
* This function causes a break sequence of platform-specific duration to be
|
||||||
|
* sent out the serial port.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID send_break(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().send_break(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set an option on the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to set an option on the serial port.
|
||||||
|
*
|
||||||
|
* @param option The option value to be set on the serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @sa SettableSerialPortOption @n
|
||||||
|
* asio::serial_port_base::baud_rate @n
|
||||||
|
* asio::serial_port_base::flow_control @n
|
||||||
|
* asio::serial_port_base::parity @n
|
||||||
|
* asio::serial_port_base::stop_bits @n
|
||||||
|
* asio::serial_port_base::character_size
|
||||||
|
*/
|
||||||
|
template <typename SettableSerialPortOption>
|
||||||
|
void set_option(const SettableSerialPortOption& option)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().set_option(impl_.get_implementation(), option, ec);
|
||||||
|
asio::detail::throw_error(ec, "set_option");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set an option on the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to set an option on the serial port.
|
||||||
|
*
|
||||||
|
* @param option The option value to be set on the serial port.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @sa SettableSerialPortOption @n
|
||||||
|
* asio::serial_port_base::baud_rate @n
|
||||||
|
* asio::serial_port_base::flow_control @n
|
||||||
|
* asio::serial_port_base::parity @n
|
||||||
|
* asio::serial_port_base::stop_bits @n
|
||||||
|
* asio::serial_port_base::character_size
|
||||||
|
*/
|
||||||
|
template <typename SettableSerialPortOption>
|
||||||
|
ASIO_SYNC_OP_VOID set_option(const SettableSerialPortOption& option,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().set_option(impl_.get_implementation(), option, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get an option from the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to get the current value of an option on the serial
|
||||||
|
* port.
|
||||||
|
*
|
||||||
|
* @param option The option value to be obtained from the serial port.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @sa GettableSerialPortOption @n
|
||||||
|
* asio::serial_port_base::baud_rate @n
|
||||||
|
* asio::serial_port_base::flow_control @n
|
||||||
|
* asio::serial_port_base::parity @n
|
||||||
|
* asio::serial_port_base::stop_bits @n
|
||||||
|
* asio::serial_port_base::character_size
|
||||||
|
*/
|
||||||
|
template <typename GettableSerialPortOption>
|
||||||
|
void get_option(GettableSerialPortOption& option) const
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().get_option(impl_.get_implementation(), option, ec);
|
||||||
|
asio::detail::throw_error(ec, "get_option");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get an option from the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to get the current value of an option on the serial
|
||||||
|
* port.
|
||||||
|
*
|
||||||
|
* @param option The option value to be obtained from the serial port.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @sa GettableSerialPortOption @n
|
||||||
|
* asio::serial_port_base::baud_rate @n
|
||||||
|
* asio::serial_port_base::flow_control @n
|
||||||
|
* asio::serial_port_base::parity @n
|
||||||
|
* asio::serial_port_base::stop_bits @n
|
||||||
|
* asio::serial_port_base::character_size
|
||||||
|
*/
|
||||||
|
template <typename GettableSerialPortOption>
|
||||||
|
ASIO_SYNC_OP_VOID get_option(GettableSerialPortOption& option,
|
||||||
|
asio::error_code& ec) const
|
||||||
|
{
|
||||||
|
impl_.get_service().get_option(impl_.get_implementation(), option, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the serial port. The function call
|
||||||
|
* will block until one or more bytes of the data has been written
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the serial port.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_serial_port.write_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().write_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "write_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the serial port. The function call
|
||||||
|
* will block until one or more bytes of the data has been written
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the serial port.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().write_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously write data to the serial port.
|
||||||
|
* It is an initiating function for an @ref asynchronous_operation, and always
|
||||||
|
* returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the serial port.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the write completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes written.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The write operation may not transmit all of the data to the peer.
|
||||||
|
* Consider using the @ref async_write function if you need to ensure that all
|
||||||
|
* data is written before the asynchronous operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_serial_port.async_write_some(
|
||||||
|
* asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WriteToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_write_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the serial port. The function
|
||||||
|
* call will block until one or more bytes of data has been read successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_serial_port.read_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().read_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "read_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the serial port.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the serial port. The function
|
||||||
|
* call will block until one or more bytes of data has been read successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().read_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously read data from the serial port.
|
||||||
|
* It is an initiating function for an @ref asynchronous_operation, and always
|
||||||
|
* returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the read completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes read.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The read operation may not read all of the requested number of bytes.
|
||||||
|
* Consider using the @ref async_read function if you need to ensure that the
|
||||||
|
* requested amount of data is read before the asynchronous operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* basic_serial_port.async_read_some(
|
||||||
|
* asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_read_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_serial_port(const basic_serial_port&) ASIO_DELETED;
|
||||||
|
basic_serial_port& operator=(const basic_serial_port&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_write_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_write_some(basic_serial_port* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WriteHandler, typename ConstBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
|
||||||
|
const ConstBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WriteHandler.
|
||||||
|
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WriteHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_write_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_serial_port* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class initiate_async_read_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_read_some(basic_serial_port* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename ReadHandler, typename MutableBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
|
||||||
|
const MutableBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a ReadHandler.
|
||||||
|
ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<ReadHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_read_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_serial_port* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
detail::io_object_impl<detail::win_iocp_serial_port_service, Executor> impl_;
|
||||||
|
#else
|
||||||
|
detail::io_object_impl<detail::posix_serial_port_service, Executor> impl_;
|
||||||
|
#endif
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_SERIAL_PORT)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_SERIAL_PORT_HPP
|
||||||
|
|
@ -0,0 +1,592 @@
|
||||||
|
//
|
||||||
|
// basic_signal_set.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_SIGNAL_SET_HPP
|
||||||
|
#define ASIO_BASIC_SIGNAL_SET_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/signal_set_service.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Provides signal functionality.
|
||||||
|
/**
|
||||||
|
* The basic_signal_set class provides the ability to perform an asynchronous
|
||||||
|
* wait for one or more signals to occur.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* Performing an asynchronous wait:
|
||||||
|
* @code
|
||||||
|
* void handler(
|
||||||
|
* const asio::error_code& error,
|
||||||
|
* int signal_number)
|
||||||
|
* {
|
||||||
|
* if (!error)
|
||||||
|
* {
|
||||||
|
* // A signal occurred.
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* ...
|
||||||
|
*
|
||||||
|
* // Construct a signal set registered for process termination.
|
||||||
|
* asio::signal_set signals(my_context, SIGINT, SIGTERM);
|
||||||
|
*
|
||||||
|
* // Start an asynchronous wait for one of the signals to occur.
|
||||||
|
* signals.async_wait(handler);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Queueing of signal notifications
|
||||||
|
*
|
||||||
|
* If a signal is registered with a signal_set, and the signal occurs when
|
||||||
|
* there are no waiting handlers, then the signal notification is queued. The
|
||||||
|
* next async_wait operation on that signal_set will dequeue the notification.
|
||||||
|
* If multiple notifications are queued, subsequent async_wait operations
|
||||||
|
* dequeue them one at a time. Signal notifications are dequeued in order of
|
||||||
|
* ascending signal number.
|
||||||
|
*
|
||||||
|
* If a signal number is removed from a signal_set (using the @c remove or @c
|
||||||
|
* erase member functions) then any queued notifications for that signal are
|
||||||
|
* discarded.
|
||||||
|
*
|
||||||
|
* @par Multiple registration of signals
|
||||||
|
*
|
||||||
|
* The same signal number may be registered with different signal_set objects.
|
||||||
|
* When the signal occurs, one handler is called for each signal_set object.
|
||||||
|
*
|
||||||
|
* Note that multiple registration only works for signals that are registered
|
||||||
|
* using Asio. The application must not also register a signal handler using
|
||||||
|
* functions such as @c signal() or @c sigaction().
|
||||||
|
*
|
||||||
|
* @par Signal masking on POSIX platforms
|
||||||
|
*
|
||||||
|
* POSIX allows signals to be blocked using functions such as @c sigprocmask()
|
||||||
|
* and @c pthread_sigmask(). For signals to be delivered, programs must ensure
|
||||||
|
* that any signals registered using signal_set objects are unblocked in at
|
||||||
|
* least one thread.
|
||||||
|
*/
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_signal_set
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the signal set type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The signal set type when rebound to the specified executor.
|
||||||
|
typedef basic_signal_set<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Construct a signal set without adding any signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set without registering for any signals.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the signal set will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* signal set.
|
||||||
|
*/
|
||||||
|
explicit basic_signal_set(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set without adding any signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set without registering for any signals.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the signal set will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the signal set.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_signal_set(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add one signal.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for one signal.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the signal set will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(ex);
|
||||||
|
* signals.add(signal_number_1); @endcode
|
||||||
|
*/
|
||||||
|
basic_signal_set(const executor_type& ex, int signal_number_1)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add one signal.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for one signal.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the signal set will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(context);
|
||||||
|
* signals.add(signal_number_1); @endcode
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_signal_set(ExecutionContext& context, int signal_number_1,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add two signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for two signals.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the signal set will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The first signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_2 The second signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(ex);
|
||||||
|
* signals.add(signal_number_1);
|
||||||
|
* signals.add(signal_number_2); @endcode
|
||||||
|
*/
|
||||||
|
basic_signal_set(const executor_type& ex, int signal_number_1,
|
||||||
|
int signal_number_2)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add two signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for two signals.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the signal set will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The first signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_2 The second signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(context);
|
||||||
|
* signals.add(signal_number_1);
|
||||||
|
* signals.add(signal_number_2); @endcode
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_signal_set(ExecutionContext& context, int signal_number_1,
|
||||||
|
int signal_number_2,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add three signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for three signals.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the signal set will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The first signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_2 The second signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_3 The third signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(ex);
|
||||||
|
* signals.add(signal_number_1);
|
||||||
|
* signals.add(signal_number_2);
|
||||||
|
* signals.add(signal_number_3); @endcode
|
||||||
|
*/
|
||||||
|
basic_signal_set(const executor_type& ex, int signal_number_1,
|
||||||
|
int signal_number_2, int signal_number_3)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_3, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a signal set and add three signals.
|
||||||
|
/**
|
||||||
|
* This constructor creates a signal set and registers for three signals.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the signal set will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the signal set.
|
||||||
|
*
|
||||||
|
* @param signal_number_1 The first signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_2 The second signal number to be added.
|
||||||
|
*
|
||||||
|
* @param signal_number_3 The third signal number to be added.
|
||||||
|
*
|
||||||
|
* @note This constructor is equivalent to performing:
|
||||||
|
* @code asio::signal_set signals(context);
|
||||||
|
* signals.add(signal_number_1);
|
||||||
|
* signals.add(signal_number_2);
|
||||||
|
* signals.add(signal_number_3); @endcode
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_signal_set(ExecutionContext& context, int signal_number_1,
|
||||||
|
int signal_number_2, int signal_number_3,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_1, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_2, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number_3, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Destroys the signal set.
|
||||||
|
/**
|
||||||
|
* This function destroys the signal set, cancelling any outstanding
|
||||||
|
* asynchronous wait operations associated with the signal set as if by
|
||||||
|
* calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_signal_set()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Add a signal to a signal_set.
|
||||||
|
/**
|
||||||
|
* This function adds the specified signal to the set. It has no effect if the
|
||||||
|
* signal is already in the set.
|
||||||
|
*
|
||||||
|
* @param signal_number The signal to be added to the set.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void add(int signal_number)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number, ec);
|
||||||
|
asio::detail::throw_error(ec, "add");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Add a signal to a signal_set.
|
||||||
|
/**
|
||||||
|
* This function adds the specified signal to the set. It has no effect if the
|
||||||
|
* signal is already in the set.
|
||||||
|
*
|
||||||
|
* @param signal_number The signal to be added to the set.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID add(int signal_number,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().add(impl_.get_implementation(), signal_number, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove a signal from a signal_set.
|
||||||
|
/**
|
||||||
|
* This function removes the specified signal from the set. It has no effect
|
||||||
|
* if the signal is not in the set.
|
||||||
|
*
|
||||||
|
* @param signal_number The signal to be removed from the set.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note Removes any notifications that have been queued for the specified
|
||||||
|
* signal number.
|
||||||
|
*/
|
||||||
|
void remove(int signal_number)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().remove(impl_.get_implementation(), signal_number, ec);
|
||||||
|
asio::detail::throw_error(ec, "remove");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove a signal from a signal_set.
|
||||||
|
/**
|
||||||
|
* This function removes the specified signal from the set. It has no effect
|
||||||
|
* if the signal is not in the set.
|
||||||
|
*
|
||||||
|
* @param signal_number The signal to be removed from the set.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @note Removes any notifications that have been queued for the specified
|
||||||
|
* signal number.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID remove(int signal_number,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().remove(impl_.get_implementation(), signal_number, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove all signals from a signal_set.
|
||||||
|
/**
|
||||||
|
* This function removes all signals from the set. It has no effect if the set
|
||||||
|
* is already empty.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note Removes all queued notifications.
|
||||||
|
*/
|
||||||
|
void clear()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().clear(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "clear");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove all signals from a signal_set.
|
||||||
|
/**
|
||||||
|
* This function removes all signals from the set. It has no effect if the set
|
||||||
|
* is already empty.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @note Removes all queued notifications.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID clear(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().clear(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all operations associated with the signal set.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the signal set. The handler for each cancelled
|
||||||
|
* operation will be invoked with the asio::error::operation_aborted
|
||||||
|
* error code.
|
||||||
|
*
|
||||||
|
* Cancellation does not alter the set of registered signals.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If a registered signal occurred before cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
void cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all operations associated with the signal set.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the signal set. The handler for each cancelled
|
||||||
|
* operation will be invoked with the asio::error::operation_aborted
|
||||||
|
* error code.
|
||||||
|
*
|
||||||
|
* Cancellation does not alter the set of registered signals.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @note If a registered signal occurred before cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous operation to wait for a signal to be delivered.
|
||||||
|
/**
|
||||||
|
* This function may be used to initiate an asynchronous wait against the
|
||||||
|
* signal set. It is an initiating function for an @ref
|
||||||
|
* asynchronous_operation, and always returns immediately.
|
||||||
|
*
|
||||||
|
* For each call to async_wait(), the completion handler will be called
|
||||||
|
* exactly once. The completion handler will be called when:
|
||||||
|
*
|
||||||
|
* @li One of the registered signals in the signal set occurs; or
|
||||||
|
*
|
||||||
|
* @li The signal set was cancelled, in which case the handler is passed the
|
||||||
|
* error code asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the wait completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* int signal_number // Indicates which signal occurred.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, int) @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* This asynchronous operation supports cancellation for the following
|
||||||
|
* asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, int))
|
||||||
|
SignalToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(SignalToken,
|
||||||
|
void (asio::error_code, int))
|
||||||
|
async_wait(
|
||||||
|
ASIO_MOVE_ARG(SignalToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<SignalToken, void (asio::error_code, int)>(
|
||||||
|
initiate_async_wait(this), token);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_signal_set(const basic_signal_set&) ASIO_DELETED;
|
||||||
|
basic_signal_set& operator=(const basic_signal_set&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_wait
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_wait(basic_signal_set* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename SignalHandler>
|
||||||
|
void operator()(ASIO_MOVE_ARG(SignalHandler) handler) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a SignalHandler.
|
||||||
|
ASIO_SIGNAL_HANDLER_CHECK(SignalHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<SignalHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_wait(
|
||||||
|
self_->impl_.get_implementation(),
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_signal_set* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
detail::io_object_impl<detail::signal_set_service, Executor> impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_SIGNAL_SET_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,407 @@
|
||||||
|
//
|
||||||
|
// basic_socket_iostream.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_SOCKET_IOSTREAM_HPP
|
||||||
|
#define ASIO_BASIC_SOCKET_IOSTREAM_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#include <istream>
|
||||||
|
#include <ostream>
|
||||||
|
#include "asio/basic_socket_streambuf.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
# include "asio/detail/variadic_templates.hpp"
|
||||||
|
|
||||||
|
// A macro that should expand to:
|
||||||
|
// template <typename T1, ..., typename Tn>
|
||||||
|
// explicit basic_socket_iostream(T1 x1, ..., Tn xn)
|
||||||
|
// : std::basic_iostream<char>(
|
||||||
|
// &this->detail::socket_iostream_base<
|
||||||
|
// Protocol, Clock, WaitTraits>::streambuf_)
|
||||||
|
// {
|
||||||
|
// if (rdbuf()->connect(x1, ..., xn) == 0)
|
||||||
|
// this->setstate(std::ios_base::failbit);
|
||||||
|
// }
|
||||||
|
// This macro should only persist within this file.
|
||||||
|
|
||||||
|
# define ASIO_PRIVATE_CTR_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
explicit basic_socket_iostream(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
|
||||||
|
: std::basic_iostream<char>( \
|
||||||
|
&this->detail::socket_iostream_base< \
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_) \
|
||||||
|
{ \
|
||||||
|
this->setf(std::ios_base::unitbuf); \
|
||||||
|
if (rdbuf()->connect(ASIO_VARIADIC_BYVAL_ARGS(n)) == 0) \
|
||||||
|
this->setstate(std::ios_base::failbit); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
|
||||||
|
// A macro that should expand to:
|
||||||
|
// template <typename T1, ..., typename Tn>
|
||||||
|
// void connect(T1 x1, ..., Tn xn)
|
||||||
|
// {
|
||||||
|
// if (rdbuf()->connect(x1, ..., xn) == 0)
|
||||||
|
// this->setstate(std::ios_base::failbit);
|
||||||
|
// }
|
||||||
|
// This macro should only persist within this file.
|
||||||
|
|
||||||
|
# define ASIO_PRIVATE_CONNECT_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void connect(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
if (rdbuf()->connect(ASIO_VARIADIC_BYVAL_ARGS(n)) == 0) \
|
||||||
|
this->setstate(std::ios_base::failbit); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// A separate base class is used to ensure that the streambuf is initialised
|
||||||
|
// prior to the basic_socket_iostream's basic_iostream base class.
|
||||||
|
template <typename Protocol, typename Clock, typename WaitTraits>
|
||||||
|
class socket_iostream_base
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
socket_iostream_base()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
socket_iostream_base(socket_iostream_base&& other)
|
||||||
|
: streambuf_(std::move(other.streambuf_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
socket_iostream_base(basic_stream_socket<Protocol> s)
|
||||||
|
: streambuf_(std::move(s))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
socket_iostream_base& operator=(socket_iostream_base&& other)
|
||||||
|
{
|
||||||
|
streambuf_ = std::move(other.streambuf_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
basic_socket_streambuf<Protocol, Clock, WaitTraits> streambuf_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Protocol,
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typename Clock = boost::posix_time::ptime,
|
||||||
|
typename WaitTraits = time_traits<Clock> >
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typename Clock = chrono::steady_clock,
|
||||||
|
typename WaitTraits = wait_traits<Clock> >
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
class basic_socket_iostream;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_SOCKET_IOSTREAM_FWD_DECL)
|
||||||
|
|
||||||
|
/// Iostream interface for a socket.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Protocol,
|
||||||
|
typename Clock = chrono::steady_clock,
|
||||||
|
typename WaitTraits = wait_traits<Clock> >
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Protocol, typename Clock, typename WaitTraits>
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
class basic_socket_iostream
|
||||||
|
: private detail::socket_iostream_base<Protocol, Clock, WaitTraits>,
|
||||||
|
public std::basic_iostream<char>
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
// These typedefs are intended keep this class's implementation independent
|
||||||
|
// of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typedef WaitTraits traits_helper;
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
|
||||||
|
public:
|
||||||
|
/// The protocol type.
|
||||||
|
typedef Protocol protocol_type;
|
||||||
|
|
||||||
|
/// The endpoint type.
|
||||||
|
typedef typename Protocol::endpoint endpoint_type;
|
||||||
|
|
||||||
|
/// The clock type.
|
||||||
|
typedef Clock clock_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// (Deprecated: Use time_point.) The time type.
|
||||||
|
typedef typename WaitTraits::time_type time_type;
|
||||||
|
|
||||||
|
/// The time type.
|
||||||
|
typedef typename WaitTraits::time_point time_point;
|
||||||
|
|
||||||
|
/// (Deprecated: Use duration.) The duration type.
|
||||||
|
typedef typename WaitTraits::duration_type duration_type;
|
||||||
|
|
||||||
|
/// The duration type.
|
||||||
|
typedef typename WaitTraits::duration duration;
|
||||||
|
#else
|
||||||
|
# if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
typedef typename traits_helper::time_type time_type;
|
||||||
|
typedef typename traits_helper::duration_type duration_type;
|
||||||
|
# endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
typedef typename traits_helper::time_type time_point;
|
||||||
|
typedef typename traits_helper::duration_type duration;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_socket_iostream without establishing a connection.
|
||||||
|
basic_socket_iostream()
|
||||||
|
: std::basic_iostream<char>(
|
||||||
|
&this->detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_)
|
||||||
|
{
|
||||||
|
this->setf(std::ios_base::unitbuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Construct a basic_socket_iostream from the supplied socket.
|
||||||
|
explicit basic_socket_iostream(basic_stream_socket<protocol_type> s)
|
||||||
|
: detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>(std::move(s)),
|
||||||
|
std::basic_iostream<char>(
|
||||||
|
&this->detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_)
|
||||||
|
{
|
||||||
|
this->setf(std::ios_base::unitbuf);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_IOSTREAM_MOVE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_socket_iostream from another.
|
||||||
|
basic_socket_iostream(basic_socket_iostream&& other)
|
||||||
|
: detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>(std::move(other)),
|
||||||
|
std::basic_iostream<char>(std::move(other))
|
||||||
|
{
|
||||||
|
this->set_rdbuf(&this->detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_socket_iostream from another.
|
||||||
|
basic_socket_iostream& operator=(basic_socket_iostream&& other)
|
||||||
|
{
|
||||||
|
std::basic_iostream<char>::operator=(std::move(other));
|
||||||
|
detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_STD_IOSTREAM_MOVE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Establish a connection to an endpoint corresponding to a resolver query.
|
||||||
|
/**
|
||||||
|
* This constructor automatically establishes a connection based on the
|
||||||
|
* supplied resolver query parameters. The arguments are used to construct
|
||||||
|
* a resolver query object.
|
||||||
|
*/
|
||||||
|
template <typename T1, ..., typename TN>
|
||||||
|
explicit basic_socket_iostream(T1 t1, ..., TN tn);
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
template <typename... T>
|
||||||
|
explicit basic_socket_iostream(T... x)
|
||||||
|
: std::basic_iostream<char>(
|
||||||
|
&this->detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_)
|
||||||
|
{
|
||||||
|
this->setf(std::ios_base::unitbuf);
|
||||||
|
if (rdbuf()->connect(x...) == 0)
|
||||||
|
this->setstate(std::ios_base::failbit);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CTR_DEF)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Establish a connection to an endpoint corresponding to a resolver query.
|
||||||
|
/**
|
||||||
|
* This function automatically establishes a connection based on the supplied
|
||||||
|
* resolver query parameters. The arguments are used to construct a resolver
|
||||||
|
* query object.
|
||||||
|
*/
|
||||||
|
template <typename T1, ..., typename TN>
|
||||||
|
void connect(T1 t1, ..., TN tn);
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
template <typename... T>
|
||||||
|
void connect(T... x)
|
||||||
|
{
|
||||||
|
if (rdbuf()->connect(x...) == 0)
|
||||||
|
this->setstate(std::ios_base::failbit);
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CONNECT_DEF)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Close the connection.
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
if (rdbuf()->close() == 0)
|
||||||
|
this->setstate(std::ios_base::failbit);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Return a pointer to the underlying streambuf.
|
||||||
|
basic_socket_streambuf<Protocol, Clock, WaitTraits>* rdbuf() const
|
||||||
|
{
|
||||||
|
return const_cast<basic_socket_streambuf<Protocol, Clock, WaitTraits>*>(
|
||||||
|
&this->detail::socket_iostream_base<
|
||||||
|
Protocol, Clock, WaitTraits>::streambuf_);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the underlying socket.
|
||||||
|
basic_socket<Protocol>& socket()
|
||||||
|
{
|
||||||
|
return rdbuf()->socket();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the last error associated with the stream.
|
||||||
|
/**
|
||||||
|
* @return An \c error_code corresponding to the last error from the stream.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To print the error associated with a failure to establish a connection:
|
||||||
|
* @code tcp::iostream s("www.boost.org", "http");
|
||||||
|
* if (!s)
|
||||||
|
* {
|
||||||
|
* std::cout << "Error: " << s.error().message() << std::endl;
|
||||||
|
* } @endcode
|
||||||
|
*/
|
||||||
|
const asio::error_code& error() const
|
||||||
|
{
|
||||||
|
return rdbuf()->error();
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use expiry().) Get the stream's expiry time as an absolute
|
||||||
|
/// time.
|
||||||
|
/**
|
||||||
|
* @return An absolute time value representing the stream's expiry time.
|
||||||
|
*/
|
||||||
|
time_point expires_at() const
|
||||||
|
{
|
||||||
|
return rdbuf()->expires_at();
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Get the stream's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* @return An absolute time value representing the stream's expiry time.
|
||||||
|
*/
|
||||||
|
time_point expiry() const
|
||||||
|
{
|
||||||
|
return rdbuf()->expiry();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the stream's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the stream.
|
||||||
|
*/
|
||||||
|
void expires_at(const time_point& expiry_time)
|
||||||
|
{
|
||||||
|
rdbuf()->expires_at(expiry_time);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the stream's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*/
|
||||||
|
void expires_after(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
rdbuf()->expires_after(expiry_time);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use expiry().) Get the stream's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* @return A relative time value representing the stream's expiry time.
|
||||||
|
*/
|
||||||
|
duration expires_from_now() const
|
||||||
|
{
|
||||||
|
return rdbuf()->expires_from_now();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expires_after().) Set the stream's expiry time relative
|
||||||
|
/// to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*/
|
||||||
|
void expires_from_now(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
rdbuf()->expires_from_now(expiry_time);
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_socket_iostream(const basic_socket_iostream&) ASIO_DELETED;
|
||||||
|
basic_socket_iostream& operator=(
|
||||||
|
const basic_socket_iostream&) ASIO_DELETED;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
# undef ASIO_PRIVATE_CTR_DEF
|
||||||
|
# undef ASIO_PRIVATE_CONNECT_DEF
|
||||||
|
#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_SOCKET_IOSTREAM_HPP
|
||||||
|
|
@ -0,0 +1,687 @@
|
||||||
|
//
|
||||||
|
// basic_socket_streambuf.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_SOCKET_STREAMBUF_HPP
|
||||||
|
#define ASIO_BASIC_SOCKET_STREAMBUF_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#include <streambuf>
|
||||||
|
#include <vector>
|
||||||
|
#include "asio/basic_socket.hpp"
|
||||||
|
#include "asio/basic_stream_socket.hpp"
|
||||||
|
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/io_context.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
# include "asio/detail/deadline_timer_service.hpp"
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
# include "asio/steady_timer.hpp"
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
# include "asio/detail/variadic_templates.hpp"
|
||||||
|
|
||||||
|
// A macro that should expand to:
|
||||||
|
// template <typename T1, ..., typename Tn>
|
||||||
|
// basic_socket_streambuf* connect(T1 x1, ..., Tn xn)
|
||||||
|
// {
|
||||||
|
// init_buffers();
|
||||||
|
// typedef typename Protocol::resolver resolver_type;
|
||||||
|
// resolver_type resolver(socket().get_executor());
|
||||||
|
// connect_to_endpoints(
|
||||||
|
// resolver.resolve(x1, ..., xn, ec_));
|
||||||
|
// return !ec_ ? this : 0;
|
||||||
|
// }
|
||||||
|
// This macro should only persist within this file.
|
||||||
|
|
||||||
|
# define ASIO_PRIVATE_CONNECT_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
basic_socket_streambuf* connect(ASIO_VARIADIC_BYVAL_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
init_buffers(); \
|
||||||
|
typedef typename Protocol::resolver resolver_type; \
|
||||||
|
resolver_type resolver(socket().get_executor()); \
|
||||||
|
connect_to_endpoints( \
|
||||||
|
resolver.resolve(ASIO_VARIADIC_BYVAL_ARGS(n), ec_)); \
|
||||||
|
return !ec_ ? this : 0; \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// A separate base class is used to ensure that the io_context member is
|
||||||
|
// initialised prior to the basic_socket_streambuf's basic_socket base class.
|
||||||
|
class socket_streambuf_io_context
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
socket_streambuf_io_context(io_context* ctx)
|
||||||
|
: default_io_context_(ctx)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
shared_ptr<io_context> default_io_context_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// A separate base class is used to ensure that the dynamically allocated
|
||||||
|
// buffers are constructed prior to the basic_socket_streambuf's basic_socket
|
||||||
|
// base class. This makes moving the socket is the last potentially throwing
|
||||||
|
// step in the streambuf's move constructor, giving the constructor a strong
|
||||||
|
// exception safety guarantee.
|
||||||
|
class socket_streambuf_buffers
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
socket_streambuf_buffers()
|
||||||
|
: get_buffer_(buffer_size),
|
||||||
|
put_buffer_(buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { buffer_size = 512 };
|
||||||
|
std::vector<char> get_buffer_;
|
||||||
|
std::vector<char> put_buffer_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Protocol,
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typename Clock = boost::posix_time::ptime,
|
||||||
|
typename WaitTraits = time_traits<Clock> >
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typename Clock = chrono::steady_clock,
|
||||||
|
typename WaitTraits = wait_traits<Clock> >
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
class basic_socket_streambuf;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_SOCKET_STREAMBUF_FWD_DECL)
|
||||||
|
|
||||||
|
/// Iostream streambuf for a socket.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Protocol,
|
||||||
|
typename Clock = chrono::steady_clock,
|
||||||
|
typename WaitTraits = wait_traits<Clock> >
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Protocol, typename Clock, typename WaitTraits>
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
class basic_socket_streambuf
|
||||||
|
: public std::streambuf,
|
||||||
|
private detail::socket_streambuf_io_context,
|
||||||
|
private detail::socket_streambuf_buffers,
|
||||||
|
#if defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
private basic_socket<Protocol>
|
||||||
|
#else // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
public basic_socket<Protocol>
|
||||||
|
#endif // defined(ASIO_NO_DEPRECATED) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
// These typedefs are intended keep this class's implementation independent
|
||||||
|
// of whether it's using Boost.DateClock, Boost.Chrono or std::chrono.
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typedef WaitTraits traits_helper;
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
typedef detail::chrono_time_traits<Clock, WaitTraits> traits_helper;
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
|
||||||
|
public:
|
||||||
|
/// The protocol type.
|
||||||
|
typedef Protocol protocol_type;
|
||||||
|
|
||||||
|
/// The endpoint type.
|
||||||
|
typedef typename Protocol::endpoint endpoint_type;
|
||||||
|
|
||||||
|
/// The clock type.
|
||||||
|
typedef Clock clock_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// (Deprecated: Use time_point.) The time type.
|
||||||
|
typedef typename WaitTraits::time_type time_type;
|
||||||
|
|
||||||
|
/// The time type.
|
||||||
|
typedef typename WaitTraits::time_point time_point;
|
||||||
|
|
||||||
|
/// (Deprecated: Use duration.) The duration type.
|
||||||
|
typedef typename WaitTraits::duration_type duration_type;
|
||||||
|
|
||||||
|
/// The duration type.
|
||||||
|
typedef typename WaitTraits::duration duration;
|
||||||
|
#else
|
||||||
|
# if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
typedef typename traits_helper::time_type time_type;
|
||||||
|
typedef typename traits_helper::duration_type duration_type;
|
||||||
|
# endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
typedef typename traits_helper::time_type time_point;
|
||||||
|
typedef typename traits_helper::duration_type duration;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_socket_streambuf without establishing a connection.
|
||||||
|
basic_socket_streambuf()
|
||||||
|
: detail::socket_streambuf_io_context(new io_context),
|
||||||
|
basic_socket<Protocol>(*default_io_context_),
|
||||||
|
expiry_time_(max_expiry_time())
|
||||||
|
{
|
||||||
|
init_buffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Construct a basic_socket_streambuf from the supplied socket.
|
||||||
|
explicit basic_socket_streambuf(basic_stream_socket<protocol_type> s)
|
||||||
|
: detail::socket_streambuf_io_context(0),
|
||||||
|
basic_socket<Protocol>(std::move(s)),
|
||||||
|
expiry_time_(max_expiry_time())
|
||||||
|
{
|
||||||
|
init_buffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-construct a basic_socket_streambuf from another.
|
||||||
|
basic_socket_streambuf(basic_socket_streambuf&& other)
|
||||||
|
: detail::socket_streambuf_io_context(other),
|
||||||
|
basic_socket<Protocol>(std::move(other.socket())),
|
||||||
|
ec_(other.ec_),
|
||||||
|
expiry_time_(other.expiry_time_)
|
||||||
|
{
|
||||||
|
get_buffer_.swap(other.get_buffer_);
|
||||||
|
put_buffer_.swap(other.put_buffer_);
|
||||||
|
setg(other.eback(), other.gptr(), other.egptr());
|
||||||
|
setp(other.pptr(), other.epptr());
|
||||||
|
other.ec_ = asio::error_code();
|
||||||
|
other.expiry_time_ = max_expiry_time();
|
||||||
|
other.init_buffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_socket_streambuf from another.
|
||||||
|
basic_socket_streambuf& operator=(basic_socket_streambuf&& other)
|
||||||
|
{
|
||||||
|
this->close();
|
||||||
|
socket() = std::move(other.socket());
|
||||||
|
detail::socket_streambuf_io_context::operator=(other);
|
||||||
|
ec_ = other.ec_;
|
||||||
|
expiry_time_ = other.expiry_time_;
|
||||||
|
get_buffer_.swap(other.get_buffer_);
|
||||||
|
put_buffer_.swap(other.put_buffer_);
|
||||||
|
setg(other.eback(), other.gptr(), other.egptr());
|
||||||
|
setp(other.pptr(), other.epptr());
|
||||||
|
other.ec_ = asio::error_code();
|
||||||
|
other.expiry_time_ = max_expiry_time();
|
||||||
|
other.put_buffer_.resize(buffer_size);
|
||||||
|
other.init_buffers();
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destructor flushes buffered data.
|
||||||
|
virtual ~basic_socket_streambuf()
|
||||||
|
{
|
||||||
|
if (pptr() != pbase())
|
||||||
|
overflow(traits_type::eof());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Establish a connection.
|
||||||
|
/**
|
||||||
|
* This function establishes a connection to the specified endpoint.
|
||||||
|
*
|
||||||
|
* @return \c this if a connection was successfully established, a null
|
||||||
|
* pointer otherwise.
|
||||||
|
*/
|
||||||
|
basic_socket_streambuf* connect(const endpoint_type& endpoint)
|
||||||
|
{
|
||||||
|
init_buffers();
|
||||||
|
ec_ = asio::error_code();
|
||||||
|
this->connect_to_endpoints(&endpoint, &endpoint + 1);
|
||||||
|
return !ec_ ? this : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Establish a connection.
|
||||||
|
/**
|
||||||
|
* This function automatically establishes a connection based on the supplied
|
||||||
|
* resolver query parameters. The arguments are used to construct a resolver
|
||||||
|
* query object.
|
||||||
|
*
|
||||||
|
* @return \c this if a connection was successfully established, a null
|
||||||
|
* pointer otherwise.
|
||||||
|
*/
|
||||||
|
template <typename T1, ..., typename TN>
|
||||||
|
basic_socket_streambuf* connect(T1 t1, ..., TN tn);
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
template <typename... T>
|
||||||
|
basic_socket_streambuf* connect(T... x)
|
||||||
|
{
|
||||||
|
init_buffers();
|
||||||
|
typedef typename Protocol::resolver resolver_type;
|
||||||
|
resolver_type resolver(socket().get_executor());
|
||||||
|
connect_to_endpoints(resolver.resolve(x..., ec_));
|
||||||
|
return !ec_ ? this : 0;
|
||||||
|
}
|
||||||
|
#else
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_CONNECT_DEF)
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Close the connection.
|
||||||
|
/**
|
||||||
|
* @return \c this if a connection was successfully established, a null
|
||||||
|
* pointer otherwise.
|
||||||
|
*/
|
||||||
|
basic_socket_streambuf* close()
|
||||||
|
{
|
||||||
|
sync();
|
||||||
|
socket().close(ec_);
|
||||||
|
if (!ec_)
|
||||||
|
init_buffers();
|
||||||
|
return !ec_ ? this : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the underlying socket.
|
||||||
|
basic_socket<Protocol>& socket()
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the last error associated with the stream buffer.
|
||||||
|
/**
|
||||||
|
* @return An \c error_code corresponding to the last error from the stream
|
||||||
|
* buffer.
|
||||||
|
*/
|
||||||
|
const asio::error_code& error() const
|
||||||
|
{
|
||||||
|
return ec_;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use error().) Get the last error associated with the stream
|
||||||
|
/// buffer.
|
||||||
|
/**
|
||||||
|
* @return An \c error_code corresponding to the last error from the stream
|
||||||
|
* buffer.
|
||||||
|
*/
|
||||||
|
const asio::error_code& puberror() const
|
||||||
|
{
|
||||||
|
return error();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expiry().) Get the stream buffer's expiry time as an
|
||||||
|
/// absolute time.
|
||||||
|
/**
|
||||||
|
* @return An absolute time value representing the stream buffer's expiry
|
||||||
|
* time.
|
||||||
|
*/
|
||||||
|
time_point expires_at() const
|
||||||
|
{
|
||||||
|
return expiry_time_;
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Get the stream buffer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* @return An absolute time value representing the stream buffer's expiry
|
||||||
|
* time.
|
||||||
|
*/
|
||||||
|
time_point expiry() const
|
||||||
|
{
|
||||||
|
return expiry_time_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the stream buffer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the stream.
|
||||||
|
*/
|
||||||
|
void expires_at(const time_point& expiry_time)
|
||||||
|
{
|
||||||
|
expiry_time_ = expiry_time;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the stream buffer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*/
|
||||||
|
void expires_after(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use expiry().) Get the stream buffer's expiry time relative
|
||||||
|
/// to now.
|
||||||
|
/**
|
||||||
|
* @return A relative time value representing the stream buffer's expiry time.
|
||||||
|
*/
|
||||||
|
duration expires_from_now() const
|
||||||
|
{
|
||||||
|
return traits_helper::subtract(expires_at(), traits_helper::now());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expires_after().) Set the stream buffer's expiry time
|
||||||
|
/// relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time associated with the stream. Stream
|
||||||
|
* operations performed after this time (where the operations cannot be
|
||||||
|
* completed using the internal buffers) will fail with the error
|
||||||
|
* asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*/
|
||||||
|
void expires_from_now(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
expiry_time_ = traits_helper::add(traits_helper::now(), expiry_time);
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
protected:
|
||||||
|
int_type underflow()
|
||||||
|
{
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
ec_ = asio::error::operation_not_supported;
|
||||||
|
return traits_type::eof();
|
||||||
|
#else // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
if (gptr() != egptr())
|
||||||
|
return traits_type::eof();
|
||||||
|
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
// Check if we are past the expiry time.
|
||||||
|
if (traits_helper::less_than(expiry_time_, traits_helper::now()))
|
||||||
|
{
|
||||||
|
ec_ = asio::error::timed_out;
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Try to complete the operation without blocking.
|
||||||
|
if (!socket().native_non_blocking())
|
||||||
|
socket().native_non_blocking(true, ec_);
|
||||||
|
detail::buffer_sequence_adapter<mutable_buffer, mutable_buffer>
|
||||||
|
bufs(asio::buffer(get_buffer_) + putback_max);
|
||||||
|
detail::signed_size_type bytes = detail::socket_ops::recv(
|
||||||
|
socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
|
||||||
|
|
||||||
|
// Check if operation succeeded.
|
||||||
|
if (bytes > 0)
|
||||||
|
{
|
||||||
|
setg(&get_buffer_[0], &get_buffer_[0] + putback_max,
|
||||||
|
&get_buffer_[0] + putback_max + bytes);
|
||||||
|
return traits_type::to_int_type(*gptr());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check for EOF.
|
||||||
|
if (bytes == 0)
|
||||||
|
{
|
||||||
|
ec_ = asio::error::eof;
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Operation failed.
|
||||||
|
if (ec_ != asio::error::would_block
|
||||||
|
&& ec_ != asio::error::try_again)
|
||||||
|
return traits_type::eof();
|
||||||
|
|
||||||
|
// Wait for socket to become ready.
|
||||||
|
if (detail::socket_ops::poll_read(
|
||||||
|
socket().native_handle(), 0, timeout(), ec_) < 0)
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
}
|
||||||
|
|
||||||
|
int_type overflow(int_type c)
|
||||||
|
{
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
ec_ = asio::error::operation_not_supported;
|
||||||
|
return traits_type::eof();
|
||||||
|
#else // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
char_type ch = traits_type::to_char_type(c);
|
||||||
|
|
||||||
|
// Determine what needs to be sent.
|
||||||
|
const_buffer output_buffer;
|
||||||
|
if (put_buffer_.empty())
|
||||||
|
{
|
||||||
|
if (traits_type::eq_int_type(c, traits_type::eof()))
|
||||||
|
return traits_type::not_eof(c); // Nothing to do.
|
||||||
|
output_buffer = asio::buffer(&ch, sizeof(char_type));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
output_buffer = asio::buffer(pbase(),
|
||||||
|
(pptr() - pbase()) * sizeof(char_type));
|
||||||
|
}
|
||||||
|
|
||||||
|
while (output_buffer.size() > 0)
|
||||||
|
{
|
||||||
|
// Check if we are past the expiry time.
|
||||||
|
if (traits_helper::less_than(expiry_time_, traits_helper::now()))
|
||||||
|
{
|
||||||
|
ec_ = asio::error::timed_out;
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Try to complete the operation without blocking.
|
||||||
|
if (!socket().native_non_blocking())
|
||||||
|
socket().native_non_blocking(true, ec_);
|
||||||
|
detail::buffer_sequence_adapter<
|
||||||
|
const_buffer, const_buffer> bufs(output_buffer);
|
||||||
|
detail::signed_size_type bytes = detail::socket_ops::send(
|
||||||
|
socket().native_handle(), bufs.buffers(), bufs.count(), 0, ec_);
|
||||||
|
|
||||||
|
// Check if operation succeeded.
|
||||||
|
if (bytes > 0)
|
||||||
|
{
|
||||||
|
output_buffer += static_cast<std::size_t>(bytes);
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Operation failed.
|
||||||
|
if (ec_ != asio::error::would_block
|
||||||
|
&& ec_ != asio::error::try_again)
|
||||||
|
return traits_type::eof();
|
||||||
|
|
||||||
|
// Wait for socket to become ready.
|
||||||
|
if (detail::socket_ops::poll_write(
|
||||||
|
socket().native_handle(), 0, timeout(), ec_) < 0)
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
|
||||||
|
if (!put_buffer_.empty())
|
||||||
|
{
|
||||||
|
setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
|
||||||
|
|
||||||
|
// If the new character is eof then our work here is done.
|
||||||
|
if (traits_type::eq_int_type(c, traits_type::eof()))
|
||||||
|
return traits_type::not_eof(c);
|
||||||
|
|
||||||
|
// Add the new character to the output buffer.
|
||||||
|
*pptr() = ch;
|
||||||
|
pbump(1);
|
||||||
|
}
|
||||||
|
|
||||||
|
return c;
|
||||||
|
#endif // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
}
|
||||||
|
|
||||||
|
int sync()
|
||||||
|
{
|
||||||
|
return overflow(traits_type::eof());
|
||||||
|
}
|
||||||
|
|
||||||
|
std::streambuf* setbuf(char_type* s, std::streamsize n)
|
||||||
|
{
|
||||||
|
if (pptr() == pbase() && s == 0 && n == 0)
|
||||||
|
{
|
||||||
|
put_buffer_.clear();
|
||||||
|
setp(0, 0);
|
||||||
|
sync();
|
||||||
|
return this;
|
||||||
|
}
|
||||||
|
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_socket_streambuf(const basic_socket_streambuf&) ASIO_DELETED;
|
||||||
|
basic_socket_streambuf& operator=(
|
||||||
|
const basic_socket_streambuf&) ASIO_DELETED;
|
||||||
|
|
||||||
|
void init_buffers()
|
||||||
|
{
|
||||||
|
setg(&get_buffer_[0],
|
||||||
|
&get_buffer_[0] + putback_max,
|
||||||
|
&get_buffer_[0] + putback_max);
|
||||||
|
|
||||||
|
if (put_buffer_.empty())
|
||||||
|
setp(0, 0);
|
||||||
|
else
|
||||||
|
setp(&put_buffer_[0], &put_buffer_[0] + put_buffer_.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
int timeout() const
|
||||||
|
{
|
||||||
|
int64_t msec = traits_helper::to_posix_duration(
|
||||||
|
traits_helper::subtract(expiry_time_,
|
||||||
|
traits_helper::now())).total_milliseconds();
|
||||||
|
if (msec > (std::numeric_limits<int>::max)())
|
||||||
|
msec = (std::numeric_limits<int>::max)();
|
||||||
|
else if (msec < 0)
|
||||||
|
msec = 0;
|
||||||
|
return static_cast<int>(msec);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename EndpointSequence>
|
||||||
|
void connect_to_endpoints(const EndpointSequence& endpoints)
|
||||||
|
{
|
||||||
|
this->connect_to_endpoints(endpoints.begin(), endpoints.end());
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename EndpointIterator>
|
||||||
|
void connect_to_endpoints(EndpointIterator begin, EndpointIterator end)
|
||||||
|
{
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
ec_ = asio::error::operation_not_supported;
|
||||||
|
#else // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
if (ec_)
|
||||||
|
return;
|
||||||
|
|
||||||
|
ec_ = asio::error::not_found;
|
||||||
|
for (EndpointIterator i = begin; i != end; ++i)
|
||||||
|
{
|
||||||
|
// Check if we are past the expiry time.
|
||||||
|
if (traits_helper::less_than(expiry_time_, traits_helper::now()))
|
||||||
|
{
|
||||||
|
ec_ = asio::error::timed_out;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close and reopen the socket.
|
||||||
|
typename Protocol::endpoint ep(*i);
|
||||||
|
socket().close(ec_);
|
||||||
|
socket().open(ep.protocol(), ec_);
|
||||||
|
if (ec_)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// Try to complete the operation without blocking.
|
||||||
|
if (!socket().native_non_blocking())
|
||||||
|
socket().native_non_blocking(true, ec_);
|
||||||
|
detail::socket_ops::connect(socket().native_handle(),
|
||||||
|
ep.data(), ep.size(), ec_);
|
||||||
|
|
||||||
|
// Check if operation succeeded.
|
||||||
|
if (!ec_)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Operation failed.
|
||||||
|
if (ec_ != asio::error::in_progress
|
||||||
|
&& ec_ != asio::error::would_block)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// Wait for socket to become ready.
|
||||||
|
if (detail::socket_ops::poll_connect(
|
||||||
|
socket().native_handle(), timeout(), ec_) < 0)
|
||||||
|
continue;
|
||||||
|
|
||||||
|
// Get the error code from the connect operation.
|
||||||
|
int connect_error = 0;
|
||||||
|
size_t connect_error_len = sizeof(connect_error);
|
||||||
|
if (detail::socket_ops::getsockopt(socket().native_handle(), 0,
|
||||||
|
SOL_SOCKET, SO_ERROR, &connect_error, &connect_error_len, ec_)
|
||||||
|
== detail::socket_error_retval)
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Check the result of the connect operation.
|
||||||
|
ec_ = asio::error_code(connect_error,
|
||||||
|
asio::error::get_system_category());
|
||||||
|
if (!ec_)
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper function to get the maximum expiry time.
|
||||||
|
static time_point max_expiry_time()
|
||||||
|
{
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
&& defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
return boost::posix_time::pos_infin;
|
||||||
|
#else // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
return (time_point::max)();
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// && defined(ASIO_USE_BOOST_DATE_TIME_FOR_SOCKET_IOSTREAM)
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { putback_max = 8 };
|
||||||
|
asio::error_code ec_;
|
||||||
|
time_point expiry_time_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
# undef ASIO_PRIVATE_CONNECT_DEF
|
||||||
|
#endif // !defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_SOCKET_STREAMBUF_HPP
|
||||||
|
|
@ -0,0 +1,742 @@
|
||||||
|
//
|
||||||
|
// basic_stream_file.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_STREAM_FILE_HPP
|
||||||
|
#define ASIO_BASIC_STREAM_FILE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_FILE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/basic_file.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_STREAM_FILE_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_STREAM_FILE_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_stream_file;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_STREAM_FILE_FWD_DECL)
|
||||||
|
|
||||||
|
/// Provides stream-oriented file functionality.
|
||||||
|
/**
|
||||||
|
* The basic_stream_file class template provides asynchronous and blocking
|
||||||
|
* stream-oriented file functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Concepts:
|
||||||
|
* AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
|
||||||
|
*/
|
||||||
|
template <typename Executor>
|
||||||
|
class basic_stream_file
|
||||||
|
: public basic_file<Executor>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the file type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The file type when rebound to the specified executor.
|
||||||
|
typedef basic_stream_file<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a file.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef typename basic_file<Executor>::native_handle_type native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_stream_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it. The file needs to
|
||||||
|
* be opened before data can be read from or or written to it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*/
|
||||||
|
explicit basic_stream_file(const executor_type& ex)
|
||||||
|
: basic_file<Executor>(ex)
|
||||||
|
{
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_stream_file without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a file without opening it. The file needs to
|
||||||
|
* be opened before data can be read from or or written to it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_stream_file(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context)
|
||||||
|
{
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_stream_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_stream_file(const executor_type& ex,
|
||||||
|
const char* path, file_base::flags open_flags)
|
||||||
|
: basic_file<Executor>(ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
this->impl_.get_service().open(
|
||||||
|
this->impl_.get_implementation(),
|
||||||
|
path, open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_stream_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_stream_file(ExecutionContext& context,
|
||||||
|
const char* path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
this->impl_.get_service().open(
|
||||||
|
this->impl_.get_implementation(),
|
||||||
|
path, open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_stream_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_stream_file(const executor_type& ex,
|
||||||
|
const std::string& path, file_base::flags open_flags)
|
||||||
|
: basic_file<Executor>(ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
this->impl_.get_service().open(
|
||||||
|
this->impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and open a basic_stream_file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises and opens a file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param path The path name identifying the file to be opened.
|
||||||
|
*
|
||||||
|
* @param open_flags A set of flags that determine how the file should be
|
||||||
|
* opened.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_stream_file(ExecutionContext& context,
|
||||||
|
const std::string& path, file_base::flags open_flags,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
this->impl_.get_service().open(
|
||||||
|
this->impl_.get_implementation(),
|
||||||
|
path.c_str(), open_flags, ec);
|
||||||
|
asio::detail::throw_error(ec, "open");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_stream_file on an existing native file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a stream file object to hold an existing
|
||||||
|
* native file.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the file will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file The new underlying file implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_stream_file(const executor_type& ex,
|
||||||
|
const native_handle_type& native_file)
|
||||||
|
: basic_file<Executor>(ex, native_file)
|
||||||
|
{
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_stream_file on an existing native file.
|
||||||
|
/**
|
||||||
|
* This constructor initialises a stream file object to hold an existing
|
||||||
|
* native file.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the file will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the file.
|
||||||
|
*
|
||||||
|
* @param native_file The new underlying file implementation.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_stream_file(ExecutionContext& context,
|
||||||
|
const native_handle_type& native_file,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(context, native_file)
|
||||||
|
{
|
||||||
|
this->impl_.get_service().set_is_stream(
|
||||||
|
this->impl_.get_implementation(), true);
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_stream_file from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a stream file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_stream_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_stream_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_stream_file(basic_stream_file&& other) ASIO_NOEXCEPT
|
||||||
|
: basic_file<Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_stream_file from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a stream file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_stream_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_stream_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_stream_file& operator=(basic_stream_file&& other)
|
||||||
|
{
|
||||||
|
basic_file<Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-construct a basic_stream_file from a file of another executor
|
||||||
|
/// type.
|
||||||
|
/**
|
||||||
|
* This constructor moves a stream file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_stream_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_stream_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
basic_stream_file(basic_stream_file<Executor1>&& other,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: basic_file<Executor>(std::move(other))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_stream_file from a file of another executor type.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a stream file from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_stream_file object from which the move
|
||||||
|
* will occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_stream_file(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
basic_stream_file&
|
||||||
|
>::type operator=(basic_stream_file<Executor1>&& other)
|
||||||
|
{
|
||||||
|
basic_file<Executor>::operator=(std::move(other));
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the file.
|
||||||
|
/**
|
||||||
|
* This function destroys the file, cancelling any outstanding asynchronous
|
||||||
|
* operations associated with the file as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_stream_file()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Seek to a position in the file.
|
||||||
|
/**
|
||||||
|
* This function updates the current position in the file.
|
||||||
|
*
|
||||||
|
* @param offset The requested position in the file, relative to @c whence.
|
||||||
|
*
|
||||||
|
* @param whence One of @c seek_set, @c seek_cur or @c seek_end.
|
||||||
|
*
|
||||||
|
* @returns The new position relative to the beginning of the file.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
uint64_t seek(int64_t offset, file_base::seek_basis whence)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
uint64_t n = this->impl_.get_service().seek(
|
||||||
|
this->impl_.get_implementation(), offset, whence, ec);
|
||||||
|
asio::detail::throw_error(ec, "seek");
|
||||||
|
return n;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Seek to a position in the file.
|
||||||
|
/**
|
||||||
|
* This function updates the current position in the file.
|
||||||
|
*
|
||||||
|
* @param offset The requested position in the file, relative to @c whence.
|
||||||
|
*
|
||||||
|
* @param whence One of @c seek_set, @c seek_cur or @c seek_end.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The new position relative to the beginning of the file.
|
||||||
|
*/
|
||||||
|
uint64_t seek(int64_t offset, file_base::seek_basis whence,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().seek(
|
||||||
|
this->impl_.get_implementation(), offset, whence, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the file.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the stream file. The function call
|
||||||
|
* will block until one or more bytes of the data has been written
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the file.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the end of the file was reached.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* file.write_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().write_some(
|
||||||
|
this->impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "write_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the file.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the stream file. The function call
|
||||||
|
* will block until one or more bytes of the data has been written
|
||||||
|
* successfully, or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the file.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().write_some(
|
||||||
|
this->impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously write data to the stream file.
|
||||||
|
* It is an initiating function for an @ref asynchronous_operation, and always
|
||||||
|
* returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the file.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the write completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes written.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The write operation may not transmit all of the data to the peer.
|
||||||
|
* Consider using the @ref async_write function if you need to ensure that all
|
||||||
|
* data is written before the asynchronous operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* file.async_write_some(asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WriteToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_write_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the file.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the stream file. The function
|
||||||
|
* call will block until one or more bytes of data has been read successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the end of the file was reached.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* file.read_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = this->impl_.get_service().read_some(
|
||||||
|
this->impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "read_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the file.
|
||||||
|
/**
|
||||||
|
* This function is used to read data from the stream file. The function
|
||||||
|
* call will block until one or more bytes of data has been read successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes read. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The read_some operation may not read all of the requested number of
|
||||||
|
* bytes. Consider using the @ref read function if you need to ensure that
|
||||||
|
* the requested amount of data is read before the blocking operation
|
||||||
|
* completes.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return this->impl_.get_service().read_some(
|
||||||
|
this->impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously read data from the stream file.
|
||||||
|
* It is an initiating function for an @ref asynchronous_operation, and always
|
||||||
|
* returns immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more buffers into which the data will be read.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the read completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes read.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The read operation may not read all of the requested number of bytes.
|
||||||
|
* Consider using the @ref async_read function if you need to ensure that the
|
||||||
|
* requested amount of data is read before the asynchronous operation
|
||||||
|
* completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To read into a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* file.async_read_some(asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on reading into multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* On POSIX or Windows operating systems, this asynchronous operation supports
|
||||||
|
* cancellation for the following asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<ReadToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_read_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_stream_file(const basic_stream_file&) ASIO_DELETED;
|
||||||
|
basic_stream_file& operator=(const basic_stream_file&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_write_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_write_some(basic_stream_file* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WriteHandler, typename ConstBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
|
||||||
|
const ConstBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WriteHandler.
|
||||||
|
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WriteHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_write_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_stream_file* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class initiate_async_read_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_read_some(basic_stream_file* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename ReadHandler, typename MutableBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(ReadHandler) handler,
|
||||||
|
const MutableBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a ReadHandler.
|
||||||
|
ASIO_READ_HANDLER_CHECK(ReadHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<ReadHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_read_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_stream_file* self_;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_FILE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_STREAM_FILE_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,452 @@
|
||||||
|
//
|
||||||
|
// basic_streambuf.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_STREAMBUF_HPP
|
||||||
|
#define ASIO_BASIC_STREAMBUF_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
|
#include <cstring>
|
||||||
|
#include <stdexcept>
|
||||||
|
#include <streambuf>
|
||||||
|
#include <vector>
|
||||||
|
#include "asio/basic_streambuf_fwd.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/limits.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/throw_exception.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Automatically resizable buffer class based on std::streambuf.
|
||||||
|
/**
|
||||||
|
* The @c basic_streambuf class is derived from @c std::streambuf to associate
|
||||||
|
* the streambuf's input and output sequences with one or more character
|
||||||
|
* arrays. These character arrays are internal to the @c basic_streambuf
|
||||||
|
* object, but direct access to the array elements is provided to permit them
|
||||||
|
* to be used efficiently with I/O operations. Characters written to the output
|
||||||
|
* sequence of a @c basic_streambuf object are appended to the input sequence
|
||||||
|
* of the same object.
|
||||||
|
*
|
||||||
|
* The @c basic_streambuf class's public interface is intended to permit the
|
||||||
|
* following implementation strategies:
|
||||||
|
*
|
||||||
|
* @li A single contiguous character array, which is reallocated as necessary
|
||||||
|
* to accommodate changes in the size of the character sequence. This is the
|
||||||
|
* implementation approach currently used in Asio.
|
||||||
|
*
|
||||||
|
* @li A sequence of one or more character arrays, where each array is of the
|
||||||
|
* same size. Additional character array objects are appended to the sequence
|
||||||
|
* to accommodate changes in the size of the character sequence.
|
||||||
|
*
|
||||||
|
* @li A sequence of one or more character arrays of varying sizes. Additional
|
||||||
|
* character array objects are appended to the sequence to accommodate changes
|
||||||
|
* in the size of the character sequence.
|
||||||
|
*
|
||||||
|
* The constructor for basic_streambuf accepts a @c size_t argument specifying
|
||||||
|
* the maximum of the sum of the sizes of the input sequence and output
|
||||||
|
* sequence. During the lifetime of the @c basic_streambuf object, the following
|
||||||
|
* invariant holds:
|
||||||
|
* @code size() <= max_size()@endcode
|
||||||
|
* Any member function that would, if successful, cause the invariant to be
|
||||||
|
* violated shall throw an exception of class @c std::length_error.
|
||||||
|
*
|
||||||
|
* The constructor for @c basic_streambuf takes an Allocator argument. A copy
|
||||||
|
* of this argument is used for any memory allocation performed, by the
|
||||||
|
* constructor and by all member functions, during the lifetime of each @c
|
||||||
|
* basic_streambuf object.
|
||||||
|
*
|
||||||
|
* @par Examples
|
||||||
|
* Writing directly from an streambuf to a socket:
|
||||||
|
* @code
|
||||||
|
* asio::streambuf b;
|
||||||
|
* std::ostream os(&b);
|
||||||
|
* os << "Hello, World!\n";
|
||||||
|
*
|
||||||
|
* // try sending some data in input sequence
|
||||||
|
* size_t n = sock.send(b.data());
|
||||||
|
*
|
||||||
|
* b.consume(n); // sent data is removed from input sequence
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* Reading from a socket directly into a streambuf:
|
||||||
|
* @code
|
||||||
|
* asio::streambuf b;
|
||||||
|
*
|
||||||
|
* // reserve 512 bytes in output sequence
|
||||||
|
* asio::streambuf::mutable_buffers_type bufs = b.prepare(512);
|
||||||
|
*
|
||||||
|
* size_t n = sock.receive(bufs);
|
||||||
|
*
|
||||||
|
* // received data is "committed" from output sequence to input sequence
|
||||||
|
* b.commit(n);
|
||||||
|
*
|
||||||
|
* std::istream is(&b);
|
||||||
|
* std::string s;
|
||||||
|
* is >> s;
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Allocator = std::allocator<char> >
|
||||||
|
#else
|
||||||
|
template <typename Allocator>
|
||||||
|
#endif
|
||||||
|
class basic_streambuf
|
||||||
|
: public std::streambuf,
|
||||||
|
private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The type used to represent the input sequence as a list of buffers.
|
||||||
|
typedef implementation_defined const_buffers_type;
|
||||||
|
|
||||||
|
/// The type used to represent the output sequence as a list of buffers.
|
||||||
|
typedef implementation_defined mutable_buffers_type;
|
||||||
|
#else
|
||||||
|
typedef ASIO_CONST_BUFFER const_buffers_type;
|
||||||
|
typedef ASIO_MUTABLE_BUFFER mutable_buffers_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct a basic_streambuf object.
|
||||||
|
/**
|
||||||
|
* Constructs a streambuf with the specified maximum size. The initial size
|
||||||
|
* of the streambuf's input sequence is 0.
|
||||||
|
*/
|
||||||
|
explicit basic_streambuf(
|
||||||
|
std::size_t maximum_size = (std::numeric_limits<std::size_t>::max)(),
|
||||||
|
const Allocator& allocator = Allocator())
|
||||||
|
: max_size_(maximum_size),
|
||||||
|
buffer_(allocator)
|
||||||
|
{
|
||||||
|
std::size_t pend = (std::min<std::size_t>)(max_size_, buffer_delta);
|
||||||
|
buffer_.resize((std::max<std::size_t>)(pend, 1));
|
||||||
|
setg(&buffer_[0], &buffer_[0], &buffer_[0]);
|
||||||
|
setp(&buffer_[0], &buffer_[0] + pend);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the size of the input sequence.
|
||||||
|
/**
|
||||||
|
* @returns The size of the input sequence. The value is equal to that
|
||||||
|
* calculated for @c s in the following code:
|
||||||
|
* @code
|
||||||
|
* size_t s = 0;
|
||||||
|
* const_buffers_type bufs = data();
|
||||||
|
* const_buffers_type::const_iterator i = bufs.begin();
|
||||||
|
* while (i != bufs.end())
|
||||||
|
* {
|
||||||
|
* const_buffer buf(*i++);
|
||||||
|
* s += buf.size();
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
std::size_t size() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return pptr() - gptr();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the maximum size of the basic_streambuf.
|
||||||
|
/**
|
||||||
|
* @returns The allowed maximum of the sum of the sizes of the input sequence
|
||||||
|
* and output sequence.
|
||||||
|
*/
|
||||||
|
std::size_t max_size() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return max_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the current capacity of the basic_streambuf.
|
||||||
|
/**
|
||||||
|
* @returns The current total capacity of the streambuf, i.e. for both the
|
||||||
|
* input sequence and output sequence.
|
||||||
|
*/
|
||||||
|
std::size_t capacity() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffer_.capacity();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a list of buffers that represents the input sequence.
|
||||||
|
/**
|
||||||
|
* @returns An object of type @c const_buffers_type that satisfies
|
||||||
|
* ConstBufferSequence requirements, representing all character arrays in the
|
||||||
|
* input sequence.
|
||||||
|
*
|
||||||
|
* @note The returned object is invalidated by any @c basic_streambuf member
|
||||||
|
* function that modifies the input sequence or output sequence.
|
||||||
|
*/
|
||||||
|
const_buffers_type data() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return asio::buffer(asio::const_buffer(gptr(),
|
||||||
|
(pptr() - gptr()) * sizeof(char_type)));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a list of buffers that represents the output sequence, with the given
|
||||||
|
/// size.
|
||||||
|
/**
|
||||||
|
* Ensures that the output sequence can accommodate @c n characters,
|
||||||
|
* reallocating character array objects as necessary.
|
||||||
|
*
|
||||||
|
* @returns An object of type @c mutable_buffers_type that satisfies
|
||||||
|
* MutableBufferSequence requirements, representing character array objects
|
||||||
|
* at the start of the output sequence such that the sum of the buffer sizes
|
||||||
|
* is @c n.
|
||||||
|
*
|
||||||
|
* @throws std::length_error If <tt>size() + n > max_size()</tt>.
|
||||||
|
*
|
||||||
|
* @note The returned object is invalidated by any @c basic_streambuf member
|
||||||
|
* function that modifies the input sequence or output sequence.
|
||||||
|
*/
|
||||||
|
mutable_buffers_type prepare(std::size_t n)
|
||||||
|
{
|
||||||
|
reserve(n);
|
||||||
|
return asio::buffer(asio::mutable_buffer(
|
||||||
|
pptr(), n * sizeof(char_type)));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move characters from the output sequence to the input sequence.
|
||||||
|
/**
|
||||||
|
* Appends @c n characters from the start of the output sequence to the input
|
||||||
|
* sequence. The beginning of the output sequence is advanced by @c n
|
||||||
|
* characters.
|
||||||
|
*
|
||||||
|
* Requires a preceding call <tt>prepare(x)</tt> where <tt>x >= n</tt>, and
|
||||||
|
* no intervening operations that modify the input or output sequence.
|
||||||
|
*
|
||||||
|
* @note If @c n is greater than the size of the output sequence, the entire
|
||||||
|
* output sequence is moved to the input sequence and no error is issued.
|
||||||
|
*/
|
||||||
|
void commit(std::size_t n)
|
||||||
|
{
|
||||||
|
n = std::min<std::size_t>(n, epptr() - pptr());
|
||||||
|
pbump(static_cast<int>(n));
|
||||||
|
setg(eback(), gptr(), pptr());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove characters from the input sequence.
|
||||||
|
/**
|
||||||
|
* Removes @c n characters from the beginning of the input sequence.
|
||||||
|
*
|
||||||
|
* @note If @c n is greater than the size of the input sequence, the entire
|
||||||
|
* input sequence is consumed and no error is issued.
|
||||||
|
*/
|
||||||
|
void consume(std::size_t n)
|
||||||
|
{
|
||||||
|
if (egptr() < pptr())
|
||||||
|
setg(&buffer_[0], gptr(), pptr());
|
||||||
|
if (gptr() + n > pptr())
|
||||||
|
n = pptr() - gptr();
|
||||||
|
gbump(static_cast<int>(n));
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
enum { buffer_delta = 128 };
|
||||||
|
|
||||||
|
/// Override std::streambuf behaviour.
|
||||||
|
/**
|
||||||
|
* Behaves according to the specification of @c std::streambuf::underflow().
|
||||||
|
*/
|
||||||
|
int_type underflow()
|
||||||
|
{
|
||||||
|
if (gptr() < pptr())
|
||||||
|
{
|
||||||
|
setg(&buffer_[0], gptr(), pptr());
|
||||||
|
return traits_type::to_int_type(*gptr());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return traits_type::eof();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Override std::streambuf behaviour.
|
||||||
|
/**
|
||||||
|
* Behaves according to the specification of @c std::streambuf::overflow(),
|
||||||
|
* with the specialisation that @c std::length_error is thrown if appending
|
||||||
|
* the character to the input sequence would require the condition
|
||||||
|
* <tt>size() > max_size()</tt> to be true.
|
||||||
|
*/
|
||||||
|
int_type overflow(int_type c)
|
||||||
|
{
|
||||||
|
if (!traits_type::eq_int_type(c, traits_type::eof()))
|
||||||
|
{
|
||||||
|
if (pptr() == epptr())
|
||||||
|
{
|
||||||
|
std::size_t buffer_size = pptr() - gptr();
|
||||||
|
if (buffer_size < max_size_ && max_size_ - buffer_size < buffer_delta)
|
||||||
|
{
|
||||||
|
reserve(max_size_ - buffer_size);
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
reserve(buffer_delta);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
*pptr() = traits_type::to_char_type(c);
|
||||||
|
pbump(1);
|
||||||
|
return c;
|
||||||
|
}
|
||||||
|
|
||||||
|
return traits_type::not_eof(c);
|
||||||
|
}
|
||||||
|
|
||||||
|
void reserve(std::size_t n)
|
||||||
|
{
|
||||||
|
// Get current stream positions as offsets.
|
||||||
|
std::size_t gnext = gptr() - &buffer_[0];
|
||||||
|
std::size_t pnext = pptr() - &buffer_[0];
|
||||||
|
std::size_t pend = epptr() - &buffer_[0];
|
||||||
|
|
||||||
|
// Check if there is already enough space in the put area.
|
||||||
|
if (n <= pend - pnext)
|
||||||
|
{
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Shift existing contents of get area to start of buffer.
|
||||||
|
if (gnext > 0)
|
||||||
|
{
|
||||||
|
pnext -= gnext;
|
||||||
|
std::memmove(&buffer_[0], &buffer_[0] + gnext, pnext);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ensure buffer is large enough to hold at least the specified size.
|
||||||
|
if (n > pend - pnext)
|
||||||
|
{
|
||||||
|
if (n <= max_size_ && pnext <= max_size_ - n)
|
||||||
|
{
|
||||||
|
pend = pnext + n;
|
||||||
|
buffer_.resize((std::max<std::size_t>)(pend, 1));
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
std::length_error ex("asio::streambuf too long");
|
||||||
|
asio::detail::throw_exception(ex);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update stream positions.
|
||||||
|
setg(&buffer_[0], &buffer_[0], &buffer_[0] + pnext);
|
||||||
|
setp(&buffer_[0] + pnext, &buffer_[0] + pend);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::size_t max_size_;
|
||||||
|
std::vector<char_type, Allocator> buffer_;
|
||||||
|
|
||||||
|
// Helper function to get the preferred size for reading data.
|
||||||
|
friend std::size_t read_size_helper(
|
||||||
|
basic_streambuf& sb, std::size_t max_size)
|
||||||
|
{
|
||||||
|
return std::min<std::size_t>(
|
||||||
|
std::max<std::size_t>(512, sb.buffer_.capacity() - sb.size()),
|
||||||
|
std::min<std::size_t>(max_size, sb.max_size() - sb.size()));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Adapts basic_streambuf to the dynamic buffer sequence type requirements.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename Allocator = std::allocator<char> >
|
||||||
|
#else
|
||||||
|
template <typename Allocator>
|
||||||
|
#endif
|
||||||
|
class basic_streambuf_ref
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type used to represent the input sequence as a list of buffers.
|
||||||
|
typedef typename basic_streambuf<Allocator>::const_buffers_type
|
||||||
|
const_buffers_type;
|
||||||
|
|
||||||
|
/// The type used to represent the output sequence as a list of buffers.
|
||||||
|
typedef typename basic_streambuf<Allocator>::mutable_buffers_type
|
||||||
|
mutable_buffers_type;
|
||||||
|
|
||||||
|
/// Construct a basic_streambuf_ref for the given basic_streambuf object.
|
||||||
|
explicit basic_streambuf_ref(basic_streambuf<Allocator>& sb)
|
||||||
|
: sb_(sb)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy construct a basic_streambuf_ref.
|
||||||
|
basic_streambuf_ref(const basic_streambuf_ref& other) ASIO_NOEXCEPT
|
||||||
|
: sb_(other.sb_)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move construct a basic_streambuf_ref.
|
||||||
|
basic_streambuf_ref(basic_streambuf_ref&& other) ASIO_NOEXCEPT
|
||||||
|
: sb_(other.sb_)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Get the size of the input sequence.
|
||||||
|
std::size_t size() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return sb_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the maximum size of the dynamic buffer.
|
||||||
|
std::size_t max_size() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return sb_.max_size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the current capacity of the dynamic buffer.
|
||||||
|
std::size_t capacity() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return sb_.capacity();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a list of buffers that represents the input sequence.
|
||||||
|
const_buffers_type data() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return sb_.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a list of buffers that represents the output sequence, with the given
|
||||||
|
/// size.
|
||||||
|
mutable_buffers_type prepare(std::size_t n)
|
||||||
|
{
|
||||||
|
return sb_.prepare(n);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move bytes from the output sequence to the input sequence.
|
||||||
|
void commit(std::size_t n)
|
||||||
|
{
|
||||||
|
return sb_.commit(n);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Remove characters from the input sequence.
|
||||||
|
void consume(std::size_t n)
|
||||||
|
{
|
||||||
|
return sb_.consume(n);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_streambuf<Allocator>& sb_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_STREAMBUF_HPP
|
||||||
|
|
@ -0,0 +1,36 @@
|
||||||
|
//
|
||||||
|
// basic_streambuf_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_STREAMBUF_FWD_HPP
|
||||||
|
#define ASIO_BASIC_STREAMBUF_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#include <memory>
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename Allocator = std::allocator<char> >
|
||||||
|
class basic_streambuf;
|
||||||
|
|
||||||
|
template <typename Allocator = std::allocator<char> >
|
||||||
|
class basic_streambuf_ref;
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_IOSTREAM)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_STREAMBUF_FWD_HPP
|
||||||
|
|
@ -0,0 +1,827 @@
|
||||||
|
//
|
||||||
|
// basic_waitable_timer.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_WAITABLE_TIMER_HPP
|
||||||
|
#define ASIO_BASIC_WAITABLE_TIMER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/detail/chrono_time_traits.hpp"
|
||||||
|
#include "asio/detail/deadline_timer_service.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/wait_traits.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
|
||||||
|
#define ASIO_BASIC_WAITABLE_TIMER_FWD_DECL
|
||||||
|
|
||||||
|
// Forward declaration with defaulted arguments.
|
||||||
|
template <typename Clock,
|
||||||
|
typename WaitTraits = asio::wait_traits<Clock>,
|
||||||
|
typename Executor = any_io_executor>
|
||||||
|
class basic_waitable_timer;
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_BASIC_WAITABLE_TIMER_FWD_DECL)
|
||||||
|
|
||||||
|
/// Provides waitable timer functionality.
|
||||||
|
/**
|
||||||
|
* The basic_waitable_timer class template provides the ability to perform a
|
||||||
|
* blocking or asynchronous wait for a timer to expire.
|
||||||
|
*
|
||||||
|
* A waitable timer is always in one of two states: "expired" or "not expired".
|
||||||
|
* If the wait() or async_wait() function is called on an expired timer, the
|
||||||
|
* wait operation will complete immediately.
|
||||||
|
*
|
||||||
|
* Most applications will use one of the asio::steady_timer,
|
||||||
|
* asio::system_timer or asio::high_resolution_timer typedefs.
|
||||||
|
*
|
||||||
|
* @note This waitable timer functionality is for use with the C++11 standard
|
||||||
|
* library's @c <chrono> facility, or with the Boost.Chrono library.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Examples
|
||||||
|
* Performing a blocking wait (C++11):
|
||||||
|
* @code
|
||||||
|
* // Construct a timer without setting an expiry time.
|
||||||
|
* asio::steady_timer timer(my_context);
|
||||||
|
*
|
||||||
|
* // Set an expiry time relative to now.
|
||||||
|
* timer.expires_after(std::chrono::seconds(5));
|
||||||
|
*
|
||||||
|
* // Wait for the timer to expire.
|
||||||
|
* timer.wait();
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par
|
||||||
|
* Performing an asynchronous wait (C++11):
|
||||||
|
* @code
|
||||||
|
* void handler(const asio::error_code& error)
|
||||||
|
* {
|
||||||
|
* if (!error)
|
||||||
|
* {
|
||||||
|
* // Timer expired.
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* ...
|
||||||
|
*
|
||||||
|
* // Construct a timer with an absolute expiry time.
|
||||||
|
* asio::steady_timer timer(my_context,
|
||||||
|
* std::chrono::steady_clock::now() + std::chrono::seconds(60));
|
||||||
|
*
|
||||||
|
* // Start an asynchronous wait.
|
||||||
|
* timer.async_wait(handler);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Changing an active waitable timer's expiry time
|
||||||
|
*
|
||||||
|
* Changing the expiry time of a timer while there are pending asynchronous
|
||||||
|
* waits causes those wait operations to be cancelled. To ensure that the action
|
||||||
|
* associated with the timer is performed only once, use something like this:
|
||||||
|
* used:
|
||||||
|
*
|
||||||
|
* @code
|
||||||
|
* void on_some_event()
|
||||||
|
* {
|
||||||
|
* if (my_timer.expires_after(seconds(5)) > 0)
|
||||||
|
* {
|
||||||
|
* // We managed to cancel the timer. Start new asynchronous wait.
|
||||||
|
* my_timer.async_wait(on_timeout);
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* // Too late, timer has already expired!
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* void on_timeout(const asio::error_code& e)
|
||||||
|
* {
|
||||||
|
* if (e != asio::error::operation_aborted)
|
||||||
|
* {
|
||||||
|
* // Timer was not cancelled, take necessary action.
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @li The asio::basic_waitable_timer::expires_after() function
|
||||||
|
* cancels any pending asynchronous waits, and returns the number of
|
||||||
|
* asynchronous waits that were cancelled. If it returns 0 then you were too
|
||||||
|
* late and the wait handler has already been executed, or will soon be
|
||||||
|
* executed. If it returns 1 then the wait handler was successfully cancelled.
|
||||||
|
*
|
||||||
|
* @li If a wait handler is cancelled, the asio::error_code passed to
|
||||||
|
* it contains the value asio::error::operation_aborted.
|
||||||
|
*/
|
||||||
|
template <typename Clock, typename WaitTraits, typename Executor>
|
||||||
|
class basic_waitable_timer
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the timer type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The timer type when rebound to the specified executor.
|
||||||
|
typedef basic_waitable_timer<Clock, WaitTraits, Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The clock type.
|
||||||
|
typedef Clock clock_type;
|
||||||
|
|
||||||
|
/// The duration type of the clock.
|
||||||
|
typedef typename clock_type::duration duration;
|
||||||
|
|
||||||
|
/// The time point type of the clock.
|
||||||
|
typedef typename clock_type::time_point time_point;
|
||||||
|
|
||||||
|
/// The wait traits type.
|
||||||
|
typedef WaitTraits traits_type;
|
||||||
|
|
||||||
|
/// Constructor.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer without setting an expiry time. The
|
||||||
|
* expires_at() or expires_after() functions must be called to set an expiry
|
||||||
|
* time before the timer can be waited on.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*/
|
||||||
|
explicit basic_waitable_timer(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer without setting an expiry time. The
|
||||||
|
* expires_at() or expires_after() functions must be called to set an expiry
|
||||||
|
* time before the timer can be waited on.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_waitable_timer(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor object that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, expressed
|
||||||
|
* as an absolute time.
|
||||||
|
*/
|
||||||
|
basic_waitable_timer(const executor_type& ex, const time_point& expiry_time)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, expressed
|
||||||
|
* as an absolute time.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_waitable_timer(ExecutionContext& context,
|
||||||
|
const time_point& expiry_time,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_at(impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the timer will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, relative to
|
||||||
|
* now.
|
||||||
|
*/
|
||||||
|
basic_waitable_timer(const executor_type& ex, const duration& expiry_time)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_after(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_after");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Constructor to set a particular expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This constructor creates a timer and sets the expiry time.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the timer will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the timer.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer, relative to
|
||||||
|
* now.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_waitable_timer(ExecutionContext& context,
|
||||||
|
const duration& expiry_time,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().expires_after(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_after");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_waitable_timer from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a timer from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_waitable_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_waitable_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_waitable_timer(basic_waitable_timer&& other)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_waitable_timer from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a timer from one object to another. Cancels
|
||||||
|
* any outstanding asynchronous operations associated with the target object.
|
||||||
|
*
|
||||||
|
* @param other The other basic_waitable_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_waitable_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_waitable_timer& operator=(basic_waitable_timer&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
// All timers have access to each other's implementations.
|
||||||
|
template <typename Clock1, typename WaitTraits1, typename Executor1>
|
||||||
|
friend class basic_waitable_timer;
|
||||||
|
|
||||||
|
/// Move-construct a basic_waitable_timer from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a timer from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_waitable_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_waitable_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
basic_waitable_timer(
|
||||||
|
basic_waitable_timer<Clock, WaitTraits, Executor1>&& other,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_waitable_timer from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a timer from one object to another. Cancels
|
||||||
|
* any outstanding asynchronous operations associated with the target object.
|
||||||
|
*
|
||||||
|
* @param other The other basic_waitable_timer object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_waitable_timer(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
template <typename Executor1>
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<Executor1, Executor>::value,
|
||||||
|
basic_waitable_timer&
|
||||||
|
>::type operator=(basic_waitable_timer<Clock, WaitTraits, Executor1>&& other)
|
||||||
|
{
|
||||||
|
basic_waitable_timer tmp(std::move(other));
|
||||||
|
impl_ = std::move(tmp.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the timer.
|
||||||
|
/**
|
||||||
|
* This function destroys the timer, cancelling any outstanding asynchronous
|
||||||
|
* wait operations associated with the timer as if by calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_waitable_timer()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel any asynchronous operations that are waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the timer. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use non-error_code overload.) Cancel any asynchronous
|
||||||
|
/// operations that are waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of any pending asynchronous wait
|
||||||
|
* operations against the timer. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel() is called, then the
|
||||||
|
* handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Cancels one asynchronous operation that is waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of one pending asynchronous wait
|
||||||
|
* operation against the timer. Handlers are cancelled in FIFO order. The
|
||||||
|
* handler for the cancelled operation will be invoked with the
|
||||||
|
* asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled. That is,
|
||||||
|
* either 0 or 1.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel_one() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel_one()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().cancel_one(
|
||||||
|
impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel_one");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use non-error_code overload.) Cancels one asynchronous
|
||||||
|
/// operation that is waiting on the timer.
|
||||||
|
/**
|
||||||
|
* This function forces the completion of one pending asynchronous wait
|
||||||
|
* operation against the timer. Handlers are cancelled in FIFO order. The
|
||||||
|
* handler for the cancelled operation will be invoked with the
|
||||||
|
* asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* Cancelling the timer does not change the expiry time.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled. That is,
|
||||||
|
* either 0 or 1.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when cancel_one() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t cancel_one(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().cancel_one(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expiry().) Get the timer's expiry time as an absolute
|
||||||
|
/// time.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the timer's current expiry time.
|
||||||
|
* Whether the timer has expired or not does not affect this value.
|
||||||
|
*/
|
||||||
|
time_point expires_at() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_at(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Get the timer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the timer's current expiry time.
|
||||||
|
* Whether the timer has expired or not does not affect this value.
|
||||||
|
*/
|
||||||
|
time_point expiry() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().expiry(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Set the timer's expiry time as an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_at() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_at(const time_point& expiry_time)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().expires_at(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_at");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use non-error_code overload.) Set the timer's expiry time as
|
||||||
|
/// an absolute time.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_at() is called, then
|
||||||
|
* the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_at(const time_point& expiry_time,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_at(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Set the timer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_after() is called,
|
||||||
|
* then the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_after(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().expires_after(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_after");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
/// (Deprecated: Use expiry().) Get the timer's expiry time relative to now.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the timer's current expiry time.
|
||||||
|
* Whether the timer has expired or not does not affect this value.
|
||||||
|
*/
|
||||||
|
duration expires_from_now() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_from_now(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expires_after().) Set the timer's expiry time relative
|
||||||
|
/// to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_from_now() is called,
|
||||||
|
* then the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_from_now(const duration& expiry_time)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
asio::detail::throw_error(ec, "expires_from_now");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// (Deprecated: Use expires_after().) Set the timer's expiry time relative
|
||||||
|
/// to now.
|
||||||
|
/**
|
||||||
|
* This function sets the expiry time. Any pending asynchronous wait
|
||||||
|
* operations will be cancelled. The handler for each cancelled operation will
|
||||||
|
* be invoked with the asio::error::operation_aborted error code.
|
||||||
|
*
|
||||||
|
* @param expiry_time The expiry time to be used for the timer.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @return The number of asynchronous operations that were cancelled.
|
||||||
|
*
|
||||||
|
* @note If the timer has already expired when expires_from_now() is called,
|
||||||
|
* then the handlers for asynchronous wait operations will:
|
||||||
|
*
|
||||||
|
* @li have already been invoked; or
|
||||||
|
*
|
||||||
|
* @li have been queued for invocation in the near future.
|
||||||
|
*
|
||||||
|
* These handlers can no longer be cancelled, and therefore are passed an
|
||||||
|
* error code that indicates the successful completion of the wait operation.
|
||||||
|
*/
|
||||||
|
std::size_t expires_from_now(const duration& expiry_time,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().expires_from_now(
|
||||||
|
impl_.get_implementation(), expiry_time, ec);
|
||||||
|
}
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
/// Perform a blocking wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function is used to wait for the timer to expire. This function
|
||||||
|
* blocks and does not return until the timer has expired.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void wait()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().wait(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "wait");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a blocking wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function is used to wait for the timer to expire. This function
|
||||||
|
* blocks and does not return until the timer has expired.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
void wait(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().wait(impl_.get_implementation(), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous wait on the timer.
|
||||||
|
/**
|
||||||
|
* This function may be used to initiate an asynchronous wait against the
|
||||||
|
* timer. It is an initiating function for an @ref asynchronous_operation,
|
||||||
|
* and always returns immediately.
|
||||||
|
*
|
||||||
|
* For each call to async_wait(), the completion handler will be called
|
||||||
|
* exactly once. The completion handler will be called when:
|
||||||
|
*
|
||||||
|
* @li The timer has expired.
|
||||||
|
*
|
||||||
|
* @li The timer was cancelled, in which case the handler is passed the error
|
||||||
|
* code asio::error::operation_aborted.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the timer expires. Potential
|
||||||
|
* completion tokens include @ref use_future, @ref use_awaitable, @ref
|
||||||
|
* yield_context, or a function object with the correct completion signature.
|
||||||
|
* The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error // Result of operation.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code) @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* This asynchronous operation supports cancellation for the following
|
||||||
|
* asio::cancellation_type values:
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::terminal
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::partial
|
||||||
|
*
|
||||||
|
* @li @c cancellation_type::total
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code))
|
||||||
|
WaitToken ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WaitToken,
|
||||||
|
void (asio::error_code))
|
||||||
|
async_wait(
|
||||||
|
ASIO_MOVE_ARG(WaitToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WaitToken, void (asio::error_code)>(
|
||||||
|
initiate_async_wait(this), token);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_waitable_timer(const basic_waitable_timer&) ASIO_DELETED;
|
||||||
|
basic_waitable_timer& operator=(
|
||||||
|
const basic_waitable_timer&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_wait
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_wait(basic_waitable_timer* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WaitHandler>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WaitHandler) handler) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WaitHandler.
|
||||||
|
ASIO_WAIT_HANDLER_CHECK(WaitHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WaitHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_wait(
|
||||||
|
self_->impl_.get_implementation(),
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_waitable_timer* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
detail::io_object_impl<
|
||||||
|
detail::deadline_timer_service<
|
||||||
|
detail::chrono_time_traits<Clock, WaitTraits> >,
|
||||||
|
executor_type > impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_WAITABLE_TIMER_HPP
|
||||||
|
|
@ -0,0 +1,525 @@
|
||||||
|
//
|
||||||
|
// basic_writable_pipe.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BASIC_WRITABLE_PIPE_HPP
|
||||||
|
#define ASIO_BASIC_WRITABLE_PIPE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_PIPE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include <string>
|
||||||
|
#include "asio/any_io_executor.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/handler_type_requirements.hpp"
|
||||||
|
#include "asio/detail/io_object_impl.hpp"
|
||||||
|
#include "asio/detail/non_const_lvalue.hpp"
|
||||||
|
#include "asio/detail/throw_error.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
# include "asio/detail/win_iocp_handle_service.hpp"
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
# include "asio/detail/io_uring_descriptor_service.hpp"
|
||||||
|
#else
|
||||||
|
# include "asio/detail/reactive_descriptor_service.hpp"
|
||||||
|
#endif
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Provides pipe functionality.
|
||||||
|
/**
|
||||||
|
* The basic_writable_pipe class provides a wrapper over pipe
|
||||||
|
* functionality.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*/
|
||||||
|
template <typename Executor = any_io_executor>
|
||||||
|
class basic_writable_pipe
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
/// Rebinds the pipe type to another executor.
|
||||||
|
template <typename Executor1>
|
||||||
|
struct rebind_executor
|
||||||
|
{
|
||||||
|
/// The pipe type when rebound to the specified executor.
|
||||||
|
typedef basic_writable_pipe<Executor1> other;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// The native representation of a pipe.
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef implementation_defined native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IOCP)
|
||||||
|
typedef detail::win_iocp_handle_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
typedef detail::io_uring_descriptor_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#else
|
||||||
|
typedef detail::reactive_descriptor_service::native_handle_type
|
||||||
|
native_handle_type;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// A basic_writable_pipe is always the lowest layer.
|
||||||
|
typedef basic_writable_pipe lowest_layer_type;
|
||||||
|
|
||||||
|
/// Construct a basic_writable_pipe without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe without opening it.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the pipe will use, by default, to dispatch
|
||||||
|
* handlers for any asynchronous operations performed on the pipe.
|
||||||
|
*/
|
||||||
|
explicit basic_writable_pipe(const executor_type& ex)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_writable_pipe without opening it.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe without opening it.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the pipe will use, by default, to dispatch handlers for any asynchronous
|
||||||
|
* operations performed on the pipe.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
explicit basic_writable_pipe(ExecutionContext& context,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value,
|
||||||
|
defaulted_constraint
|
||||||
|
>::type = defaulted_constraint())
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_writable_pipe on an existing native pipe.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe object to hold an existing native
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param ex The I/O executor that the pipe will use, by default, to
|
||||||
|
* dispatch handlers for any asynchronous operations performed on the
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
basic_writable_pipe(const executor_type& ex,
|
||||||
|
const native_handle_type& native_pipe)
|
||||||
|
: impl_(0, ex)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a basic_writable_pipe on an existing native pipe.
|
||||||
|
/**
|
||||||
|
* This constructor creates a pipe object to hold an existing native
|
||||||
|
* pipe.
|
||||||
|
*
|
||||||
|
* @param context An execution context which provides the I/O executor that
|
||||||
|
* the pipe will use, by default, to dispatch handlers for any
|
||||||
|
* asynchronous operations performed on the pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
basic_writable_pipe(ExecutionContext& context,
|
||||||
|
const native_handle_type& native_pipe,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: impl_(0, 0, context)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(),
|
||||||
|
native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move-construct a basic_writable_pipe from another.
|
||||||
|
/**
|
||||||
|
* This constructor moves a pipe from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_writable_pipe object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_writable_pipe(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_writable_pipe(basic_writable_pipe&& other)
|
||||||
|
: impl_(std::move(other.impl_))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move-assign a basic_writable_pipe from another.
|
||||||
|
/**
|
||||||
|
* This assignment operator moves a pipe from one object to another.
|
||||||
|
*
|
||||||
|
* @param other The other basic_writable_pipe object from which the move will
|
||||||
|
* occur.
|
||||||
|
*
|
||||||
|
* @note Following the move, the moved-from object is in the same state as if
|
||||||
|
* constructed using the @c basic_writable_pipe(const executor_type&)
|
||||||
|
* constructor.
|
||||||
|
*/
|
||||||
|
basic_writable_pipe& operator=(basic_writable_pipe&& other)
|
||||||
|
{
|
||||||
|
impl_ = std::move(other.impl_);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destroys the pipe.
|
||||||
|
/**
|
||||||
|
* This function destroys the pipe, cancelling any outstanding
|
||||||
|
* asynchronous wait operations associated with the pipe as if by
|
||||||
|
* calling @c cancel.
|
||||||
|
*/
|
||||||
|
~basic_writable_pipe()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_.get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_writable_pipe cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A reference to the lowest layer in the stack of layers. Ownership
|
||||||
|
* is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
/**
|
||||||
|
* This function returns a const reference to the lowest layer in a stack of
|
||||||
|
* layers. Since a basic_writable_pipe cannot contain any further layers, it
|
||||||
|
* simply returns a reference to itself.
|
||||||
|
*
|
||||||
|
* @return A const reference to the lowest layer in the stack of layers.
|
||||||
|
* Ownership is not transferred to the caller.
|
||||||
|
*/
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native pipe to the pipe.
|
||||||
|
/*
|
||||||
|
* This function opens the pipe to hold an existing native pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void assign(const native_handle_type& native_pipe)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
|
||||||
|
asio::detail::throw_error(ec, "assign");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Assign an existing native pipe to the pipe.
|
||||||
|
/*
|
||||||
|
* This function opens the pipe to hold an existing native pipe.
|
||||||
|
*
|
||||||
|
* @param native_pipe A native pipe.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID assign(const native_handle_type& native_pipe,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().assign(impl_.get_implementation(), native_pipe, ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine whether the pipe is open.
|
||||||
|
bool is_open() const
|
||||||
|
{
|
||||||
|
return impl_.get_service().is_open(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to close the pipe. Any asynchronous write operations
|
||||||
|
* will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "close");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to close the pipe. Any asynchronous write operations
|
||||||
|
* will be cancelled immediately, and will complete with the
|
||||||
|
* asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().close(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the native pipe representation.
|
||||||
|
/**
|
||||||
|
* This function may be used to obtain the underlying representation of the
|
||||||
|
* pipe. This is intended to allow access to native pipe
|
||||||
|
* functionality that is not otherwise provided.
|
||||||
|
*/
|
||||||
|
native_handle_type native_handle()
|
||||||
|
{
|
||||||
|
return impl_.get_service().native_handle(impl_.get_implementation());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the pipe.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous write operations to
|
||||||
|
* finish immediately, and the handlers for cancelled operations will be
|
||||||
|
* passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
void cancel()
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
asio::detail::throw_error(ec, "cancel");
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Cancel all asynchronous operations associated with the pipe.
|
||||||
|
/**
|
||||||
|
* This function causes all outstanding asynchronous write operations to
|
||||||
|
* finish immediately, and the handlers for cancelled operations will be
|
||||||
|
* passed the asio::error::operation_aborted error.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
ASIO_SYNC_OP_VOID cancel(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
impl_.get_service().cancel(impl_.get_implementation(), ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the pipe. The function call will
|
||||||
|
* block until one or more bytes of the data has been written successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the pipe.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure. An error code of
|
||||||
|
* asio::error::eof indicates that the connection was closed by the
|
||||||
|
* peer.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* pipe.write_some(asio::buffer(data, size));
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
std::size_t s = impl_.get_service().write_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
asio::detail::throw_error(ec, "write_some");
|
||||||
|
return s;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write some data to the pipe.
|
||||||
|
/**
|
||||||
|
* This function is used to write data to the pipe. The function call will
|
||||||
|
* block until one or more bytes of the data has been written successfully,
|
||||||
|
* or until an error occurs.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the pipe.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*
|
||||||
|
* @returns The number of bytes written. Returns 0 if an error occurred.
|
||||||
|
*
|
||||||
|
* @note The write_some operation may not transmit all of the data to the
|
||||||
|
* peer. Consider using the @ref write function if you need to ensure that
|
||||||
|
* all data is written before the blocking operation completes.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return impl_.get_service().write_some(
|
||||||
|
impl_.get_implementation(), buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write.
|
||||||
|
/**
|
||||||
|
* This function is used to asynchronously write data to the pipe. It is an
|
||||||
|
* initiating function for an @ref asynchronous_operation, and always returns
|
||||||
|
* immediately.
|
||||||
|
*
|
||||||
|
* @param buffers One or more data buffers to be written to the pipe.
|
||||||
|
* Although the buffers object may be copied as necessary, ownership of the
|
||||||
|
* underlying memory blocks is retained by the caller, which must guarantee
|
||||||
|
* that they remain valid until the completion handler is called.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler, which will be called when the write completes.
|
||||||
|
* Potential completion tokens include @ref use_future, @ref use_awaitable,
|
||||||
|
* @ref yield_context, or a function object with the correct completion
|
||||||
|
* signature. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(
|
||||||
|
* const asio::error_code& error, // Result of operation.
|
||||||
|
* std::size_t bytes_transferred // Number of bytes written.
|
||||||
|
* ); @endcode
|
||||||
|
* Regardless of whether the asynchronous operation completes immediately or
|
||||||
|
* not, the completion handler will not be invoked from within this function.
|
||||||
|
* On immediate completion, invocation of the handler will be performed in a
|
||||||
|
* manner equivalent to using asio::post().
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*
|
||||||
|
* @note The write operation may not transmit all of the data to the peer.
|
||||||
|
* Consider using the @ref async_write function if you need to ensure that all
|
||||||
|
* data is written before the asynchronous operation completes.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* To write a single data buffer use the @ref buffer function as follows:
|
||||||
|
* @code
|
||||||
|
* pipe.async_write_some(asio::buffer(data, size), handler);
|
||||||
|
* @endcode
|
||||||
|
* See the @ref buffer documentation for information on writing multiple
|
||||||
|
* buffers in one go, and how to use it with arrays, boost::array or
|
||||||
|
* std::vector.
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteToken,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return async_initiate<WriteToken,
|
||||||
|
void (asio::error_code, std::size_t)>(
|
||||||
|
initiate_async_write_some(this), token, buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
basic_writable_pipe(const basic_writable_pipe&) ASIO_DELETED;
|
||||||
|
basic_writable_pipe& operator=(const basic_writable_pipe&) ASIO_DELETED;
|
||||||
|
|
||||||
|
class initiate_async_write_some
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
explicit initiate_async_write_some(basic_writable_pipe* self)
|
||||||
|
: self_(self)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return self_->get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename WriteHandler, typename ConstBufferSequence>
|
||||||
|
void operator()(ASIO_MOVE_ARG(WriteHandler) handler,
|
||||||
|
const ConstBufferSequence& buffers) const
|
||||||
|
{
|
||||||
|
// If you get an error on the following line it means that your handler
|
||||||
|
// does not meet the documented type requirements for a WriteHandler.
|
||||||
|
ASIO_WRITE_HANDLER_CHECK(WriteHandler, handler) type_check;
|
||||||
|
|
||||||
|
detail::non_const_lvalue<WriteHandler> handler2(handler);
|
||||||
|
self_->impl_.get_service().async_write_some(
|
||||||
|
self_->impl_.get_implementation(), buffers,
|
||||||
|
handler2.value, self_->impl_.get_executor());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
basic_writable_pipe* self_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
detail::io_object_impl<detail::win_iocp_handle_service, Executor> impl_;
|
||||||
|
#elif defined(ASIO_HAS_IO_URING_AS_DEFAULT)
|
||||||
|
detail::io_object_impl<detail::io_uring_descriptor_service, Executor> impl_;
|
||||||
|
#else
|
||||||
|
detail::io_object_impl<detail::reactive_descriptor_service, Executor> impl_;
|
||||||
|
#endif
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_PIPE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_BASIC_WRITABLE_PIPE_HPP
|
||||||
|
|
@ -0,0 +1,722 @@
|
||||||
|
//
|
||||||
|
// bind_allocator.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BIND_ALLOCATOR_HPP
|
||||||
|
#define ASIO_BIND_ALLOCATOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/detail/variadic_templates.hpp"
|
||||||
|
#include "asio/associated_allocator.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef result_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct allocator_binder_result_type
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
typedef void result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct allocator_binder_result_type<T,
|
||||||
|
typename void_type<typename T::result_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::result_type result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct allocator_binder_result_type<R(*)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct allocator_binder_result_type<R(&)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct allocator_binder_result_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct allocator_binder_result_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct allocator_binder_result_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct allocator_binder_result_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct allocator_binder_argument_type {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct allocator_binder_argument_type<T,
|
||||||
|
typename void_type<typename T::argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::argument_type argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct allocator_binder_argument_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct allocator_binder_argument_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedefs first_argument_type and
|
||||||
|
// second_argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct allocator_binder_argument_types {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct allocator_binder_argument_types<T,
|
||||||
|
typename void_type<typename T::first_argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::first_argument_type first_argument_type;
|
||||||
|
typedef typename T::second_argument_type second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct allocator_binder_argument_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct allocator_binder_argument_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to enable SFINAE on zero-argument operator() below.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct allocator_binder_result_of0
|
||||||
|
{
|
||||||
|
typedef void type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct allocator_binder_result_of0<T,
|
||||||
|
typename void_type<typename result_of<T()>::type>::type>
|
||||||
|
{
|
||||||
|
typedef typename result_of<T()>::type type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// A call wrapper type to bind an allocator of type @c Allocator
|
||||||
|
/// to an object of type @c T.
|
||||||
|
template <typename T, typename Allocator>
|
||||||
|
class allocator_binder
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: public detail::allocator_binder_result_type<T>,
|
||||||
|
public detail::allocator_binder_argument_type<T>,
|
||||||
|
public detail::allocator_binder_argument_types<T>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the target object.
|
||||||
|
typedef T target_type;
|
||||||
|
|
||||||
|
/// The type of the associated allocator.
|
||||||
|
typedef Allocator allocator_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The return type if a function.
|
||||||
|
/**
|
||||||
|
* The type of @c result_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to function type, @c result_type is a synonym for
|
||||||
|
* the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c result_type, then @c
|
||||||
|
* result_type is a synonym for @c T::result_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c result_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below result_type;
|
||||||
|
|
||||||
|
/// The type of the function's argument.
|
||||||
|
/**
|
||||||
|
* The type of @c argument_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting a single argument,
|
||||||
|
* @c argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c argument_type, then @c
|
||||||
|
* argument_type is a synonym for @c T::argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's first argument.
|
||||||
|
/**
|
||||||
|
* The type of @c first_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* first_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c first_argument_type is a synonym for @c T::first_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c first_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below first_argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's second argument.
|
||||||
|
/**
|
||||||
|
* The type of @c second_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* second_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c second_argument_type is a synonym for @c T::second_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c second_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below second_argument_type;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Construct an allocator wrapper for the specified object.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U>
|
||||||
|
allocator_binder(const allocator_type& s,
|
||||||
|
ASIO_MOVE_ARG(U) u)
|
||||||
|
: allocator_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(u))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy constructor.
|
||||||
|
allocator_binder(const allocator_binder& other)
|
||||||
|
: allocator_(other.get_allocator()),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy, but specify a different allocator.
|
||||||
|
allocator_binder(const allocator_type& s,
|
||||||
|
const allocator_binder& other)
|
||||||
|
: allocator_(s),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different allocator wrapper type.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the @c Allocator type is
|
||||||
|
* constructible from type @c OtherAllocator, and the type @c T is
|
||||||
|
* constructible from type @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherAllocator>
|
||||||
|
allocator_binder(
|
||||||
|
const allocator_binder<U, OtherAllocator>& other)
|
||||||
|
: allocator_(other.get_allocator()),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different allocator wrapper type, but
|
||||||
|
/// specify a different allocator.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherAllocator>
|
||||||
|
allocator_binder(const allocator_type& s,
|
||||||
|
const allocator_binder<U, OtherAllocator>& other)
|
||||||
|
: allocator_(s),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Move constructor.
|
||||||
|
allocator_binder(allocator_binder&& other)
|
||||||
|
: allocator_(ASIO_MOVE_CAST(allocator_type)(
|
||||||
|
other.get_allocator())),
|
||||||
|
target_(ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct the target object, but specify a different allocator.
|
||||||
|
allocator_binder(const allocator_type& s,
|
||||||
|
allocator_binder&& other)
|
||||||
|
: allocator_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different allocator wrapper type.
|
||||||
|
template <typename U, typename OtherAllocator>
|
||||||
|
allocator_binder(
|
||||||
|
allocator_binder<U, OtherAllocator>&& other)
|
||||||
|
: allocator_(ASIO_MOVE_CAST(OtherAllocator)(
|
||||||
|
other.get_allocator())),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different allocator wrapper type, but
|
||||||
|
/// specify a different allocator.
|
||||||
|
template <typename U, typename OtherAllocator>
|
||||||
|
allocator_binder(const allocator_type& s,
|
||||||
|
allocator_binder<U, OtherAllocator>&& other)
|
||||||
|
: allocator_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destructor.
|
||||||
|
~allocator_binder()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
target_type& get() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
const target_type& get() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain the associated allocator.
|
||||||
|
allocator_type get_allocator() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return allocator_;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <typename... Args> auto operator()(Args&& ...);
|
||||||
|
template <typename... Args> auto operator()(Args&& ...) const;
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
return target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typename detail::allocator_binder_result_of0<T>::type operator()()
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
typename detail::allocator_binder_result_of0<T>::type
|
||||||
|
operator()() const
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BINDER_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BINDER_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BINDER_CALL_DEF
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typedef typename detail::allocator_binder_result_type<
|
||||||
|
T>::result_type_or_void result_type_or_void;
|
||||||
|
|
||||||
|
result_type_or_void operator()()
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
result_type_or_void operator()() const
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BINDER_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BINDER_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BINDER_CALL_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
private:
|
||||||
|
Allocator allocator_;
|
||||||
|
T target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Associate an object of type @c T with an allocator of type
|
||||||
|
/// @c Allocator.
|
||||||
|
template <typename Allocator, typename T>
|
||||||
|
ASIO_NODISCARD inline allocator_binder<typename decay<T>::type, Allocator>
|
||||||
|
bind_allocator(const Allocator& s, ASIO_MOVE_ARG(T) t)
|
||||||
|
{
|
||||||
|
return allocator_binder<
|
||||||
|
typename decay<T>::type, Allocator>(
|
||||||
|
s, ASIO_MOVE_CAST(T)(t));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult,
|
||||||
|
typename Allocator, typename = void>
|
||||||
|
struct allocator_binder_async_result_completion_handler_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename Allocator>
|
||||||
|
struct allocator_binder_async_result_completion_handler_type<
|
||||||
|
TargetAsyncResult, Allocator,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::completion_handler_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef allocator_binder<
|
||||||
|
typename TargetAsyncResult::completion_handler_type, Allocator>
|
||||||
|
completion_handler_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename = void>
|
||||||
|
struct allocator_binder_async_result_return_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult>
|
||||||
|
struct allocator_binder_async_result_return_type<
|
||||||
|
TargetAsyncResult,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::return_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef typename TargetAsyncResult::return_type return_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
template <typename T, typename Allocator, typename Signature>
|
||||||
|
class async_result<allocator_binder<T, Allocator>, Signature> :
|
||||||
|
public detail::allocator_binder_async_result_completion_handler_type<
|
||||||
|
async_result<T, Signature>, Allocator>,
|
||||||
|
public detail::allocator_binder_async_result_return_type<
|
||||||
|
async_result<T, Signature> >
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit async_result(allocator_binder<T, Allocator>& b)
|
||||||
|
: target_(b.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
typename async_result<T, Signature>::return_type get()
|
||||||
|
{
|
||||||
|
return target_.get();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Initiation>
|
||||||
|
struct init_wrapper
|
||||||
|
{
|
||||||
|
template <typename Init>
|
||||||
|
init_wrapper(const Allocator& allocator, ASIO_MOVE_ARG(Init) init)
|
||||||
|
: allocator_(allocator),
|
||||||
|
initiation_(ASIO_MOVE_CAST(Init)(init))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
allocator_binder<
|
||||||
|
typename decay<Handler>::type, Allocator>(
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
allocator_binder<
|
||||||
|
typename decay<Handler>::type, Allocator>(
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
allocator_binder<
|
||||||
|
typename decay<Handler>::type, Allocator>(
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
allocator_binder<
|
||||||
|
typename decay<Handler>::type, Allocator>(
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)( \
|
||||||
|
allocator_binder< \
|
||||||
|
typename decay<Handler>::type, Allocator>( \
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
initiation_( \
|
||||||
|
allocator_binder< \
|
||||||
|
typename decay<Handler>::type, Allocator>( \
|
||||||
|
allocator_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INIT_WRAPPER_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INIT_WRAPPER_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
Allocator allocator_;
|
||||||
|
Initiation initiation_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken, typename... Args>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get(),
|
||||||
|
declval<ASIO_MOVE_ARG(Args)>()...)))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_allocator(),
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get(), ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get())))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_allocator(),
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get());
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INITIATE_DEF(n) \
|
||||||
|
template <typename Initiation, typename RawCompletionToken, \
|
||||||
|
ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
|
||||||
|
(async_initiate<T, Signature>( \
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(), \
|
||||||
|
declval<RawCompletionToken>().get(), \
|
||||||
|
ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
|
||||||
|
initiate( \
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation, \
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return async_initiate<T, Signature>( \
|
||||||
|
init_wrapper<typename decay<Initiation>::type>( \
|
||||||
|
token.get_allocator(), \
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)), \
|
||||||
|
token.get(), ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INITIATE_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
private:
|
||||||
|
async_result(const async_result&) ASIO_DELETED;
|
||||||
|
async_result& operator=(const async_result&) ASIO_DELETED;
|
||||||
|
|
||||||
|
async_result<T, Signature> target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <template <typename, typename> class Associator,
|
||||||
|
typename T, typename Allocator, typename DefaultCandidate>
|
||||||
|
struct associator<Associator,
|
||||||
|
allocator_binder<T, Allocator>,
|
||||||
|
DefaultCandidate>
|
||||||
|
{
|
||||||
|
typedef typename Associator<T, DefaultCandidate>::type type;
|
||||||
|
|
||||||
|
static type get(const allocator_binder<T, Allocator>& b,
|
||||||
|
const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return Associator<T, DefaultCandidate>::get(b.get(), c);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename Allocator, typename Allocator1>
|
||||||
|
struct associated_allocator<
|
||||||
|
allocator_binder<T, Allocator>,
|
||||||
|
Allocator1>
|
||||||
|
{
|
||||||
|
typedef Allocator type;
|
||||||
|
|
||||||
|
static type get(const allocator_binder<T, Allocator>& b,
|
||||||
|
const Allocator1& = Allocator1()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return b.get_allocator();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BIND_ALLOCATOR_HPP
|
||||||
|
|
@ -0,0 +1,724 @@
|
||||||
|
//
|
||||||
|
// bind_cancellation_slot.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BIND_CANCELLATION_SLOT_HPP
|
||||||
|
#define ASIO_BIND_CANCELLATION_SLOT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/detail/variadic_templates.hpp"
|
||||||
|
#include "asio/associated_cancellation_slot.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef result_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct cancellation_slot_binder_result_type
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
typedef void result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct cancellation_slot_binder_result_type<T,
|
||||||
|
typename void_type<typename T::result_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::result_type result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct cancellation_slot_binder_result_type<R(*)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct cancellation_slot_binder_result_type<R(&)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct cancellation_slot_binder_result_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct cancellation_slot_binder_result_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct cancellation_slot_binder_result_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct cancellation_slot_binder_result_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct cancellation_slot_binder_argument_type {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct cancellation_slot_binder_argument_type<T,
|
||||||
|
typename void_type<typename T::argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::argument_type argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct cancellation_slot_binder_argument_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct cancellation_slot_binder_argument_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedefs first_argument_type and
|
||||||
|
// second_argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct cancellation_slot_binder_argument_types {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct cancellation_slot_binder_argument_types<T,
|
||||||
|
typename void_type<typename T::first_argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::first_argument_type first_argument_type;
|
||||||
|
typedef typename T::second_argument_type second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct cancellation_slot_binder_argument_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct cancellation_slot_binder_argument_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to enable SFINAE on zero-argument operator() below.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct cancellation_slot_binder_result_of0
|
||||||
|
{
|
||||||
|
typedef void type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct cancellation_slot_binder_result_of0<T,
|
||||||
|
typename void_type<typename result_of<T()>::type>::type>
|
||||||
|
{
|
||||||
|
typedef typename result_of<T()>::type type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// A call wrapper type to bind a cancellation slot of type @c CancellationSlot
|
||||||
|
/// to an object of type @c T.
|
||||||
|
template <typename T, typename CancellationSlot>
|
||||||
|
class cancellation_slot_binder
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: public detail::cancellation_slot_binder_result_type<T>,
|
||||||
|
public detail::cancellation_slot_binder_argument_type<T>,
|
||||||
|
public detail::cancellation_slot_binder_argument_types<T>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the target object.
|
||||||
|
typedef T target_type;
|
||||||
|
|
||||||
|
/// The type of the associated cancellation slot.
|
||||||
|
typedef CancellationSlot cancellation_slot_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The return type if a function.
|
||||||
|
/**
|
||||||
|
* The type of @c result_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to function type, @c result_type is a synonym for
|
||||||
|
* the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c result_type, then @c
|
||||||
|
* result_type is a synonym for @c T::result_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c result_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below result_type;
|
||||||
|
|
||||||
|
/// The type of the function's argument.
|
||||||
|
/**
|
||||||
|
* The type of @c argument_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting a single argument,
|
||||||
|
* @c argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c argument_type, then @c
|
||||||
|
* argument_type is a synonym for @c T::argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's first argument.
|
||||||
|
/**
|
||||||
|
* The type of @c first_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* first_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c first_argument_type is a synonym for @c T::first_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c first_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below first_argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's second argument.
|
||||||
|
/**
|
||||||
|
* The type of @c second_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* second_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c second_argument_type is a synonym for @c T::second_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c second_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below second_argument_type;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Construct a cancellation slot wrapper for the specified object.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U>
|
||||||
|
cancellation_slot_binder(const cancellation_slot_type& s,
|
||||||
|
ASIO_MOVE_ARG(U) u)
|
||||||
|
: slot_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(u))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy constructor.
|
||||||
|
cancellation_slot_binder(const cancellation_slot_binder& other)
|
||||||
|
: slot_(other.get_cancellation_slot()),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy, but specify a different cancellation slot.
|
||||||
|
cancellation_slot_binder(const cancellation_slot_type& s,
|
||||||
|
const cancellation_slot_binder& other)
|
||||||
|
: slot_(s),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different cancellation slot wrapper type.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the @c CancellationSlot type is
|
||||||
|
* constructible from type @c OtherCancellationSlot, and the type @c T is
|
||||||
|
* constructible from type @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherCancellationSlot>
|
||||||
|
cancellation_slot_binder(
|
||||||
|
const cancellation_slot_binder<U, OtherCancellationSlot>& other)
|
||||||
|
: slot_(other.get_cancellation_slot()),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different cancellation slot wrapper type, but
|
||||||
|
/// specify a different cancellation slot.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherCancellationSlot>
|
||||||
|
cancellation_slot_binder(const cancellation_slot_type& s,
|
||||||
|
const cancellation_slot_binder<U, OtherCancellationSlot>& other)
|
||||||
|
: slot_(s),
|
||||||
|
target_(other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Move constructor.
|
||||||
|
cancellation_slot_binder(cancellation_slot_binder&& other)
|
||||||
|
: slot_(ASIO_MOVE_CAST(cancellation_slot_type)(
|
||||||
|
other.get_cancellation_slot())),
|
||||||
|
target_(ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct the target object, but specify a different cancellation
|
||||||
|
/// slot.
|
||||||
|
cancellation_slot_binder(const cancellation_slot_type& s,
|
||||||
|
cancellation_slot_binder&& other)
|
||||||
|
: slot_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different cancellation slot wrapper type.
|
||||||
|
template <typename U, typename OtherCancellationSlot>
|
||||||
|
cancellation_slot_binder(
|
||||||
|
cancellation_slot_binder<U, OtherCancellationSlot>&& other)
|
||||||
|
: slot_(ASIO_MOVE_CAST(OtherCancellationSlot)(
|
||||||
|
other.get_cancellation_slot())),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different cancellation slot wrapper type, but
|
||||||
|
/// specify a different cancellation slot.
|
||||||
|
template <typename U, typename OtherCancellationSlot>
|
||||||
|
cancellation_slot_binder(const cancellation_slot_type& s,
|
||||||
|
cancellation_slot_binder<U, OtherCancellationSlot>&& other)
|
||||||
|
: slot_(s),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destructor.
|
||||||
|
~cancellation_slot_binder()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
target_type& get() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
const target_type& get() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain the associated cancellation slot.
|
||||||
|
cancellation_slot_type get_cancellation_slot() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return slot_;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <typename... Args> auto operator()(Args&& ...);
|
||||||
|
template <typename... Args> auto operator()(Args&& ...) const;
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
return target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typename detail::cancellation_slot_binder_result_of0<T>::type operator()()
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
typename detail::cancellation_slot_binder_result_of0<T>::type
|
||||||
|
operator()() const
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BINDER_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BINDER_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BINDER_CALL_DEF
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typedef typename detail::cancellation_slot_binder_result_type<
|
||||||
|
T>::result_type_or_void result_type_or_void;
|
||||||
|
|
||||||
|
result_type_or_void operator()()
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
result_type_or_void operator()() const
|
||||||
|
{
|
||||||
|
return target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BINDER_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BINDER_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BINDER_CALL_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
private:
|
||||||
|
CancellationSlot slot_;
|
||||||
|
T target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Associate an object of type @c T with a cancellation slot of type
|
||||||
|
/// @c CancellationSlot.
|
||||||
|
template <typename CancellationSlot, typename T>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
cancellation_slot_binder<typename decay<T>::type, CancellationSlot>
|
||||||
|
bind_cancellation_slot(const CancellationSlot& s, ASIO_MOVE_ARG(T) t)
|
||||||
|
{
|
||||||
|
return cancellation_slot_binder<
|
||||||
|
typename decay<T>::type, CancellationSlot>(
|
||||||
|
s, ASIO_MOVE_CAST(T)(t));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult,
|
||||||
|
typename CancellationSlot, typename = void>
|
||||||
|
struct cancellation_slot_binder_async_result_completion_handler_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename CancellationSlot>
|
||||||
|
struct cancellation_slot_binder_async_result_completion_handler_type<
|
||||||
|
TargetAsyncResult, CancellationSlot,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::completion_handler_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef cancellation_slot_binder<
|
||||||
|
typename TargetAsyncResult::completion_handler_type, CancellationSlot>
|
||||||
|
completion_handler_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename = void>
|
||||||
|
struct cancellation_slot_binder_async_result_return_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult>
|
||||||
|
struct cancellation_slot_binder_async_result_return_type<
|
||||||
|
TargetAsyncResult,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::return_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef typename TargetAsyncResult::return_type return_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
template <typename T, typename CancellationSlot, typename Signature>
|
||||||
|
class async_result<cancellation_slot_binder<T, CancellationSlot>, Signature> :
|
||||||
|
public detail::cancellation_slot_binder_async_result_completion_handler_type<
|
||||||
|
async_result<T, Signature>, CancellationSlot>,
|
||||||
|
public detail::cancellation_slot_binder_async_result_return_type<
|
||||||
|
async_result<T, Signature> >
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit async_result(cancellation_slot_binder<T, CancellationSlot>& b)
|
||||||
|
: target_(b.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
typename async_result<T, Signature>::return_type get()
|
||||||
|
{
|
||||||
|
return target_.get();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Initiation>
|
||||||
|
struct init_wrapper
|
||||||
|
{
|
||||||
|
template <typename Init>
|
||||||
|
init_wrapper(const CancellationSlot& slot, ASIO_MOVE_ARG(Init) init)
|
||||||
|
: slot_(slot),
|
||||||
|
initiation_(ASIO_MOVE_CAST(Init)(init))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
cancellation_slot_binder<
|
||||||
|
typename decay<Handler>::type, CancellationSlot>(
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
cancellation_slot_binder<
|
||||||
|
typename decay<Handler>::type, CancellationSlot>(
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
cancellation_slot_binder<
|
||||||
|
typename decay<Handler>::type, CancellationSlot>(
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
cancellation_slot_binder<
|
||||||
|
typename decay<Handler>::type, CancellationSlot>(
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)( \
|
||||||
|
cancellation_slot_binder< \
|
||||||
|
typename decay<Handler>::type, CancellationSlot>( \
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
initiation_( \
|
||||||
|
cancellation_slot_binder< \
|
||||||
|
typename decay<Handler>::type, CancellationSlot>( \
|
||||||
|
slot_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INIT_WRAPPER_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INIT_WRAPPER_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
CancellationSlot slot_;
|
||||||
|
Initiation initiation_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken, typename... Args>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get(),
|
||||||
|
declval<ASIO_MOVE_ARG(Args)>()...)))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_cancellation_slot(),
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get(), ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get())))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_cancellation_slot(),
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get());
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INITIATE_DEF(n) \
|
||||||
|
template <typename Initiation, typename RawCompletionToken, \
|
||||||
|
ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
|
||||||
|
(async_initiate<T, Signature>( \
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(), \
|
||||||
|
declval<RawCompletionToken>().get(), \
|
||||||
|
ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
|
||||||
|
initiate( \
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation, \
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return async_initiate<T, Signature>( \
|
||||||
|
init_wrapper<typename decay<Initiation>::type>( \
|
||||||
|
token.get_cancellation_slot(), \
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation)), \
|
||||||
|
token.get(), ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INITIATE_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
private:
|
||||||
|
async_result(const async_result&) ASIO_DELETED;
|
||||||
|
async_result& operator=(const async_result&) ASIO_DELETED;
|
||||||
|
|
||||||
|
async_result<T, Signature> target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <template <typename, typename> class Associator,
|
||||||
|
typename T, typename CancellationSlot, typename DefaultCandidate>
|
||||||
|
struct associator<Associator,
|
||||||
|
cancellation_slot_binder<T, CancellationSlot>,
|
||||||
|
DefaultCandidate>
|
||||||
|
{
|
||||||
|
typedef typename Associator<T, DefaultCandidate>::type type;
|
||||||
|
|
||||||
|
static type get(const cancellation_slot_binder<T, CancellationSlot>& b,
|
||||||
|
const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return Associator<T, DefaultCandidate>::get(b.get(), c);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename CancellationSlot, typename CancellationSlot1>
|
||||||
|
struct associated_cancellation_slot<
|
||||||
|
cancellation_slot_binder<T, CancellationSlot>,
|
||||||
|
CancellationSlot1>
|
||||||
|
{
|
||||||
|
typedef CancellationSlot type;
|
||||||
|
|
||||||
|
static type get(const cancellation_slot_binder<T, CancellationSlot>& b,
|
||||||
|
const CancellationSlot1& = CancellationSlot1()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return b.get_cancellation_slot();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BIND_CANCELLATION_SLOT_HPP
|
||||||
|
|
@ -0,0 +1,770 @@
|
||||||
|
//
|
||||||
|
// bind_executor.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BIND_EXECUTOR_HPP
|
||||||
|
#define ASIO_BIND_EXECUTOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/detail/variadic_templates.hpp"
|
||||||
|
#include "asio/associated_executor.hpp"
|
||||||
|
#include "asio/associator.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
#include "asio/uses_executor.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef result_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct executor_binder_result_type
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
typedef void result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct executor_binder_result_type<T,
|
||||||
|
typename void_type<typename T::result_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::result_type result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct executor_binder_result_type<R(*)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R>
|
||||||
|
struct executor_binder_result_type<R(&)()>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct executor_binder_result_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct executor_binder_result_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct executor_binder_result_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct executor_binder_result_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef R result_type;
|
||||||
|
protected:
|
||||||
|
typedef result_type result_type_or_void;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedef argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct executor_binder_argument_type {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct executor_binder_argument_type<T,
|
||||||
|
typename void_type<typename T::argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::argument_type argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct executor_binder_argument_type<R(*)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1>
|
||||||
|
struct executor_binder_argument_type<R(&)(A1)>
|
||||||
|
{
|
||||||
|
typedef A1 argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to automatically define nested typedefs first_argument_type and
|
||||||
|
// second_argument_type.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct executor_binder_argument_types {};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct executor_binder_argument_types<T,
|
||||||
|
typename void_type<typename T::first_argument_type>::type>
|
||||||
|
{
|
||||||
|
typedef typename T::first_argument_type first_argument_type;
|
||||||
|
typedef typename T::second_argument_type second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct executor_binder_argument_type<R(*)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename R, typename A1, typename A2>
|
||||||
|
struct executor_binder_argument_type<R(&)(A1, A2)>
|
||||||
|
{
|
||||||
|
typedef A1 first_argument_type;
|
||||||
|
typedef A2 second_argument_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to perform uses_executor construction of the target type, if
|
||||||
|
// required.
|
||||||
|
|
||||||
|
template <typename T, typename Executor, bool UsesExecutor>
|
||||||
|
class executor_binder_base;
|
||||||
|
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
class executor_binder_base<T, Executor, true>
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
template <typename E, typename U>
|
||||||
|
executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
|
||||||
|
: executor_(ASIO_MOVE_CAST(E)(e)),
|
||||||
|
target_(executor_arg_t(), executor_, ASIO_MOVE_CAST(U)(u))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
Executor executor_;
|
||||||
|
T target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
class executor_binder_base<T, Executor, false>
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
template <typename E, typename U>
|
||||||
|
executor_binder_base(ASIO_MOVE_ARG(E) e, ASIO_MOVE_ARG(U) u)
|
||||||
|
: executor_(ASIO_MOVE_CAST(E)(e)),
|
||||||
|
target_(ASIO_MOVE_CAST(U)(u))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
Executor executor_;
|
||||||
|
T target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to enable SFINAE on zero-argument operator() below.
|
||||||
|
|
||||||
|
template <typename T, typename = void>
|
||||||
|
struct executor_binder_result_of0
|
||||||
|
{
|
||||||
|
typedef void type;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct executor_binder_result_of0<T,
|
||||||
|
typename void_type<typename result_of<T()>::type>::type>
|
||||||
|
{
|
||||||
|
typedef typename result_of<T()>::type type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// A call wrapper type to bind an executor of type @c Executor to an object of
|
||||||
|
/// type @c T.
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
class executor_binder
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
: public detail::executor_binder_result_type<T>,
|
||||||
|
public detail::executor_binder_argument_type<T>,
|
||||||
|
public detail::executor_binder_argument_types<T>,
|
||||||
|
private detail::executor_binder_base<
|
||||||
|
T, Executor, uses_executor<T, Executor>::value>
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the target object.
|
||||||
|
typedef T target_type;
|
||||||
|
|
||||||
|
/// The type of the associated executor.
|
||||||
|
typedef Executor executor_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The return type if a function.
|
||||||
|
/**
|
||||||
|
* The type of @c result_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to function type, @c result_type is a synonym for
|
||||||
|
* the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c result_type, then @c
|
||||||
|
* result_type is a synonym for @c T::result_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c result_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below result_type;
|
||||||
|
|
||||||
|
/// The type of the function's argument.
|
||||||
|
/**
|
||||||
|
* The type of @c argument_type is based on the type @c T of the wrapper's
|
||||||
|
* target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting a single argument,
|
||||||
|
* @c argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c argument_type, then @c
|
||||||
|
* argument_type is a synonym for @c T::argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's first argument.
|
||||||
|
/**
|
||||||
|
* The type of @c first_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* first_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c first_argument_type is a synonym for @c T::first_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c first_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below first_argument_type;
|
||||||
|
|
||||||
|
/// The type of the function's second argument.
|
||||||
|
/**
|
||||||
|
* The type of @c second_argument_type is based on the type @c T of the
|
||||||
|
* wrapper's target object:
|
||||||
|
*
|
||||||
|
* @li if @c T is a pointer to a function type accepting two arguments, @c
|
||||||
|
* second_argument_type is a synonym for the return type of @c T;
|
||||||
|
*
|
||||||
|
* @li if @c T is a class type with a member type @c first_argument_type,
|
||||||
|
* then @c second_argument_type is a synonym for @c T::second_argument_type;
|
||||||
|
*
|
||||||
|
* @li otherwise @c second_argument_type is not defined.
|
||||||
|
*/
|
||||||
|
typedef see_below second_argument_type;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Construct an executor wrapper for the specified object.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U>
|
||||||
|
executor_binder(executor_arg_t, const executor_type& e,
|
||||||
|
ASIO_MOVE_ARG(U) u)
|
||||||
|
: base_type(e, ASIO_MOVE_CAST(U)(u))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy constructor.
|
||||||
|
executor_binder(const executor_binder& other)
|
||||||
|
: base_type(other.get_executor(), other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy, but specify a different executor.
|
||||||
|
executor_binder(executor_arg_t, const executor_type& e,
|
||||||
|
const executor_binder& other)
|
||||||
|
: base_type(e, other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different executor wrapper type.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the @c Executor type is constructible
|
||||||
|
* from type @c OtherExecutor, and the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherExecutor>
|
||||||
|
executor_binder(const executor_binder<U, OtherExecutor>& other)
|
||||||
|
: base_type(other.get_executor(), other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct a copy of a different executor wrapper type, but specify a
|
||||||
|
/// different executor.
|
||||||
|
/**
|
||||||
|
* This constructor is only valid if the type @c T is constructible from type
|
||||||
|
* @c U.
|
||||||
|
*/
|
||||||
|
template <typename U, typename OtherExecutor>
|
||||||
|
executor_binder(executor_arg_t, const executor_type& e,
|
||||||
|
const executor_binder<U, OtherExecutor>& other)
|
||||||
|
: base_type(e, other.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Move constructor.
|
||||||
|
executor_binder(executor_binder&& other)
|
||||||
|
: base_type(ASIO_MOVE_CAST(executor_type)(other.get_executor()),
|
||||||
|
ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct the target object, but specify a different executor.
|
||||||
|
executor_binder(executor_arg_t, const executor_type& e,
|
||||||
|
executor_binder&& other)
|
||||||
|
: base_type(e, ASIO_MOVE_CAST(T)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different executor wrapper type.
|
||||||
|
template <typename U, typename OtherExecutor>
|
||||||
|
executor_binder(executor_binder<U, OtherExecutor>&& other)
|
||||||
|
: base_type(ASIO_MOVE_CAST(OtherExecutor)(other.get_executor()),
|
||||||
|
ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Move construct from a different executor wrapper type, but specify a
|
||||||
|
/// different executor.
|
||||||
|
template <typename U, typename OtherExecutor>
|
||||||
|
executor_binder(executor_arg_t, const executor_type& e,
|
||||||
|
executor_binder<U, OtherExecutor>&& other)
|
||||||
|
: base_type(e, ASIO_MOVE_CAST(U)(other.get()))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Destructor.
|
||||||
|
~executor_binder()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
target_type& get() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return this->target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain a reference to the target object.
|
||||||
|
const target_type& get() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return this->target_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Obtain the associated executor.
|
||||||
|
executor_type get_executor() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return this->executor_;
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <typename... Args> auto operator()(Args&& ...);
|
||||||
|
template <typename... Args> auto operator()(Args&& ...) const;
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return this->target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Forwarding function call operator.
|
||||||
|
template <typename... Args>
|
||||||
|
typename result_of<T(Args...)>::type operator()(
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
return this->target_(ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typename detail::executor_binder_result_of0<T>::type operator()()
|
||||||
|
{
|
||||||
|
return this->target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
typename detail::executor_binder_result_of0<T>::type operator()() const
|
||||||
|
{
|
||||||
|
return this->target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
typename result_of<T(ASIO_VARIADIC_TARGS(n))>::type operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
typedef typename detail::executor_binder_result_type<T>::result_type_or_void
|
||||||
|
result_type_or_void;
|
||||||
|
|
||||||
|
result_type_or_void operator()()
|
||||||
|
{
|
||||||
|
return this->target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
result_type_or_void operator()() const
|
||||||
|
{
|
||||||
|
return this->target_();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
result_type_or_void operator()( \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
return this->target_(ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF)
|
||||||
|
#undef ASIO_PRIVATE_BIND_EXECUTOR_CALL_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_TYPE_TRAITS) && !defined(_MSC_VER)
|
||||||
|
|
||||||
|
private:
|
||||||
|
typedef detail::executor_binder_base<T, Executor,
|
||||||
|
uses_executor<T, Executor>::value> base_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Associate an object of type @c T with an executor of type @c Executor.
|
||||||
|
template <typename Executor, typename T>
|
||||||
|
ASIO_NODISCARD inline executor_binder<typename decay<T>::type, Executor>
|
||||||
|
bind_executor(const Executor& ex, ASIO_MOVE_ARG(T) t,
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
{
|
||||||
|
return executor_binder<typename decay<T>::type, Executor>(
|
||||||
|
executor_arg_t(), ex, ASIO_MOVE_CAST(T)(t));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Associate an object of type @c T with an execution context's executor.
|
||||||
|
template <typename ExecutionContext, typename T>
|
||||||
|
ASIO_NODISCARD inline executor_binder<typename decay<T>::type,
|
||||||
|
typename ExecutionContext::executor_type>
|
||||||
|
bind_executor(ExecutionContext& ctx, ASIO_MOVE_ARG(T) t,
|
||||||
|
typename constraint<is_convertible<
|
||||||
|
ExecutionContext&, execution_context&>::value>::type = 0)
|
||||||
|
{
|
||||||
|
return executor_binder<typename decay<T>::type,
|
||||||
|
typename ExecutionContext::executor_type>(
|
||||||
|
executor_arg_t(), ctx.get_executor(), ASIO_MOVE_CAST(T)(t));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
struct uses_executor<executor_binder<T, Executor>, Executor>
|
||||||
|
: true_type {};
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename Executor, typename = void>
|
||||||
|
class executor_binder_completion_handler_async_result
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename T>
|
||||||
|
explicit executor_binder_completion_handler_async_result(T&)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename Executor>
|
||||||
|
class executor_binder_completion_handler_async_result<
|
||||||
|
TargetAsyncResult, Executor,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::completion_handler_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef executor_binder<
|
||||||
|
typename TargetAsyncResult::completion_handler_type, Executor>
|
||||||
|
completion_handler_type;
|
||||||
|
|
||||||
|
explicit executor_binder_completion_handler_async_result(
|
||||||
|
typename TargetAsyncResult::completion_handler_type& handler)
|
||||||
|
: target_(handler)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
typename TargetAsyncResult::return_type get()
|
||||||
|
{
|
||||||
|
return target_.get();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
TargetAsyncResult target_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult, typename = void>
|
||||||
|
struct executor_binder_async_result_return_type
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename TargetAsyncResult>
|
||||||
|
struct executor_binder_async_result_return_type<
|
||||||
|
TargetAsyncResult,
|
||||||
|
typename void_type<
|
||||||
|
typename TargetAsyncResult::return_type
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
typedef typename TargetAsyncResult::return_type return_type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
template <typename T, typename Executor, typename Signature>
|
||||||
|
class async_result<executor_binder<T, Executor>, Signature> :
|
||||||
|
public detail::executor_binder_completion_handler_async_result<
|
||||||
|
async_result<T, Signature>, Executor>,
|
||||||
|
public detail::executor_binder_async_result_return_type<
|
||||||
|
async_result<T, Signature> >
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit async_result(executor_binder<T, Executor>& b)
|
||||||
|
: detail::executor_binder_completion_handler_async_result<
|
||||||
|
async_result<T, Signature>, Executor>(b.get())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Initiation>
|
||||||
|
struct init_wrapper
|
||||||
|
{
|
||||||
|
template <typename Init>
|
||||||
|
init_wrapper(const Executor& ex, ASIO_MOVE_ARG(Init) init)
|
||||||
|
: ex_(ex),
|
||||||
|
initiation_(ASIO_MOVE_CAST(Init)(init))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>(
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler, typename... Args>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler,
|
||||||
|
ASIO_MOVE_ARG(Args)... args) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>(
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler)
|
||||||
|
{
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)(
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>(
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
void operator()(
|
||||||
|
ASIO_MOVE_ARG(Handler) handler) const
|
||||||
|
{
|
||||||
|
initiation_(
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>(
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)));
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INIT_WRAPPER_DEF(n) \
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
ASIO_MOVE_CAST(Initiation)(initiation_)( \
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>( \
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
\
|
||||||
|
template <typename Handler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
void operator()( \
|
||||||
|
ASIO_MOVE_ARG(Handler) handler, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) const \
|
||||||
|
{ \
|
||||||
|
initiation_( \
|
||||||
|
executor_binder<typename decay<Handler>::type, Executor>( \
|
||||||
|
executor_arg_t(), ex_, ASIO_MOVE_CAST(Handler)(handler)), \
|
||||||
|
ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INIT_WRAPPER_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INIT_WRAPPER_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
Executor ex_;
|
||||||
|
Initiation initiation_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken, typename... Args>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get(),
|
||||||
|
declval<ASIO_MOVE_ARG(Args)>()...)))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token,
|
||||||
|
ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get(), ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
}
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
template <typename Initiation, typename RawCompletionToken>
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature,
|
||||||
|
(async_initiate<T, Signature>(
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(),
|
||||||
|
declval<RawCompletionToken>().get())))
|
||||||
|
initiate(
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation,
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token)
|
||||||
|
{
|
||||||
|
return async_initiate<T, Signature>(
|
||||||
|
init_wrapper<typename decay<Initiation>::type>(
|
||||||
|
token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)),
|
||||||
|
token.get());
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_INITIATE_DEF(n) \
|
||||||
|
template <typename Initiation, typename RawCompletionToken, \
|
||||||
|
ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
static ASIO_INITFN_DEDUCED_RESULT_TYPE(T, Signature, \
|
||||||
|
(async_initiate<T, Signature>( \
|
||||||
|
declval<init_wrapper<typename decay<Initiation>::type> >(), \
|
||||||
|
declval<RawCompletionToken>().get(), \
|
||||||
|
ASIO_VARIADIC_MOVE_DECLVAL(n)))) \
|
||||||
|
initiate( \
|
||||||
|
ASIO_MOVE_ARG(Initiation) initiation, \
|
||||||
|
ASIO_MOVE_ARG(RawCompletionToken) token, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
return async_initiate<T, Signature>( \
|
||||||
|
init_wrapper<typename decay<Initiation>::type>( \
|
||||||
|
token.get_executor(), ASIO_MOVE_CAST(Initiation)(initiation)), \
|
||||||
|
token.get(), ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_INITIATE_DEF)
|
||||||
|
#undef ASIO_PRIVATE_INITIATE_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
private:
|
||||||
|
async_result(const async_result&) ASIO_DELETED;
|
||||||
|
async_result& operator=(const async_result&) ASIO_DELETED;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <template <typename, typename> class Associator,
|
||||||
|
typename T, typename Executor, typename DefaultCandidate>
|
||||||
|
struct associator<Associator, executor_binder<T, Executor>, DefaultCandidate>
|
||||||
|
{
|
||||||
|
typedef typename Associator<T, DefaultCandidate>::type type;
|
||||||
|
|
||||||
|
static type get(const executor_binder<T, Executor>& b,
|
||||||
|
const DefaultCandidate& c = DefaultCandidate()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return Associator<T, DefaultCandidate>::get(b.get(), c);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename T, typename Executor, typename Executor1>
|
||||||
|
struct associated_executor<executor_binder<T, Executor>, Executor1>
|
||||||
|
{
|
||||||
|
typedef Executor type;
|
||||||
|
|
||||||
|
static type get(const executor_binder<T, Executor>& b,
|
||||||
|
const Executor1& = Executor1()) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return b.get_executor();
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BIND_EXECUTOR_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,328 @@
|
||||||
|
//
|
||||||
|
// buffer_registration.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFER_REGISTRATION_HPP
|
||||||
|
#define ASIO_BUFFER_REGISTRATION_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <iterator>
|
||||||
|
#include <vector>
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/execution/context.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
#include "asio/query.hpp"
|
||||||
|
#include "asio/registered_buffer.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
# include "asio/detail/scheduler.hpp"
|
||||||
|
# include "asio/detail/io_uring_service.hpp"
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
# include <utility>
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class buffer_registration_base
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
static mutable_registered_buffer make_buffer(const mutable_buffer& b,
|
||||||
|
const void* scope, int index) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return mutable_registered_buffer(b, registered_buffer_id(scope, index));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Automatically registers and unregistered buffers with an execution context.
|
||||||
|
/**
|
||||||
|
* For portability, applications should assume that only one registration is
|
||||||
|
* permitted per execution context.
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
typename Allocator = std::allocator<void> >
|
||||||
|
class buffer_registration
|
||||||
|
: detail::buffer_registration_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The allocator type used for allocating storage for the buffers container.
|
||||||
|
typedef Allocator allocator_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The type of an iterator over the registered buffers.
|
||||||
|
typedef unspecified iterator;
|
||||||
|
|
||||||
|
/// The type of a const iterator over the registered buffers.
|
||||||
|
typedef unspecified const_iterator;
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef std::vector<mutable_registered_buffer>::const_iterator iterator;
|
||||||
|
typedef std::vector<mutable_registered_buffer>::const_iterator const_iterator;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Register buffers with an executor's execution context.
|
||||||
|
template <typename Executor>
|
||||||
|
buffer_registration(const Executor& ex,
|
||||||
|
const MutableBufferSequence& buffer_sequence,
|
||||||
|
const allocator_type& alloc = allocator_type(),
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
: buffer_sequence_(buffer_sequence),
|
||||||
|
buffers_(
|
||||||
|
ASIO_REBIND_ALLOC(allocator_type,
|
||||||
|
mutable_registered_buffer)(alloc))
|
||||||
|
{
|
||||||
|
init_buffers(buffer_registration::get_context(ex),
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence_),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence_));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Register buffers with an execution context.
|
||||||
|
template <typename ExecutionContext>
|
||||||
|
buffer_registration(ExecutionContext& ctx,
|
||||||
|
const MutableBufferSequence& buffer_sequence,
|
||||||
|
const allocator_type& alloc = allocator_type(),
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
: buffer_sequence_(buffer_sequence),
|
||||||
|
buffers_(
|
||||||
|
ASIO_REBIND_ALLOC(allocator_type,
|
||||||
|
mutable_registered_buffer)(alloc))
|
||||||
|
{
|
||||||
|
init_buffers(ctx,
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence_),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence_));
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move constructor.
|
||||||
|
buffer_registration(buffer_registration&& other) ASIO_NOEXCEPT
|
||||||
|
: buffer_sequence_(std::move(other.buffer_sequence_)),
|
||||||
|
buffers_(std::move(other.buffers_))
|
||||||
|
{
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
service_ = other.service_;
|
||||||
|
other.service_ = 0;
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Unregisters the buffers.
|
||||||
|
~buffer_registration()
|
||||||
|
{
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
if (service_)
|
||||||
|
service_->unregister_buffers();
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Move assignment.
|
||||||
|
buffer_registration& operator=(
|
||||||
|
buffer_registration&& other) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
if (this != &other)
|
||||||
|
{
|
||||||
|
buffer_sequence_ = std::move(other.buffer_sequence_);
|
||||||
|
buffers_ = std::move(other.buffers_);
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
if (service_)
|
||||||
|
service_->unregister_buffers();
|
||||||
|
service_ = other.service_;
|
||||||
|
other.service_ = 0;
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
}
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Get the number of registered buffers.
|
||||||
|
std::size_t size() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the begin iterator for the sequence of registered buffers.
|
||||||
|
const_iterator begin() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.begin();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the begin iterator for the sequence of registered buffers.
|
||||||
|
const_iterator cbegin() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.cbegin();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the end iterator for the sequence of registered buffers.
|
||||||
|
const_iterator end() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.end();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the end iterator for the sequence of registered buffers.
|
||||||
|
const_iterator cend() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.cend();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the buffer at the specified index.
|
||||||
|
const mutable_registered_buffer& operator[](std::size_t i) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_[i];
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the buffer at the specified index.
|
||||||
|
const mutable_registered_buffer& at(std::size_t i) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return buffers_.at(i);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Disallow copying and assignment.
|
||||||
|
buffer_registration(const buffer_registration&) ASIO_DELETED;
|
||||||
|
buffer_registration& operator=(const buffer_registration&) ASIO_DELETED;
|
||||||
|
|
||||||
|
// Helper function to get an executor's context.
|
||||||
|
template <typename T>
|
||||||
|
static execution_context& get_context(const T& t,
|
||||||
|
typename enable_if<execution::is_executor<T>::value>::type* = 0)
|
||||||
|
{
|
||||||
|
return asio::query(t, execution::context);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper function to get an executor's context.
|
||||||
|
template <typename T>
|
||||||
|
static execution_context& get_context(const T& t,
|
||||||
|
typename enable_if<!execution::is_executor<T>::value>::type* = 0)
|
||||||
|
{
|
||||||
|
return t.context();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper function to initialise the container of buffers.
|
||||||
|
template <typename Iterator>
|
||||||
|
void init_buffers(execution_context& ctx, Iterator begin, Iterator end)
|
||||||
|
{
|
||||||
|
std::size_t n = std::distance(begin, end);
|
||||||
|
buffers_.resize(n);
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
service_ = &use_service<detail::io_uring_service>(ctx);
|
||||||
|
std::vector<iovec,
|
||||||
|
ASIO_REBIND_ALLOC(allocator_type, iovec)> iovecs(n,
|
||||||
|
ASIO_REBIND_ALLOC(allocator_type, iovec)(
|
||||||
|
buffers_.get_allocator()));
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
|
||||||
|
Iterator iter = begin;
|
||||||
|
for (int index = 0; iter != end; ++index, ++iter)
|
||||||
|
{
|
||||||
|
mutable_buffer b(*iter);
|
||||||
|
std::size_t i = static_cast<std::size_t>(index);
|
||||||
|
buffers_[i] = this->make_buffer(b, &ctx, index);
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
iovecs[i].iov_base = buffers_[i].data();
|
||||||
|
iovecs[i].iov_len = buffers_[i].size();
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
if (n > 0)
|
||||||
|
{
|
||||||
|
service_->register_buffers(&iovecs[0],
|
||||||
|
static_cast<unsigned>(iovecs.size()));
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
}
|
||||||
|
|
||||||
|
MutableBufferSequence buffer_sequence_;
|
||||||
|
std::vector<mutable_registered_buffer,
|
||||||
|
ASIO_REBIND_ALLOC(allocator_type,
|
||||||
|
mutable_registered_buffer)> buffers_;
|
||||||
|
#if defined(ASIO_HAS_IO_URING)
|
||||||
|
detail::io_uring_service* service_;
|
||||||
|
#endif // defined(ASIO_HAS_IO_URING)
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Register buffers with an execution context.
|
||||||
|
template <typename Executor, typename MutableBufferSequence>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
buffer_registration<MutableBufferSequence>
|
||||||
|
register_buffers(const Executor& ex,
|
||||||
|
const MutableBufferSequence& buffer_sequence,
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
{
|
||||||
|
return buffer_registration<MutableBufferSequence>(ex, buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Register buffers with an execution context.
|
||||||
|
template <typename Executor, typename MutableBufferSequence, typename Allocator>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
buffer_registration<MutableBufferSequence, Allocator>
|
||||||
|
register_buffers(const Executor& ex,
|
||||||
|
const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0)
|
||||||
|
{
|
||||||
|
return buffer_registration<MutableBufferSequence, Allocator>(
|
||||||
|
ex, buffer_sequence, alloc);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Register buffers with an execution context.
|
||||||
|
template <typename ExecutionContext, typename MutableBufferSequence>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
buffer_registration<MutableBufferSequence>
|
||||||
|
register_buffers(ExecutionContext& ctx,
|
||||||
|
const MutableBufferSequence& buffer_sequence,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
{
|
||||||
|
return buffer_registration<MutableBufferSequence>(ctx, buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Register buffers with an execution context.
|
||||||
|
template <typename ExecutionContext,
|
||||||
|
typename MutableBufferSequence, typename Allocator>
|
||||||
|
ASIO_NODISCARD inline
|
||||||
|
buffer_registration<MutableBufferSequence, Allocator>
|
||||||
|
register_buffers(ExecutionContext& ctx,
|
||||||
|
const MutableBufferSequence& buffer_sequence, const Allocator& alloc,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0)
|
||||||
|
{
|
||||||
|
return buffer_registration<MutableBufferSequence, Allocator>(
|
||||||
|
ctx, buffer_sequence, alloc);
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_HAS_MOVE) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFER_REGISTRATION_HPP
|
||||||
|
|
@ -0,0 +1,265 @@
|
||||||
|
//
|
||||||
|
// buffered_read_stream.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_READ_STREAM_HPP
|
||||||
|
#define ASIO_BUFFERED_READ_STREAM_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/buffered_read_stream_fwd.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/buffer_resize_guard.hpp"
|
||||||
|
#include "asio/detail/buffered_stream_storage.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Adds buffering to the read-related operations of a stream.
|
||||||
|
/**
|
||||||
|
* The buffered_read_stream class template can be used to add buffering to the
|
||||||
|
* synchronous and asynchronous read operations of a stream.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Concepts:
|
||||||
|
* AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
|
||||||
|
*/
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_read_stream
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the next layer.
|
||||||
|
typedef typename remove_reference<Stream>::type next_layer_type;
|
||||||
|
|
||||||
|
/// The type of the lowest layer.
|
||||||
|
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
|
||||||
|
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef typename lowest_layer_type::executor_type executor_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The default buffer size.
|
||||||
|
static const std::size_t default_buffer_size = implementation_defined;
|
||||||
|
#else
|
||||||
|
ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
explicit buffered_read_stream(Arg& a)
|
||||||
|
: next_layer_(a),
|
||||||
|
storage_(default_buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
buffered_read_stream(Arg& a, std::size_t buffer_size)
|
||||||
|
: next_layer_(a),
|
||||||
|
storage_(buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the next layer.
|
||||||
|
next_layer_type& next_layer()
|
||||||
|
{
|
||||||
|
return next_layer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer().get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
next_layer_.close();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
next_layer_.close(ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return next_layer_.write_some(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written,
|
||||||
|
/// or 0 if an error occurred.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return next_layer_.write_some(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write. The data being written must be valid for the
|
||||||
|
/// lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return next_layer_.async_write_some(buffers,
|
||||||
|
ASIO_MOVE_CAST(WriteHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fill the buffer with some data. Returns the number of bytes placed in the
|
||||||
|
/// buffer as a result of the operation. Throws an exception on failure.
|
||||||
|
std::size_t fill();
|
||||||
|
|
||||||
|
/// Fill the buffer with some data. Returns the number of bytes placed in the
|
||||||
|
/// buffer as a result of the operation, or 0 if an error occurred.
|
||||||
|
std::size_t fill(asio::error_code& ec);
|
||||||
|
|
||||||
|
/// Start an asynchronous fill.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_fill(
|
||||||
|
ASIO_MOVE_ARG(ReadHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type));
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read. Throws
|
||||||
|
/// an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers);
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read or 0 if
|
||||||
|
/// an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
/// Start an asynchronous read. The buffer into which the data will be read
|
||||||
|
/// must be valid for the lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type));
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers);
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read,
|
||||||
|
/// or 0 if an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail()
|
||||||
|
{
|
||||||
|
return storage_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
ec = asio::error_code();
|
||||||
|
return storage_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
/// Copy data out of the internal buffer to the specified target buffer.
|
||||||
|
/// Returns the number of bytes copied.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t copy(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
std::size_t bytes_copied = asio::buffer_copy(
|
||||||
|
buffers, storage_.data(), storage_.size());
|
||||||
|
storage_.consume(bytes_copied);
|
||||||
|
return bytes_copied;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy data from the internal buffer to the specified target buffer, without
|
||||||
|
/// removing the data from the internal buffer. Returns the number of bytes
|
||||||
|
/// copied.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek_copy(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return asio::buffer_copy(buffers, storage_.data(), storage_.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
/// The next layer.
|
||||||
|
Stream next_layer_;
|
||||||
|
|
||||||
|
// The data in the buffer.
|
||||||
|
detail::buffered_stream_storage storage_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/buffered_read_stream.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_READ_STREAM_HPP
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
//
|
||||||
|
// buffered_read_stream_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_READ_STREAM_FWD_HPP
|
||||||
|
#define ASIO_BUFFERED_READ_STREAM_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_read_stream;
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_READ_STREAM_FWD_HPP
|
||||||
|
|
@ -0,0 +1,295 @@
|
||||||
|
//
|
||||||
|
// buffered_stream.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_STREAM_HPP
|
||||||
|
#define ASIO_BUFFERED_STREAM_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/buffered_read_stream.hpp"
|
||||||
|
#include "asio/buffered_write_stream.hpp"
|
||||||
|
#include "asio/buffered_stream_fwd.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Adds buffering to the read- and write-related operations of a stream.
|
||||||
|
/**
|
||||||
|
* The buffered_stream class template can be used to add buffering to the
|
||||||
|
* synchronous and asynchronous read and write operations of a stream.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Concepts:
|
||||||
|
* AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
|
||||||
|
*/
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_stream
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the next layer.
|
||||||
|
typedef typename remove_reference<Stream>::type next_layer_type;
|
||||||
|
|
||||||
|
/// The type of the lowest layer.
|
||||||
|
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
|
||||||
|
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef typename lowest_layer_type::executor_type executor_type;
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
explicit buffered_stream(Arg& a)
|
||||||
|
: inner_stream_impl_(a),
|
||||||
|
stream_impl_(inner_stream_impl_)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
explicit buffered_stream(Arg& a, std::size_t read_buffer_size,
|
||||||
|
std::size_t write_buffer_size)
|
||||||
|
: inner_stream_impl_(a, write_buffer_size),
|
||||||
|
stream_impl_(inner_stream_impl_, read_buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the next layer.
|
||||||
|
next_layer_type& next_layer()
|
||||||
|
{
|
||||||
|
return stream_impl_.next_layer().next_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return stream_impl_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return stream_impl_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return stream_impl_.lowest_layer().get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
stream_impl_.close();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
stream_impl_.close(ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Flush all data from the buffer to the next layer. Returns the number of
|
||||||
|
/// bytes written to the next layer on the last write operation. Throws an
|
||||||
|
/// exception on failure.
|
||||||
|
std::size_t flush()
|
||||||
|
{
|
||||||
|
return stream_impl_.next_layer().flush();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Flush all data from the buffer to the next layer. Returns the number of
|
||||||
|
/// bytes written to the next layer on the last write operation, or 0 if an
|
||||||
|
/// error occurred.
|
||||||
|
std::size_t flush(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.next_layer().flush(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous flush.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_flush(
|
||||||
|
ASIO_MOVE_ARG(WriteHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return stream_impl_.next_layer().async_flush(
|
||||||
|
ASIO_MOVE_CAST(WriteHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return stream_impl_.write_some(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written,
|
||||||
|
/// or 0 if an error occurred.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.write_some(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous write. The data being written must be valid for the
|
||||||
|
/// lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return stream_impl_.async_write_some(buffers,
|
||||||
|
ASIO_MOVE_CAST(WriteHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fill the buffer with some data. Returns the number of bytes placed in the
|
||||||
|
/// buffer as a result of the operation. Throws an exception on failure.
|
||||||
|
std::size_t fill()
|
||||||
|
{
|
||||||
|
return stream_impl_.fill();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Fill the buffer with some data. Returns the number of bytes placed in the
|
||||||
|
/// buffer as a result of the operation, or 0 if an error occurred.
|
||||||
|
std::size_t fill(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.fill(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous fill.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_fill(
|
||||||
|
ASIO_MOVE_ARG(ReadHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return stream_impl_.async_fill(ASIO_MOVE_CAST(ReadHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read. Throws
|
||||||
|
/// an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return stream_impl_.read_some(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read or 0 if
|
||||||
|
/// an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.read_some(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read. The buffer into which the data will be read
|
||||||
|
/// must be valid for the lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return stream_impl_.async_read_some(buffers,
|
||||||
|
ASIO_MOVE_CAST(ReadHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return stream_impl_.peek(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read,
|
||||||
|
/// or 0 if an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.peek(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail()
|
||||||
|
{
|
||||||
|
return stream_impl_.in_avail();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return stream_impl_.in_avail(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// The buffered write stream.
|
||||||
|
typedef buffered_write_stream<Stream> write_stream_type;
|
||||||
|
write_stream_type inner_stream_impl_;
|
||||||
|
|
||||||
|
// The buffered read stream.
|
||||||
|
typedef buffered_read_stream<write_stream_type&> read_stream_type;
|
||||||
|
read_stream_type stream_impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_STREAM_HPP
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
//
|
||||||
|
// buffered_stream_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_STREAM_FWD_HPP
|
||||||
|
#define ASIO_BUFFERED_STREAM_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_stream;
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_STREAM_FWD_HPP
|
||||||
|
|
@ -0,0 +1,257 @@
|
||||||
|
//
|
||||||
|
// buffered_write_stream.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_WRITE_STREAM_HPP
|
||||||
|
#define ASIO_BUFFERED_WRITE_STREAM_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/buffered_write_stream_fwd.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/completion_condition.hpp"
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/buffered_stream_storage.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/write.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Adds buffering to the write-related operations of a stream.
|
||||||
|
/**
|
||||||
|
* The buffered_write_stream class template can be used to add buffering to the
|
||||||
|
* synchronous and asynchronous write operations of a stream.
|
||||||
|
*
|
||||||
|
* @par Thread Safety
|
||||||
|
* @e Distinct @e objects: Safe.@n
|
||||||
|
* @e Shared @e objects: Unsafe.
|
||||||
|
*
|
||||||
|
* @par Concepts:
|
||||||
|
* AsyncReadStream, AsyncWriteStream, Stream, SyncReadStream, SyncWriteStream.
|
||||||
|
*/
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_write_stream
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// The type of the next layer.
|
||||||
|
typedef typename remove_reference<Stream>::type next_layer_type;
|
||||||
|
|
||||||
|
/// The type of the lowest layer.
|
||||||
|
typedef typename next_layer_type::lowest_layer_type lowest_layer_type;
|
||||||
|
|
||||||
|
/// The type of the executor associated with the object.
|
||||||
|
typedef typename lowest_layer_type::executor_type executor_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The default buffer size.
|
||||||
|
static const std::size_t default_buffer_size = implementation_defined;
|
||||||
|
#else
|
||||||
|
ASIO_STATIC_CONSTANT(std::size_t, default_buffer_size = 1024);
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
explicit buffered_write_stream(Arg& a)
|
||||||
|
: next_layer_(a),
|
||||||
|
storage_(default_buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct, passing the specified argument to initialise the next layer.
|
||||||
|
template <typename Arg>
|
||||||
|
buffered_write_stream(Arg& a, std::size_t buffer_size)
|
||||||
|
: next_layer_(a),
|
||||||
|
storage_(buffer_size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the next layer.
|
||||||
|
next_layer_type& next_layer()
|
||||||
|
{
|
||||||
|
return next_layer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a reference to the lowest layer.
|
||||||
|
lowest_layer_type& lowest_layer()
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get a const reference to the lowest layer.
|
||||||
|
const lowest_layer_type& lowest_layer() const
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Get the executor associated with the object.
|
||||||
|
executor_type get_executor() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return next_layer_.lowest_layer().get_executor();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
void close()
|
||||||
|
{
|
||||||
|
next_layer_.close();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Close the stream.
|
||||||
|
ASIO_SYNC_OP_VOID close(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
next_layer_.close(ec);
|
||||||
|
ASIO_SYNC_OP_VOID_RETURN(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Flush all data from the buffer to the next layer. Returns the number of
|
||||||
|
/// bytes written to the next layer on the last write operation. Throws an
|
||||||
|
/// exception on failure.
|
||||||
|
std::size_t flush();
|
||||||
|
|
||||||
|
/// Flush all data from the buffer to the next layer. Returns the number of
|
||||||
|
/// bytes written to the next layer on the last write operation, or 0 if an
|
||||||
|
/// error occurred.
|
||||||
|
std::size_t flush(asio::error_code& ec);
|
||||||
|
|
||||||
|
/// Start an asynchronous flush.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_flush(
|
||||||
|
ASIO_MOVE_ARG(WriteHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type));
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers);
|
||||||
|
|
||||||
|
/// Write the given data to the stream. Returns the number of bytes written,
|
||||||
|
/// or 0 if an error occurred and the error handler did not throw.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t write_some(const ConstBufferSequence& buffers,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
/// Start an asynchronous write. The data being written must be valid for the
|
||||||
|
/// lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename ConstBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) WriteHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_write_some(const ConstBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(WriteHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type));
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read. Throws
|
||||||
|
/// an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return next_layer_.read_some(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Read some data from the stream. Returns the number of bytes read or 0 if
|
||||||
|
/// an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t read_some(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return next_layer_.read_some(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Start an asynchronous read. The buffer into which the data will be read
|
||||||
|
/// must be valid for the lifetime of the asynchronous operation.
|
||||||
|
/**
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(asio::error_code, std::size_t) @endcode
|
||||||
|
*/
|
||||||
|
template <typename MutableBufferSequence,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code,
|
||||||
|
std::size_t)) ReadHandler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(ReadHandler,
|
||||||
|
void (asio::error_code, std::size_t))
|
||||||
|
async_read_some(const MutableBufferSequence& buffers,
|
||||||
|
ASIO_MOVE_ARG(ReadHandler) handler
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(executor_type))
|
||||||
|
{
|
||||||
|
return next_layer_.async_read_some(buffers,
|
||||||
|
ASIO_MOVE_CAST(ReadHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read.
|
||||||
|
/// Throws an exception on failure.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return next_layer_.peek(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Peek at the incoming data on the stream. Returns the number of bytes read,
|
||||||
|
/// or 0 if an error occurred.
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
std::size_t peek(const MutableBufferSequence& buffers,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return next_layer_.peek(buffers, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail()
|
||||||
|
{
|
||||||
|
return next_layer_.in_avail();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Determine the amount of data that may be read without blocking.
|
||||||
|
std::size_t in_avail(asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return next_layer_.in_avail(ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
/// Copy data into the internal buffer from the specified source buffer.
|
||||||
|
/// Returns the number of bytes copied.
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
std::size_t copy(const ConstBufferSequence& buffers);
|
||||||
|
|
||||||
|
/// The next layer.
|
||||||
|
Stream next_layer_;
|
||||||
|
|
||||||
|
// The data in the buffer.
|
||||||
|
detail::buffered_stream_storage storage_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/buffered_write_stream.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_WRITE_STREAM_HPP
|
||||||
|
|
@ -0,0 +1,25 @@
|
||||||
|
//
|
||||||
|
// buffered_write_stream_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
|
||||||
|
#define ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
template <typename Stream>
|
||||||
|
class buffered_write_stream;
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERED_WRITE_STREAM_FWD_HPP
|
||||||
|
|
@ -0,0 +1,521 @@
|
||||||
|
//
|
||||||
|
// buffers_iterator.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_BUFFERS_ITERATOR_HPP
|
||||||
|
#define ASIO_BUFFERS_ITERATOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include <iterator>
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/assert.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
namespace detail
|
||||||
|
{
|
||||||
|
template <bool IsMutable>
|
||||||
|
struct buffers_iterator_types_helper;
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct buffers_iterator_types_helper<false>
|
||||||
|
{
|
||||||
|
typedef const_buffer buffer_type;
|
||||||
|
template <typename ByteType>
|
||||||
|
struct byte_type
|
||||||
|
{
|
||||||
|
typedef typename add_const<ByteType>::type type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
struct buffers_iterator_types_helper<true>
|
||||||
|
{
|
||||||
|
typedef mutable_buffer buffer_type;
|
||||||
|
template <typename ByteType>
|
||||||
|
struct byte_type
|
||||||
|
{
|
||||||
|
typedef ByteType type;
|
||||||
|
};
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename BufferSequence, typename ByteType>
|
||||||
|
struct buffers_iterator_types
|
||||||
|
{
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
is_mutable = is_convertible<
|
||||||
|
typename BufferSequence::value_type,
|
||||||
|
mutable_buffer>::value
|
||||||
|
};
|
||||||
|
typedef buffers_iterator_types_helper<is_mutable> helper;
|
||||||
|
typedef typename helper::buffer_type buffer_type;
|
||||||
|
typedef typename helper::template byte_type<ByteType>::type byte_type;
|
||||||
|
typedef typename BufferSequence::const_iterator const_iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename ByteType>
|
||||||
|
struct buffers_iterator_types<mutable_buffer, ByteType>
|
||||||
|
{
|
||||||
|
typedef mutable_buffer buffer_type;
|
||||||
|
typedef ByteType byte_type;
|
||||||
|
typedef const mutable_buffer* const_iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename ByteType>
|
||||||
|
struct buffers_iterator_types<const_buffer, ByteType>
|
||||||
|
{
|
||||||
|
typedef const_buffer buffer_type;
|
||||||
|
typedef typename add_const<ByteType>::type byte_type;
|
||||||
|
typedef const const_buffer* const_iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
template <typename ByteType>
|
||||||
|
struct buffers_iterator_types<mutable_buffers_1, ByteType>
|
||||||
|
{
|
||||||
|
typedef mutable_buffer buffer_type;
|
||||||
|
typedef ByteType byte_type;
|
||||||
|
typedef const mutable_buffer* const_iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename ByteType>
|
||||||
|
struct buffers_iterator_types<const_buffers_1, ByteType>
|
||||||
|
{
|
||||||
|
typedef const_buffer buffer_type;
|
||||||
|
typedef typename add_const<ByteType>::type byte_type;
|
||||||
|
typedef const const_buffer* const_iterator;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A random access iterator over the bytes in a buffer sequence.
|
||||||
|
template <typename BufferSequence, typename ByteType = char>
|
||||||
|
class buffers_iterator
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
typedef typename detail::buffers_iterator_types<
|
||||||
|
BufferSequence, ByteType>::buffer_type buffer_type;
|
||||||
|
|
||||||
|
typedef typename detail::buffers_iterator_types<BufferSequence,
|
||||||
|
ByteType>::const_iterator buffer_sequence_iterator_type;
|
||||||
|
|
||||||
|
public:
|
||||||
|
/// The type used for the distance between two iterators.
|
||||||
|
typedef std::ptrdiff_t difference_type;
|
||||||
|
|
||||||
|
/// The type of the value pointed to by the iterator.
|
||||||
|
typedef ByteType value_type;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The type of the result of applying operator->() to the iterator.
|
||||||
|
/**
|
||||||
|
* If the buffer sequence stores buffer objects that are convertible to
|
||||||
|
* mutable_buffer, this is a pointer to a non-const ByteType. Otherwise, a
|
||||||
|
* pointer to a const ByteType.
|
||||||
|
*/
|
||||||
|
typedef const_or_non_const_ByteType* pointer;
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef typename detail::buffers_iterator_types<
|
||||||
|
BufferSequence, ByteType>::byte_type* pointer;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// The type of the result of applying operator*() to the iterator.
|
||||||
|
/**
|
||||||
|
* If the buffer sequence stores buffer objects that are convertible to
|
||||||
|
* mutable_buffer, this is a reference to a non-const ByteType. Otherwise, a
|
||||||
|
* reference to a const ByteType.
|
||||||
|
*/
|
||||||
|
typedef const_or_non_const_ByteType& reference;
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
typedef typename detail::buffers_iterator_types<
|
||||||
|
BufferSequence, ByteType>::byte_type& reference;
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// The iterator category.
|
||||||
|
typedef std::random_access_iterator_tag iterator_category;
|
||||||
|
|
||||||
|
/// Default constructor. Creates an iterator in an undefined state.
|
||||||
|
buffers_iterator()
|
||||||
|
: current_buffer_(),
|
||||||
|
current_buffer_position_(0),
|
||||||
|
begin_(),
|
||||||
|
current_(),
|
||||||
|
end_(),
|
||||||
|
position_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct an iterator representing the beginning of the buffers' data.
|
||||||
|
static buffers_iterator begin(const BufferSequence& buffers)
|
||||||
|
#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
|
||||||
|
__attribute__ ((__noinline__))
|
||||||
|
#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
|
||||||
|
{
|
||||||
|
buffers_iterator new_iter;
|
||||||
|
new_iter.begin_ = asio::buffer_sequence_begin(buffers);
|
||||||
|
new_iter.current_ = asio::buffer_sequence_begin(buffers);
|
||||||
|
new_iter.end_ = asio::buffer_sequence_end(buffers);
|
||||||
|
while (new_iter.current_ != new_iter.end_)
|
||||||
|
{
|
||||||
|
new_iter.current_buffer_ = *new_iter.current_;
|
||||||
|
if (new_iter.current_buffer_.size() > 0)
|
||||||
|
break;
|
||||||
|
++new_iter.current_;
|
||||||
|
}
|
||||||
|
return new_iter;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct an iterator representing the end of the buffers' data.
|
||||||
|
static buffers_iterator end(const BufferSequence& buffers)
|
||||||
|
#if defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
|
||||||
|
__attribute__ ((__noinline__))
|
||||||
|
#endif // defined(__GNUC__) && (__GNUC__ == 4) && (__GNUC_MINOR__ == 3)
|
||||||
|
{
|
||||||
|
buffers_iterator new_iter;
|
||||||
|
new_iter.begin_ = asio::buffer_sequence_begin(buffers);
|
||||||
|
new_iter.current_ = asio::buffer_sequence_begin(buffers);
|
||||||
|
new_iter.end_ = asio::buffer_sequence_end(buffers);
|
||||||
|
while (new_iter.current_ != new_iter.end_)
|
||||||
|
{
|
||||||
|
buffer_type buffer = *new_iter.current_;
|
||||||
|
new_iter.position_ += buffer.size();
|
||||||
|
++new_iter.current_;
|
||||||
|
}
|
||||||
|
return new_iter;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Dereference an iterator.
|
||||||
|
reference operator*() const
|
||||||
|
{
|
||||||
|
return dereference();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Dereference an iterator.
|
||||||
|
pointer operator->() const
|
||||||
|
{
|
||||||
|
return &dereference();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Access an individual element.
|
||||||
|
reference operator[](std::ptrdiff_t difference) const
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(*this);
|
||||||
|
tmp.advance(difference);
|
||||||
|
return *tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Increment operator (prefix).
|
||||||
|
buffers_iterator& operator++()
|
||||||
|
{
|
||||||
|
increment();
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Increment operator (postfix).
|
||||||
|
buffers_iterator operator++(int)
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(*this);
|
||||||
|
++*this;
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decrement operator (prefix).
|
||||||
|
buffers_iterator& operator--()
|
||||||
|
{
|
||||||
|
decrement();
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Decrement operator (postfix).
|
||||||
|
buffers_iterator operator--(int)
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(*this);
|
||||||
|
--*this;
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Addition operator.
|
||||||
|
buffers_iterator& operator+=(std::ptrdiff_t difference)
|
||||||
|
{
|
||||||
|
advance(difference);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Subtraction operator.
|
||||||
|
buffers_iterator& operator-=(std::ptrdiff_t difference)
|
||||||
|
{
|
||||||
|
advance(-difference);
|
||||||
|
return *this;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Addition operator.
|
||||||
|
friend buffers_iterator operator+(const buffers_iterator& iter,
|
||||||
|
std::ptrdiff_t difference)
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(iter);
|
||||||
|
tmp.advance(difference);
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Addition operator.
|
||||||
|
friend buffers_iterator operator+(std::ptrdiff_t difference,
|
||||||
|
const buffers_iterator& iter)
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(iter);
|
||||||
|
tmp.advance(difference);
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Subtraction operator.
|
||||||
|
friend buffers_iterator operator-(const buffers_iterator& iter,
|
||||||
|
std::ptrdiff_t difference)
|
||||||
|
{
|
||||||
|
buffers_iterator tmp(iter);
|
||||||
|
tmp.advance(-difference);
|
||||||
|
return tmp;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Subtraction operator.
|
||||||
|
friend std::ptrdiff_t operator-(const buffers_iterator& a,
|
||||||
|
const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return b.distance_to(a);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Test two iterators for equality.
|
||||||
|
friend bool operator==(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return a.equal(b);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Test two iterators for inequality.
|
||||||
|
friend bool operator!=(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return !a.equal(b);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two iterators.
|
||||||
|
friend bool operator<(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return a.distance_to(b) > 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two iterators.
|
||||||
|
friend bool operator<=(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return !(b < a);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two iterators.
|
||||||
|
friend bool operator>(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return b < a;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two iterators.
|
||||||
|
friend bool operator>=(const buffers_iterator& a, const buffers_iterator& b)
|
||||||
|
{
|
||||||
|
return !(a < b);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Dereference the iterator.
|
||||||
|
reference dereference() const
|
||||||
|
{
|
||||||
|
return static_cast<pointer>(
|
||||||
|
current_buffer_.data())[current_buffer_position_];
|
||||||
|
}
|
||||||
|
|
||||||
|
// Compare two iterators for equality.
|
||||||
|
bool equal(const buffers_iterator& other) const
|
||||||
|
{
|
||||||
|
return position_ == other.position_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Increment the iterator.
|
||||||
|
void increment()
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
|
||||||
|
++position_;
|
||||||
|
|
||||||
|
// Check if the increment can be satisfied by the current buffer.
|
||||||
|
++current_buffer_position_;
|
||||||
|
if (current_buffer_position_ != current_buffer_.size())
|
||||||
|
return;
|
||||||
|
|
||||||
|
// Find the next non-empty buffer.
|
||||||
|
++current_;
|
||||||
|
current_buffer_position_ = 0;
|
||||||
|
while (current_ != end_)
|
||||||
|
{
|
||||||
|
current_buffer_ = *current_;
|
||||||
|
if (current_buffer_.size() > 0)
|
||||||
|
return;
|
||||||
|
++current_;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Decrement the iterator.
|
||||||
|
void decrement()
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(position_ > 0 && "iterator out of bounds");
|
||||||
|
--position_;
|
||||||
|
|
||||||
|
// Check if the decrement can be satisfied by the current buffer.
|
||||||
|
if (current_buffer_position_ != 0)
|
||||||
|
{
|
||||||
|
--current_buffer_position_;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the previous non-empty buffer.
|
||||||
|
buffer_sequence_iterator_type iter = current_;
|
||||||
|
while (iter != begin_)
|
||||||
|
{
|
||||||
|
--iter;
|
||||||
|
buffer_type buffer = *iter;
|
||||||
|
std::size_t buffer_size = buffer.size();
|
||||||
|
if (buffer_size > 0)
|
||||||
|
{
|
||||||
|
current_ = iter;
|
||||||
|
current_buffer_ = buffer;
|
||||||
|
current_buffer_position_ = buffer_size - 1;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Advance the iterator by the specified distance.
|
||||||
|
void advance(std::ptrdiff_t n)
|
||||||
|
{
|
||||||
|
if (n > 0)
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(current_ != end_ && "iterator out of bounds");
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
std::ptrdiff_t current_buffer_balance
|
||||||
|
= current_buffer_.size() - current_buffer_position_;
|
||||||
|
|
||||||
|
// Check if the advance can be satisfied by the current buffer.
|
||||||
|
if (current_buffer_balance > n)
|
||||||
|
{
|
||||||
|
position_ += n;
|
||||||
|
current_buffer_position_ += n;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update position.
|
||||||
|
n -= current_buffer_balance;
|
||||||
|
position_ += current_buffer_balance;
|
||||||
|
|
||||||
|
// Move to next buffer. If it is empty then it will be skipped on the
|
||||||
|
// next iteration of this loop.
|
||||||
|
if (++current_ == end_)
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(n == 0 && "iterator out of bounds");
|
||||||
|
current_buffer_ = buffer_type();
|
||||||
|
current_buffer_position_ = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
current_buffer_ = *current_;
|
||||||
|
current_buffer_position_ = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else if (n < 0)
|
||||||
|
{
|
||||||
|
std::size_t abs_n = -n;
|
||||||
|
ASIO_ASSERT(position_ >= abs_n && "iterator out of bounds");
|
||||||
|
for (;;)
|
||||||
|
{
|
||||||
|
// Check if the advance can be satisfied by the current buffer.
|
||||||
|
if (current_buffer_position_ >= abs_n)
|
||||||
|
{
|
||||||
|
position_ -= abs_n;
|
||||||
|
current_buffer_position_ -= abs_n;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update position.
|
||||||
|
abs_n -= current_buffer_position_;
|
||||||
|
position_ -= current_buffer_position_;
|
||||||
|
|
||||||
|
// Check if we've reached the beginning of the buffers.
|
||||||
|
if (current_ == begin_)
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(abs_n == 0 && "iterator out of bounds");
|
||||||
|
current_buffer_position_ = 0;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the previous non-empty buffer.
|
||||||
|
buffer_sequence_iterator_type iter = current_;
|
||||||
|
while (iter != begin_)
|
||||||
|
{
|
||||||
|
--iter;
|
||||||
|
buffer_type buffer = *iter;
|
||||||
|
std::size_t buffer_size = buffer.size();
|
||||||
|
if (buffer_size > 0)
|
||||||
|
{
|
||||||
|
current_ = iter;
|
||||||
|
current_buffer_ = buffer;
|
||||||
|
current_buffer_position_ = buffer_size;
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine the distance between two iterators.
|
||||||
|
std::ptrdiff_t distance_to(const buffers_iterator& other) const
|
||||||
|
{
|
||||||
|
return other.position_ - position_;
|
||||||
|
}
|
||||||
|
|
||||||
|
buffer_type current_buffer_;
|
||||||
|
std::size_t current_buffer_position_;
|
||||||
|
buffer_sequence_iterator_type begin_;
|
||||||
|
buffer_sequence_iterator_type current_;
|
||||||
|
buffer_sequence_iterator_type end_;
|
||||||
|
std::size_t position_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Construct an iterator representing the beginning of the buffers' data.
|
||||||
|
template <typename BufferSequence>
|
||||||
|
inline buffers_iterator<BufferSequence> buffers_begin(
|
||||||
|
const BufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return buffers_iterator<BufferSequence>::begin(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct an iterator representing the end of the buffers' data.
|
||||||
|
template <typename BufferSequence>
|
||||||
|
inline buffers_iterator<BufferSequence> buffers_end(
|
||||||
|
const BufferSequence& buffers)
|
||||||
|
{
|
||||||
|
return buffers_iterator<BufferSequence>::end(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_BUFFERS_ITERATOR_HPP
|
||||||
|
|
@ -0,0 +1,305 @@
|
||||||
|
//
|
||||||
|
// cancellation_signal.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_CANCELLATION_SIGNAL_HPP
|
||||||
|
#define ASIO_CANCELLATION_SIGNAL_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cassert>
|
||||||
|
#include <new>
|
||||||
|
#include <utility>
|
||||||
|
#include "asio/cancellation_type.hpp"
|
||||||
|
#include "asio/detail/cstddef.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/detail/variadic_templates.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class cancellation_handler_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
virtual void call(cancellation_type_t) = 0;
|
||||||
|
virtual std::pair<void*, std::size_t> destroy() ASIO_NOEXCEPT = 0;
|
||||||
|
|
||||||
|
protected:
|
||||||
|
~cancellation_handler_base() {}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
class cancellation_handler
|
||||||
|
: public cancellation_handler_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
template <typename... Args>
|
||||||
|
cancellation_handler(std::size_t size, ASIO_MOVE_ARG(Args)... args)
|
||||||
|
: handler_(ASIO_MOVE_CAST(Args)(args)...),
|
||||||
|
size_(size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
cancellation_handler(std::size_t size)
|
||||||
|
: handler_(),
|
||||||
|
size_(size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_HANDLER_CTOR_DEF(n) \
|
||||||
|
template <ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
cancellation_handler(std::size_t size, ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
: handler_(ASIO_VARIADIC_MOVE_ARGS(n)), \
|
||||||
|
size_(size) \
|
||||||
|
{ \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_HANDLER_CTOR_DEF)
|
||||||
|
#undef ASIO_PRIVATE_HANDLER_CTOR_DEF
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
void call(cancellation_type_t type)
|
||||||
|
{
|
||||||
|
handler_(type);
|
||||||
|
}
|
||||||
|
|
||||||
|
std::pair<void*, std::size_t> destroy() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
std::pair<void*, std::size_t> mem(this, size_);
|
||||||
|
this->cancellation_handler::~cancellation_handler();
|
||||||
|
return mem;
|
||||||
|
}
|
||||||
|
|
||||||
|
Handler& handler() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return handler_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
~cancellation_handler()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
Handler handler_;
|
||||||
|
std::size_t size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
class cancellation_slot;
|
||||||
|
|
||||||
|
/// A cancellation signal with a single slot.
|
||||||
|
class cancellation_signal
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_CONSTEXPR cancellation_signal()
|
||||||
|
: handler_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_DECL ~cancellation_signal();
|
||||||
|
|
||||||
|
/// Emits the signal and causes invocation of the slot's handler, if any.
|
||||||
|
void emit(cancellation_type_t type)
|
||||||
|
{
|
||||||
|
if (handler_)
|
||||||
|
handler_->call(type);
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the single slot associated with the signal.
|
||||||
|
/**
|
||||||
|
* The signal object must remain valid for as long the slot may be used.
|
||||||
|
* Destruction of the signal invalidates the slot.
|
||||||
|
*/
|
||||||
|
cancellation_slot slot() ASIO_NOEXCEPT;
|
||||||
|
|
||||||
|
private:
|
||||||
|
cancellation_signal(const cancellation_signal&) ASIO_DELETED;
|
||||||
|
cancellation_signal& operator=(const cancellation_signal&) ASIO_DELETED;
|
||||||
|
|
||||||
|
detail::cancellation_handler_base* handler_;
|
||||||
|
};
|
||||||
|
|
||||||
|
/// A slot associated with a cancellation signal.
|
||||||
|
class cancellation_slot
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// Creates a slot that is not connected to any cancellation signal.
|
||||||
|
ASIO_CONSTEXPR cancellation_slot()
|
||||||
|
: handler_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
/// Installs a handler into the slot, constructing the new object directly.
|
||||||
|
/**
|
||||||
|
* Destroys any existing handler in the slot, then installs the new handler,
|
||||||
|
* constructing it with the supplied @c args.
|
||||||
|
*
|
||||||
|
* The handler is a function object to be called when the signal is emitted.
|
||||||
|
* The signature of the handler must be
|
||||||
|
* @code void handler(asio::cancellation_type_t); @endcode
|
||||||
|
*
|
||||||
|
* @param args Arguments to be passed to the @c CancellationHandler object's
|
||||||
|
* constructor.
|
||||||
|
*
|
||||||
|
* @returns A reference to the newly installed handler.
|
||||||
|
*
|
||||||
|
* @note Handlers installed into the slot via @c emplace are not required to
|
||||||
|
* be copy constructible or move constructible.
|
||||||
|
*/
|
||||||
|
template <typename CancellationHandler, typename... Args>
|
||||||
|
CancellationHandler& emplace(ASIO_MOVE_ARG(Args)... args)
|
||||||
|
{
|
||||||
|
typedef detail::cancellation_handler<CancellationHandler>
|
||||||
|
cancellation_handler_type;
|
||||||
|
auto_delete_helper del = { prepare_memory(
|
||||||
|
sizeof(cancellation_handler_type),
|
||||||
|
ASIO_ALIGNOF(CancellationHandler)) };
|
||||||
|
cancellation_handler_type* handler_obj =
|
||||||
|
new (del.mem.first) cancellation_handler_type(
|
||||||
|
del.mem.second, ASIO_MOVE_CAST(Args)(args)...);
|
||||||
|
del.mem.first = 0;
|
||||||
|
*handler_ = handler_obj;
|
||||||
|
return handler_obj->handler();
|
||||||
|
}
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename CancellationHandler>
|
||||||
|
CancellationHandler& emplace()
|
||||||
|
{
|
||||||
|
typedef detail::cancellation_handler<CancellationHandler>
|
||||||
|
cancellation_handler_type;
|
||||||
|
auto_delete_helper del = { prepare_memory(
|
||||||
|
sizeof(cancellation_handler_type),
|
||||||
|
ASIO_ALIGNOF(CancellationHandler)) };
|
||||||
|
cancellation_handler_type* handler_obj =
|
||||||
|
new (del.mem.first) cancellation_handler_type(del.mem.second);
|
||||||
|
del.mem.first = 0;
|
||||||
|
*handler_ = handler_obj;
|
||||||
|
return handler_obj->handler();
|
||||||
|
}
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_HANDLER_EMPLACE_DEF(n) \
|
||||||
|
template <typename CancellationHandler, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
CancellationHandler& emplace(ASIO_VARIADIC_MOVE_PARAMS(n)) \
|
||||||
|
{ \
|
||||||
|
typedef detail::cancellation_handler<CancellationHandler> \
|
||||||
|
cancellation_handler_type; \
|
||||||
|
auto_delete_helper del = { prepare_memory( \
|
||||||
|
sizeof(cancellation_handler_type), \
|
||||||
|
ASIO_ALIGNOF(CancellationHandler)) }; \
|
||||||
|
cancellation_handler_type* handler_obj = \
|
||||||
|
new (del.mem.first) cancellation_handler_type( \
|
||||||
|
del.mem.second, ASIO_VARIADIC_MOVE_ARGS(n)); \
|
||||||
|
del.mem.first = 0; \
|
||||||
|
*handler_ = handler_obj; \
|
||||||
|
return handler_obj->handler(); \
|
||||||
|
} \
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_HANDLER_EMPLACE_DEF)
|
||||||
|
#undef ASIO_PRIVATE_HANDLER_EMPLACE_DEF
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
|
||||||
|
/// Installs a handler into the slot.
|
||||||
|
/**
|
||||||
|
* Destroys any existing handler in the slot, then installs the new handler,
|
||||||
|
* constructing it as a decay-copy of the supplied handler.
|
||||||
|
*
|
||||||
|
* The handler is a function object to be called when the signal is emitted.
|
||||||
|
* The signature of the handler must be
|
||||||
|
* @code void handler(asio::cancellation_type_t); @endcode
|
||||||
|
*
|
||||||
|
* @param handler The handler to be installed.
|
||||||
|
*
|
||||||
|
* @returns A reference to the newly installed handler.
|
||||||
|
*/
|
||||||
|
template <typename CancellationHandler>
|
||||||
|
typename decay<CancellationHandler>::type& assign(
|
||||||
|
ASIO_MOVE_ARG(CancellationHandler) handler)
|
||||||
|
{
|
||||||
|
return this->emplace<typename decay<CancellationHandler>::type>(
|
||||||
|
ASIO_MOVE_CAST(CancellationHandler)(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Clears the slot.
|
||||||
|
/**
|
||||||
|
* Destroys any existing handler in the slot.
|
||||||
|
*/
|
||||||
|
ASIO_DECL void clear();
|
||||||
|
|
||||||
|
/// Returns whether the slot is connected to a signal.
|
||||||
|
ASIO_CONSTEXPR bool is_connected() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return handler_ != 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns whether the slot is connected and has an installed handler.
|
||||||
|
ASIO_CONSTEXPR bool has_handler() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return handler_ != 0 && *handler_ != 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two slots for equality.
|
||||||
|
friend ASIO_CONSTEXPR bool operator==(const cancellation_slot& lhs,
|
||||||
|
const cancellation_slot& rhs) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return lhs.handler_ == rhs.handler_;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Compare two slots for inequality.
|
||||||
|
friend ASIO_CONSTEXPR bool operator!=(const cancellation_slot& lhs,
|
||||||
|
const cancellation_slot& rhs) ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return lhs.handler_ != rhs.handler_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class cancellation_signal;
|
||||||
|
|
||||||
|
ASIO_CONSTEXPR cancellation_slot(int,
|
||||||
|
detail::cancellation_handler_base** handler)
|
||||||
|
: handler_(handler)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_DECL std::pair<void*, std::size_t> prepare_memory(
|
||||||
|
std::size_t size, std::size_t align);
|
||||||
|
|
||||||
|
struct auto_delete_helper
|
||||||
|
{
|
||||||
|
std::pair<void*, std::size_t> mem;
|
||||||
|
|
||||||
|
ASIO_DECL ~auto_delete_helper();
|
||||||
|
};
|
||||||
|
|
||||||
|
detail::cancellation_handler_base** handler_;
|
||||||
|
};
|
||||||
|
|
||||||
|
inline cancellation_slot cancellation_signal::slot() ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_slot(0, &handler_);
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/impl/cancellation_signal.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // ASIO_CANCELLATION_SIGNAL_HPP
|
||||||
|
|
@ -0,0 +1,235 @@
|
||||||
|
//
|
||||||
|
// cancellation_state.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_CANCELLATION_STATE_HPP
|
||||||
|
#define ASIO_CANCELLATION_STATE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cassert>
|
||||||
|
#include <new>
|
||||||
|
#include <utility>
|
||||||
|
#include "asio/cancellation_signal.hpp"
|
||||||
|
#include "asio/detail/cstddef.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// A simple cancellation signal propagation filter.
|
||||||
|
template <cancellation_type_t Mask>
|
||||||
|
struct cancellation_filter
|
||||||
|
{
|
||||||
|
/// Returns <tt>type & Mask</tt>.
|
||||||
|
cancellation_type_t operator()(
|
||||||
|
cancellation_type_t type) const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return type & Mask;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/// A cancellation filter that disables cancellation.
|
||||||
|
typedef cancellation_filter<cancellation_type::none>
|
||||||
|
disable_cancellation;
|
||||||
|
|
||||||
|
/// A cancellation filter that enables terminal cancellation only.
|
||||||
|
typedef cancellation_filter<cancellation_type::terminal>
|
||||||
|
enable_terminal_cancellation;
|
||||||
|
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// A cancellation filter that enables terminal and partial cancellation.
|
||||||
|
typedef cancellation_filter<
|
||||||
|
cancellation_type::terminal | cancellation_type::partial>
|
||||||
|
enable_partial_cancellation;
|
||||||
|
|
||||||
|
/// A cancellation filter that enables terminal, partial and total cancellation.
|
||||||
|
typedef cancellation_filter<cancellation_type::terminal
|
||||||
|
| cancellation_type::partial | cancellation_type::total>
|
||||||
|
enable_total_cancellation;
|
||||||
|
|
||||||
|
#else // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
typedef cancellation_filter<
|
||||||
|
static_cast<cancellation_type_t>(
|
||||||
|
static_cast<unsigned int>(cancellation_type::terminal)
|
||||||
|
| static_cast<unsigned int>(cancellation_type::partial))>
|
||||||
|
enable_partial_cancellation;
|
||||||
|
|
||||||
|
typedef cancellation_filter<
|
||||||
|
static_cast<cancellation_type_t>(
|
||||||
|
static_cast<unsigned int>(cancellation_type::terminal)
|
||||||
|
| static_cast<unsigned int>(cancellation_type::partial)
|
||||||
|
| static_cast<unsigned int>(cancellation_type::total))>
|
||||||
|
enable_total_cancellation;
|
||||||
|
|
||||||
|
#endif // defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// A cancellation state is used for chaining signals and slots in compositions.
|
||||||
|
class cancellation_state
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// Construct a disconnected cancellation state.
|
||||||
|
ASIO_CONSTEXPR cancellation_state() ASIO_NOEXCEPT
|
||||||
|
: impl_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and attach to a parent slot to create a new child slot.
|
||||||
|
/**
|
||||||
|
* Initialises the cancellation state so that it allows terminal cancellation
|
||||||
|
* only. Equivalent to <tt>cancellation_state(slot,
|
||||||
|
* enable_terminal_cancellation())</tt>.
|
||||||
|
*
|
||||||
|
* @param slot The parent cancellation slot to which the state will be
|
||||||
|
* attached.
|
||||||
|
*/
|
||||||
|
template <typename CancellationSlot>
|
||||||
|
ASIO_CONSTEXPR explicit cancellation_state(CancellationSlot slot)
|
||||||
|
: impl_(slot.is_connected() ? &slot.template emplace<impl<> >() : 0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and attach to a parent slot to create a new child slot.
|
||||||
|
/**
|
||||||
|
* @param slot The parent cancellation slot to which the state will be
|
||||||
|
* attached.
|
||||||
|
*
|
||||||
|
* @param filter A function object that is used to transform incoming
|
||||||
|
* cancellation signals as they are received from the parent slot. This
|
||||||
|
* function object must have the signature:
|
||||||
|
* @code asio::cancellation_type_t filter(
|
||||||
|
* asio::cancellation_type_t); @endcode
|
||||||
|
*
|
||||||
|
* The library provides the following pre-defined cancellation filters:
|
||||||
|
*
|
||||||
|
* @li asio::disable_cancellation
|
||||||
|
* @li asio::enable_terminal_cancellation
|
||||||
|
* @li asio::enable_partial_cancellation
|
||||||
|
* @li asio::enable_total_cancellation
|
||||||
|
*/
|
||||||
|
template <typename CancellationSlot, typename Filter>
|
||||||
|
ASIO_CONSTEXPR cancellation_state(CancellationSlot slot, Filter filter)
|
||||||
|
: impl_(slot.is_connected()
|
||||||
|
? &slot.template emplace<impl<Filter, Filter> >(filter, filter)
|
||||||
|
: 0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Construct and attach to a parent slot to create a new child slot.
|
||||||
|
/**
|
||||||
|
* @param slot The parent cancellation slot to which the state will be
|
||||||
|
* attached.
|
||||||
|
*
|
||||||
|
* @param in_filter A function object that is used to transform incoming
|
||||||
|
* cancellation signals as they are received from the parent slot. This
|
||||||
|
* function object must have the signature:
|
||||||
|
* @code asio::cancellation_type_t in_filter(
|
||||||
|
* asio::cancellation_type_t); @endcode
|
||||||
|
*
|
||||||
|
* @param out_filter A function object that is used to transform outcoming
|
||||||
|
* cancellation signals as they are relayed to the child slot. This function
|
||||||
|
* object must have the signature:
|
||||||
|
* @code asio::cancellation_type_t out_filter(
|
||||||
|
* asio::cancellation_type_t); @endcode
|
||||||
|
*
|
||||||
|
* The library provides the following pre-defined cancellation filters:
|
||||||
|
*
|
||||||
|
* @li asio::disable_cancellation
|
||||||
|
* @li asio::enable_terminal_cancellation
|
||||||
|
* @li asio::enable_partial_cancellation
|
||||||
|
* @li asio::enable_total_cancellation
|
||||||
|
*/
|
||||||
|
template <typename CancellationSlot, typename InFilter, typename OutFilter>
|
||||||
|
ASIO_CONSTEXPR cancellation_state(CancellationSlot slot,
|
||||||
|
InFilter in_filter, OutFilter out_filter)
|
||||||
|
: impl_(slot.is_connected()
|
||||||
|
? &slot.template emplace<impl<InFilter, OutFilter> >(
|
||||||
|
ASIO_MOVE_CAST(InFilter)(in_filter),
|
||||||
|
ASIO_MOVE_CAST(OutFilter)(out_filter))
|
||||||
|
: 0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the single child slot associated with the state.
|
||||||
|
/**
|
||||||
|
* This sub-slot is used with the operations that are being composed.
|
||||||
|
*/
|
||||||
|
ASIO_CONSTEXPR cancellation_slot slot() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_ ? impl_->signal_.slot() : cancellation_slot();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Returns the cancellation types that have been triggered.
|
||||||
|
cancellation_type_t cancelled() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return impl_ ? impl_->cancelled_ : cancellation_type_t();
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Clears the specified cancellation types, if they have been triggered.
|
||||||
|
void clear(cancellation_type_t mask = cancellation_type::all)
|
||||||
|
ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
if (impl_)
|
||||||
|
impl_->cancelled_ &= ~mask;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
struct impl_base
|
||||||
|
{
|
||||||
|
impl_base()
|
||||||
|
: cancelled_()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
cancellation_signal signal_;
|
||||||
|
cancellation_type_t cancelled_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <
|
||||||
|
typename InFilter = enable_terminal_cancellation,
|
||||||
|
typename OutFilter = InFilter>
|
||||||
|
struct impl : impl_base
|
||||||
|
{
|
||||||
|
impl()
|
||||||
|
: in_filter_(),
|
||||||
|
out_filter_()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
impl(InFilter in_filter, OutFilter out_filter)
|
||||||
|
: in_filter_(ASIO_MOVE_CAST(InFilter)(in_filter)),
|
||||||
|
out_filter_(ASIO_MOVE_CAST(OutFilter)(out_filter))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void operator()(cancellation_type_t in)
|
||||||
|
{
|
||||||
|
this->cancelled_ = in_filter_(in);
|
||||||
|
cancellation_type_t out = out_filter_(this->cancelled_);
|
||||||
|
if (out != cancellation_type::none)
|
||||||
|
this->signal_.emit(out);
|
||||||
|
}
|
||||||
|
|
||||||
|
InFilter in_filter_;
|
||||||
|
OutFilter out_filter_;
|
||||||
|
};
|
||||||
|
|
||||||
|
impl_base* impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_CANCELLATION_STATE_HPP
|
||||||
|
|
@ -0,0 +1,174 @@
|
||||||
|
//
|
||||||
|
// cancellation_type.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_CANCELLATION_TYPE_HPP
|
||||||
|
#define ASIO_CANCELLATION_TYPE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
# if defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Enumeration representing the different types of cancellation that may
|
||||||
|
/// be requested from or implemented by an asynchronous operation.
|
||||||
|
enum cancellation_type
|
||||||
|
{
|
||||||
|
/// Bitmask representing no types of cancellation.
|
||||||
|
none = 0,
|
||||||
|
|
||||||
|
/// Requests cancellation where, following a successful cancellation, the only
|
||||||
|
/// safe operations on the I/O object are closure or destruction.
|
||||||
|
terminal = 1,
|
||||||
|
|
||||||
|
/// Requests cancellation where a successful cancellation may result in
|
||||||
|
/// partial side effects or no side effects. Following cancellation, the I/O
|
||||||
|
/// object is in a well-known state, and may be used for further operations.
|
||||||
|
partial = 2,
|
||||||
|
|
||||||
|
/// Requests cancellation where a successful cancellation results in no
|
||||||
|
/// apparent side effects. Following cancellation, the I/O object is in the
|
||||||
|
/// same observable state as it was prior to the operation.
|
||||||
|
total = 4,
|
||||||
|
|
||||||
|
/// Bitmask representing all types of cancellation.
|
||||||
|
all = 0xFFFFFFFF
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Portability typedef.
|
||||||
|
typedef cancellation_type cancellation_type_t;
|
||||||
|
|
||||||
|
#elif defined(ASIO_HAS_ENUM_CLASS)
|
||||||
|
|
||||||
|
enum class cancellation_type : unsigned int
|
||||||
|
{
|
||||||
|
none = 0,
|
||||||
|
terminal = 1,
|
||||||
|
partial = 2,
|
||||||
|
total = 4,
|
||||||
|
all = 0xFFFFFFFF
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef cancellation_type cancellation_type_t;
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_ENUM_CLASS)
|
||||||
|
|
||||||
|
namespace cancellation_type {
|
||||||
|
|
||||||
|
enum cancellation_type_t
|
||||||
|
{
|
||||||
|
none = 0,
|
||||||
|
terminal = 1,
|
||||||
|
partial = 2,
|
||||||
|
total = 4,
|
||||||
|
all = 0xFFFFFFFF
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace cancellation_type
|
||||||
|
|
||||||
|
typedef cancellation_type::cancellation_type_t cancellation_type_t;
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_ENUM_CLASS)
|
||||||
|
|
||||||
|
/// Negation operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline ASIO_CONSTEXPR bool operator!(cancellation_type_t x)
|
||||||
|
{
|
||||||
|
return static_cast<unsigned int>(x) == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise and operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline ASIO_CONSTEXPR cancellation_type_t operator&(
|
||||||
|
cancellation_type_t x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
return static_cast<cancellation_type_t>(
|
||||||
|
static_cast<unsigned int>(x) & static_cast<unsigned int>(y));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise or operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline ASIO_CONSTEXPR cancellation_type_t operator|(
|
||||||
|
cancellation_type_t x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
return static_cast<cancellation_type_t>(
|
||||||
|
static_cast<unsigned int>(x) | static_cast<unsigned int>(y));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise xor operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline ASIO_CONSTEXPR cancellation_type_t operator^(
|
||||||
|
cancellation_type_t x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
return static_cast<cancellation_type_t>(
|
||||||
|
static_cast<unsigned int>(x) ^ static_cast<unsigned int>(y));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise negation operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline ASIO_CONSTEXPR cancellation_type_t operator~(cancellation_type_t x)
|
||||||
|
{
|
||||||
|
return static_cast<cancellation_type_t>(~static_cast<unsigned int>(x));
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise and-assignment operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline cancellation_type_t& operator&=(
|
||||||
|
cancellation_type_t& x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
x = x & y;
|
||||||
|
return x;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise or-assignment operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline cancellation_type_t& operator|=(
|
||||||
|
cancellation_type_t& x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
x = x | y;
|
||||||
|
return x;
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Bitwise xor-assignment operator.
|
||||||
|
/**
|
||||||
|
* @relates cancellation_type
|
||||||
|
*/
|
||||||
|
inline cancellation_type_t& operator^=(
|
||||||
|
cancellation_type_t& x, cancellation_type_t y)
|
||||||
|
{
|
||||||
|
x = x ^ y;
|
||||||
|
return x;
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_CANCELLATION_TYPE_HPP
|
||||||
|
|
@ -0,0 +1,523 @@
|
||||||
|
//
|
||||||
|
// co_spawn.hpp
|
||||||
|
// ~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_CO_SPAWN_HPP
|
||||||
|
#define ASIO_CO_SPAWN_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include "asio/awaitable.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
struct awaitable_signature;
|
||||||
|
|
||||||
|
template <typename T, typename Executor>
|
||||||
|
struct awaitable_signature<awaitable<T, Executor>>
|
||||||
|
{
|
||||||
|
typedef void type(std::exception_ptr, T);
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Executor>
|
||||||
|
struct awaitable_signature<awaitable<void, Executor>>
|
||||||
|
{
|
||||||
|
typedef void type(std::exception_ptr);
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ex The executor that will be used to schedule the new thread of
|
||||||
|
* execution.
|
||||||
|
*
|
||||||
|
* @param a The asio::awaitable object that is the result of calling the
|
||||||
|
* coroutine's entry point function.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification that
|
||||||
|
* the thread of execution has completed. The function signature of the
|
||||||
|
* completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr, T); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr, T) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<std::size_t> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* std::size_t bytes_transferred = 0;
|
||||||
|
*
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* bytes_transferred += n;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception&)
|
||||||
|
* {
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* co_return bytes_transferred;
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_executor,
|
||||||
|
* echo(std::move(my_tcp_socket)),
|
||||||
|
* [](std::exception_ptr e, std::size_t n)
|
||||||
|
* {
|
||||||
|
* std::cout << "transferred " << n << "\n";
|
||||||
|
* });
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename Executor, typename T, typename AwaitableExecutor,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(
|
||||||
|
void(std::exception_ptr, T)) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
|
||||||
|
inline ASIO_INITFN_AUTO_RESULT_TYPE(
|
||||||
|
CompletionToken, void(std::exception_ptr, T))
|
||||||
|
co_spawn(const Executor& ex, awaitable<T, AwaitableExecutor> a,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
|
||||||
|
typename constraint<
|
||||||
|
(is_executor<Executor>::value || execution::is_executor<Executor>::value)
|
||||||
|
&& is_convertible<Executor, AwaitableExecutor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ex The executor that will be used to schedule the new thread of
|
||||||
|
* execution.
|
||||||
|
*
|
||||||
|
* @param a The asio::awaitable object that is the result of calling the
|
||||||
|
* coroutine's entry point function.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification that
|
||||||
|
* the thread of execution has completed. The function signature of the
|
||||||
|
* completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<void> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception& e)
|
||||||
|
* {
|
||||||
|
* std::cerr << "Exception: " << e.what() << "\n";
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_executor,
|
||||||
|
* echo(std::move(my_tcp_socket)),
|
||||||
|
* asio::detached);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename Executor, typename AwaitableExecutor,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(
|
||||||
|
void(std::exception_ptr)) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
|
||||||
|
inline ASIO_INITFN_AUTO_RESULT_TYPE(
|
||||||
|
CompletionToken, void(std::exception_ptr))
|
||||||
|
co_spawn(const Executor& ex, awaitable<void, AwaitableExecutor> a,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
|
||||||
|
typename constraint<
|
||||||
|
(is_executor<Executor>::value || execution::is_executor<Executor>::value)
|
||||||
|
&& is_convertible<Executor, AwaitableExecutor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ctx An execution context that will provide the executor to be used to
|
||||||
|
* schedule the new thread of execution.
|
||||||
|
*
|
||||||
|
* @param a The asio::awaitable object that is the result of calling the
|
||||||
|
* coroutine's entry point function.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification that
|
||||||
|
* the thread of execution has completed. The function signature of the
|
||||||
|
* completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr, T) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<std::size_t> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* std::size_t bytes_transferred = 0;
|
||||||
|
*
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* bytes_transferred += n;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception&)
|
||||||
|
* {
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* co_return bytes_transferred;
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_io_context,
|
||||||
|
* echo(std::move(my_tcp_socket)),
|
||||||
|
* [](std::exception_ptr e, std::size_t n)
|
||||||
|
* {
|
||||||
|
* std::cout << "transferred " << n << "\n";
|
||||||
|
* });
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext, typename T, typename AwaitableExecutor,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(
|
||||||
|
void(std::exception_ptr, T)) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
|
||||||
|
typename ExecutionContext::executor_type)>
|
||||||
|
inline ASIO_INITFN_AUTO_RESULT_TYPE(
|
||||||
|
CompletionToken, void(std::exception_ptr, T))
|
||||||
|
co_spawn(ExecutionContext& ctx, awaitable<T, AwaitableExecutor> a,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(
|
||||||
|
typename ExecutionContext::executor_type),
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
&& is_convertible<typename ExecutionContext::executor_type,
|
||||||
|
AwaitableExecutor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ctx An execution context that will provide the executor to be used to
|
||||||
|
* schedule the new thread of execution.
|
||||||
|
*
|
||||||
|
* @param a The asio::awaitable object that is the result of calling the
|
||||||
|
* coroutine's entry point function.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification that
|
||||||
|
* the thread of execution has completed. The function signature of the
|
||||||
|
* completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr) @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<void> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception& e)
|
||||||
|
* {
|
||||||
|
* std::cerr << "Exception: " << e.what() << "\n";
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_io_context,
|
||||||
|
* echo(std::move(my_tcp_socket)),
|
||||||
|
* asio::detached);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext, typename AwaitableExecutor,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(
|
||||||
|
void(std::exception_ptr)) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
|
||||||
|
typename ExecutionContext::executor_type)>
|
||||||
|
inline ASIO_INITFN_AUTO_RESULT_TYPE(
|
||||||
|
CompletionToken, void(std::exception_ptr))
|
||||||
|
co_spawn(ExecutionContext& ctx, awaitable<void, AwaitableExecutor> a,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(
|
||||||
|
typename ExecutionContext::executor_type),
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
&& is_convertible<typename ExecutionContext::executor_type,
|
||||||
|
AwaitableExecutor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ex The executor that will be used to schedule the new thread of
|
||||||
|
* execution.
|
||||||
|
*
|
||||||
|
* @param f A nullary function object with a return type of the form
|
||||||
|
* @c asio::awaitable<R,E> that will be used as the coroutine's entry
|
||||||
|
* point.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification
|
||||||
|
* that the thread of execution has completed. If @c R is @c void, the function
|
||||||
|
* signature of the completion handler must be:
|
||||||
|
*
|
||||||
|
* @code void handler(std::exception_ptr); @endcode
|
||||||
|
* Otherwise, the function signature of the completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr, R); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr, R) @endcode
|
||||||
|
* where @c R is the first template argument to the @c awaitable returned by the
|
||||||
|
* supplied function object @c F:
|
||||||
|
* @code asio::awaitable<R, AwaitableExecutor> F() @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<std::size_t> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* std::size_t bytes_transferred = 0;
|
||||||
|
*
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* bytes_transferred += n;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception&)
|
||||||
|
* {
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* co_return bytes_transferred;
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_executor,
|
||||||
|
* [socket = std::move(my_tcp_socket)]() mutable
|
||||||
|
* -> asio::awaitable<void>
|
||||||
|
* {
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception& e)
|
||||||
|
* {
|
||||||
|
* std::cerr << "Exception: " << e.what() << "\n";
|
||||||
|
* }
|
||||||
|
* }, asio::detached);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename Executor, typename F,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
|
||||||
|
typename result_of<F()>::type>::type) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
|
||||||
|
typename detail::awaitable_signature<typename result_of<F()>::type>::type)
|
||||||
|
co_spawn(const Executor& ex, F&& f,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
|
||||||
|
typename constraint<
|
||||||
|
is_executor<Executor>::value || execution::is_executor<Executor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Spawn a new coroutined-based thread of execution.
|
||||||
|
/**
|
||||||
|
* @param ctx An execution context that will provide the executor to be used to
|
||||||
|
* schedule the new thread of execution.
|
||||||
|
*
|
||||||
|
* @param f A nullary function object with a return type of the form
|
||||||
|
* @c asio::awaitable<R,E> that will be used as the coroutine's entry
|
||||||
|
* point.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will handle the notification
|
||||||
|
* that the thread of execution has completed. If @c R is @c void, the function
|
||||||
|
* signature of the completion handler must be:
|
||||||
|
*
|
||||||
|
* @code void handler(std::exception_ptr); @endcode
|
||||||
|
* Otherwise, the function signature of the completion handler must be:
|
||||||
|
* @code void handler(std::exception_ptr, R); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void(std::exception_ptr, R) @endcode
|
||||||
|
* where @c R is the first template argument to the @c awaitable returned by the
|
||||||
|
* supplied function object @c F:
|
||||||
|
* @code asio::awaitable<R, AwaitableExecutor> F() @endcode
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* @code
|
||||||
|
* asio::awaitable<std::size_t> echo(tcp::socket socket)
|
||||||
|
* {
|
||||||
|
* std::size_t bytes_transferred = 0;
|
||||||
|
*
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* bytes_transferred += n;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception&)
|
||||||
|
* {
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* co_return bytes_transferred;
|
||||||
|
* }
|
||||||
|
*
|
||||||
|
* // ...
|
||||||
|
*
|
||||||
|
* asio::co_spawn(my_io_context,
|
||||||
|
* [socket = std::move(my_tcp_socket)]() mutable
|
||||||
|
* -> asio::awaitable<void>
|
||||||
|
* {
|
||||||
|
* try
|
||||||
|
* {
|
||||||
|
* char data[1024];
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* std::size_t n = co_await socket.async_read_some(
|
||||||
|
* asio::buffer(data), asio::use_awaitable);
|
||||||
|
*
|
||||||
|
* co_await asio::async_write(socket,
|
||||||
|
* asio::buffer(data, n), asio::use_awaitable);
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* catch (const std::exception& e)
|
||||||
|
* {
|
||||||
|
* std::cerr << "Exception: " << e.what() << "\n";
|
||||||
|
* }
|
||||||
|
* }, asio::detached);
|
||||||
|
* @endcode
|
||||||
|
*
|
||||||
|
* @par Per-Operation Cancellation
|
||||||
|
* The new thread of execution is created with a cancellation state that
|
||||||
|
* supports @c cancellation_type::terminal values only. To change the
|
||||||
|
* cancellation state, call asio::this_coro::reset_cancellation_state.
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext, typename F,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(typename detail::awaitable_signature<
|
||||||
|
typename result_of<F()>::type>::type) CompletionToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
|
||||||
|
typename ExecutionContext::executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken,
|
||||||
|
typename detail::awaitable_signature<typename result_of<F()>::type>::type)
|
||||||
|
co_spawn(ExecutionContext& ctx, F&& f,
|
||||||
|
CompletionToken&& token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(
|
||||||
|
typename ExecutionContext::executor_type),
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<ExecutionContext&, execution_context&>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/co_spawn.hpp"
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_CO_AWAIT) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_CO_SPAWN_HPP
|
||||||
|
|
@ -0,0 +1,218 @@
|
||||||
|
//
|
||||||
|
// completion_condition.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_COMPLETION_CONDITION_HPP
|
||||||
|
#define ASIO_COMPLETION_CONDITION_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// The default maximum number of bytes to transfer in a single operation.
|
||||||
|
enum default_max_transfer_size_t { default_max_transfer_size = 65536 };
|
||||||
|
|
||||||
|
// Adapt result of old-style completion conditions (which had a bool result
|
||||||
|
// where true indicated that the operation was complete).
|
||||||
|
inline std::size_t adapt_completion_condition_result(bool result)
|
||||||
|
{
|
||||||
|
return result ? 0 : default_max_transfer_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Adapt result of current completion conditions (which have a size_t result
|
||||||
|
// where 0 means the operation is complete, and otherwise the result is the
|
||||||
|
// maximum number of bytes to transfer on the next underlying operation).
|
||||||
|
inline std::size_t adapt_completion_condition_result(std::size_t result)
|
||||||
|
{
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
class transfer_all_t
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef std::size_t result_type;
|
||||||
|
|
||||||
|
template <typename Error>
|
||||||
|
std::size_t operator()(const Error& err, std::size_t)
|
||||||
|
{
|
||||||
|
return !!err ? 0 : default_max_transfer_size;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class transfer_at_least_t
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef std::size_t result_type;
|
||||||
|
|
||||||
|
explicit transfer_at_least_t(std::size_t minimum)
|
||||||
|
: minimum_(minimum)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Error>
|
||||||
|
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
|
||||||
|
{
|
||||||
|
return (!!err || bytes_transferred >= minimum_)
|
||||||
|
? 0 : default_max_transfer_size;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::size_t minimum_;
|
||||||
|
};
|
||||||
|
|
||||||
|
class transfer_exactly_t
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef std::size_t result_type;
|
||||||
|
|
||||||
|
explicit transfer_exactly_t(std::size_t size)
|
||||||
|
: size_(size)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Error>
|
||||||
|
std::size_t operator()(const Error& err, std::size_t bytes_transferred)
|
||||||
|
{
|
||||||
|
return (!!err || bytes_transferred >= size_) ? 0 :
|
||||||
|
(size_ - bytes_transferred < default_max_transfer_size
|
||||||
|
? size_ - bytes_transferred : std::size_t(default_max_transfer_size));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::size_t size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/**
|
||||||
|
* @defgroup completion_condition Completion Condition Function Objects
|
||||||
|
*
|
||||||
|
* Function objects used for determining when a read or write operation should
|
||||||
|
* complete.
|
||||||
|
*/
|
||||||
|
/*@{*/
|
||||||
|
|
||||||
|
/// Return a completion condition function object that indicates that a read or
|
||||||
|
/// write operation should continue until all of the data has been transferred,
|
||||||
|
/// or until an error occurs.
|
||||||
|
/**
|
||||||
|
* This function is used to create an object, of unspecified type, that meets
|
||||||
|
* CompletionCondition requirements.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* Reading until a buffer is full:
|
||||||
|
* @code
|
||||||
|
* boost::array<char, 128> buf;
|
||||||
|
* asio::error_code ec;
|
||||||
|
* std::size_t n = asio::read(
|
||||||
|
* sock, asio::buffer(buf),
|
||||||
|
* asio::transfer_all(), ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* // n == 128
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
unspecified transfer_all();
|
||||||
|
#else
|
||||||
|
inline detail::transfer_all_t transfer_all()
|
||||||
|
{
|
||||||
|
return detail::transfer_all_t();
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Return a completion condition function object that indicates that a read or
|
||||||
|
/// write operation should continue until a minimum number of bytes has been
|
||||||
|
/// transferred, or until an error occurs.
|
||||||
|
/**
|
||||||
|
* This function is used to create an object, of unspecified type, that meets
|
||||||
|
* CompletionCondition requirements.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* Reading until a buffer is full or contains at least 64 bytes:
|
||||||
|
* @code
|
||||||
|
* boost::array<char, 128> buf;
|
||||||
|
* asio::error_code ec;
|
||||||
|
* std::size_t n = asio::read(
|
||||||
|
* sock, asio::buffer(buf),
|
||||||
|
* asio::transfer_at_least(64), ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* // n >= 64 && n <= 128
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
unspecified transfer_at_least(std::size_t minimum);
|
||||||
|
#else
|
||||||
|
inline detail::transfer_at_least_t transfer_at_least(std::size_t minimum)
|
||||||
|
{
|
||||||
|
return detail::transfer_at_least_t(minimum);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/// Return a completion condition function object that indicates that a read or
|
||||||
|
/// write operation should continue until an exact number of bytes has been
|
||||||
|
/// transferred, or until an error occurs.
|
||||||
|
/**
|
||||||
|
* This function is used to create an object, of unspecified type, that meets
|
||||||
|
* CompletionCondition requirements.
|
||||||
|
*
|
||||||
|
* @par Example
|
||||||
|
* Reading until a buffer is full or contains exactly 64 bytes:
|
||||||
|
* @code
|
||||||
|
* boost::array<char, 128> buf;
|
||||||
|
* asio::error_code ec;
|
||||||
|
* std::size_t n = asio::read(
|
||||||
|
* sock, asio::buffer(buf),
|
||||||
|
* asio::transfer_exactly(64), ec);
|
||||||
|
* if (ec)
|
||||||
|
* {
|
||||||
|
* // An error occurred.
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* // n == 64
|
||||||
|
* }
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
#if defined(GENERATING_DOCUMENTATION)
|
||||||
|
unspecified transfer_exactly(std::size_t size);
|
||||||
|
#else
|
||||||
|
inline detail::transfer_exactly_t transfer_exactly(std::size_t size)
|
||||||
|
{
|
||||||
|
return detail::transfer_exactly_t(size);
|
||||||
|
}
|
||||||
|
#endif
|
||||||
|
|
||||||
|
/*@}*/
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_COMPLETION_CONDITION_HPP
|
||||||
|
|
@ -0,0 +1,136 @@
|
||||||
|
//
|
||||||
|
// compose.hpp
|
||||||
|
// ~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_COMPOSE_HPP
|
||||||
|
#define ASIO_COMPOSE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_VARIADIC_TEMPLATES) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Launch an asynchronous operation with a stateful implementation.
|
||||||
|
/**
|
||||||
|
* The async_compose function simplifies the implementation of composed
|
||||||
|
* asynchronous operations automatically wrapping a stateful function object
|
||||||
|
* with a conforming intermediate completion handler.
|
||||||
|
*
|
||||||
|
* @param implementation A function object that contains the implementation of
|
||||||
|
* the composed asynchronous operation. The first argument to the function
|
||||||
|
* object is a non-const reference to the enclosing intermediate completion
|
||||||
|
* handler. The remaining arguments are any arguments that originate from the
|
||||||
|
* completion handlers of any asynchronous operations performed by the
|
||||||
|
* implementation.
|
||||||
|
|
||||||
|
* @param token The completion token.
|
||||||
|
*
|
||||||
|
* @param io_objects_or_executors Zero or more I/O objects or I/O executors for
|
||||||
|
* which outstanding work must be maintained.
|
||||||
|
*
|
||||||
|
* @par Example:
|
||||||
|
*
|
||||||
|
* @code struct async_echo_implementation
|
||||||
|
* {
|
||||||
|
* tcp::socket& socket_;
|
||||||
|
* asio::mutable_buffer buffer_;
|
||||||
|
* enum { starting, reading, writing } state_;
|
||||||
|
*
|
||||||
|
* template <typename Self>
|
||||||
|
* void operator()(Self& self,
|
||||||
|
* asio::error_code error = {},
|
||||||
|
* std::size_t n = 0)
|
||||||
|
* {
|
||||||
|
* switch (state_)
|
||||||
|
* {
|
||||||
|
* case starting:
|
||||||
|
* state_ = reading;
|
||||||
|
* socket_.async_read_some(
|
||||||
|
* buffer_, std::move(self));
|
||||||
|
* break;
|
||||||
|
* case reading:
|
||||||
|
* if (error)
|
||||||
|
* {
|
||||||
|
* self.complete(error, 0);
|
||||||
|
* }
|
||||||
|
* else
|
||||||
|
* {
|
||||||
|
* state_ = writing;
|
||||||
|
* asio::async_write(socket_, buffer_,
|
||||||
|
* asio::transfer_exactly(n),
|
||||||
|
* std::move(self));
|
||||||
|
* }
|
||||||
|
* break;
|
||||||
|
* case writing:
|
||||||
|
* self.complete(error, n);
|
||||||
|
* break;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* };
|
||||||
|
*
|
||||||
|
* template <typename CompletionToken>
|
||||||
|
* auto async_echo(tcp::socket& socket,
|
||||||
|
* asio::mutable_buffer buffer,
|
||||||
|
* CompletionToken&& token) ->
|
||||||
|
* typename asio::async_result<
|
||||||
|
* typename std::decay<CompletionToken>::type,
|
||||||
|
* void(asio::error_code, std::size_t)>::return_type
|
||||||
|
* {
|
||||||
|
* return asio::async_compose<CompletionToken,
|
||||||
|
* void(asio::error_code, std::size_t)>(
|
||||||
|
* async_echo_implementation{socket, buffer,
|
||||||
|
* async_echo_implementation::starting},
|
||||||
|
* token, socket);
|
||||||
|
* } @endcode
|
||||||
|
*/
|
||||||
|
template <typename CompletionToken, typename Signature,
|
||||||
|
typename Implementation, typename... IoObjectsOrExecutors>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature)
|
||||||
|
async_compose(ASIO_MOVE_ARG(Implementation) implementation,
|
||||||
|
ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token,
|
||||||
|
ASIO_MOVE_ARG(IoObjectsOrExecutors)... io_objects_or_executors);
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
template <typename CompletionToken, typename Signature, typename Implementation>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature)
|
||||||
|
async_compose(ASIO_MOVE_ARG(Implementation) implementation,
|
||||||
|
ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token);
|
||||||
|
|
||||||
|
#define ASIO_PRIVATE_ASYNC_COMPOSE_DEF(n) \
|
||||||
|
template <typename CompletionToken, typename Signature, \
|
||||||
|
typename Implementation, ASIO_VARIADIC_TPARAMS(n)> \
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature) \
|
||||||
|
async_compose(ASIO_MOVE_ARG(Implementation) implementation, \
|
||||||
|
ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \
|
||||||
|
ASIO_VARIADIC_MOVE_PARAMS(n));
|
||||||
|
/**/
|
||||||
|
ASIO_VARIADIC_GENERATE(ASIO_PRIVATE_ASYNC_COMPOSE_DEF)
|
||||||
|
#undef ASIO_PRIVATE_ASYNC_COMPOSE_DEF
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_VARIADIC_TEMPLATES)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/compose.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_COMPOSE_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,83 @@
|
||||||
|
//
|
||||||
|
// connect_pipe.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_CONNECT_PIPE_HPP
|
||||||
|
#define ASIO_CONNECT_PIPE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_PIPE) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include "asio/basic_readable_pipe.hpp"
|
||||||
|
#include "asio/basic_writable_pipe.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_IOCP)
|
||||||
|
typedef HANDLE native_pipe_handle;
|
||||||
|
#else // defined(ASIO_HAS_IOCP)
|
||||||
|
typedef int native_pipe_handle;
|
||||||
|
#endif // defined(ASIO_HAS_IOCP)
|
||||||
|
|
||||||
|
ASIO_DECL void create_pipe(native_pipe_handle p[2],
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL void close_pipe(native_pipe_handle p);
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Connect two pipe ends using an anonymous pipe.
|
||||||
|
/**
|
||||||
|
* @param read_end The read end of the pipe.
|
||||||
|
*
|
||||||
|
* @param write_end The write end of the pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*/
|
||||||
|
template <typename Executor1, typename Executor2>
|
||||||
|
void connect_pipe(basic_readable_pipe<Executor1>& read_end,
|
||||||
|
basic_writable_pipe<Executor2>& write_end);
|
||||||
|
|
||||||
|
/// Connect two pipe ends using an anonymous pipe.
|
||||||
|
/**
|
||||||
|
* @param read_end The read end of the pipe.
|
||||||
|
*
|
||||||
|
* @param write_end The write end of the pipe.
|
||||||
|
*
|
||||||
|
* @throws asio::system_error Thrown on failure.
|
||||||
|
*
|
||||||
|
* @param ec Set to indicate what error occurred, if any.
|
||||||
|
*/
|
||||||
|
template <typename Executor1, typename Executor2>
|
||||||
|
ASIO_SYNC_OP_VOID connect_pipe(basic_readable_pipe<Executor1>& read_end,
|
||||||
|
basic_writable_pipe<Executor2>& write_end, asio::error_code& ec);
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/connect_pipe.hpp"
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/impl/connect_pipe.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_PIPE)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_CONNECT_PIPE_HPP
|
||||||
|
|
@ -0,0 +1,328 @@
|
||||||
|
//
|
||||||
|
// coroutine.hpp
|
||||||
|
// ~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_COROUTINE_HPP
|
||||||
|
#define ASIO_COROUTINE_HPP
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class coroutine_ref;
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
|
||||||
|
/// Provides support for implementing stackless coroutines.
|
||||||
|
/**
|
||||||
|
* The @c coroutine class may be used to implement stackless coroutines. The
|
||||||
|
* class itself is used to store the current state of the coroutine.
|
||||||
|
*
|
||||||
|
* Coroutines are copy-constructible and assignable, and the space overhead is
|
||||||
|
* a single int. They can be used as a base class:
|
||||||
|
*
|
||||||
|
* @code class session : coroutine
|
||||||
|
* {
|
||||||
|
* ...
|
||||||
|
* }; @endcode
|
||||||
|
*
|
||||||
|
* or as a data member:
|
||||||
|
*
|
||||||
|
* @code class session
|
||||||
|
* {
|
||||||
|
* ...
|
||||||
|
* coroutine coro_;
|
||||||
|
* }; @endcode
|
||||||
|
*
|
||||||
|
* or even bound in as a function argument using lambdas or @c bind(). The
|
||||||
|
* important thing is that as the application maintains a copy of the object
|
||||||
|
* for as long as the coroutine must be kept alive.
|
||||||
|
*
|
||||||
|
* @par Pseudo-keywords
|
||||||
|
*
|
||||||
|
* A coroutine is used in conjunction with certain "pseudo-keywords", which
|
||||||
|
* are implemented as macros. These macros are defined by a header file:
|
||||||
|
*
|
||||||
|
* @code #include <asio/yield.hpp>@endcode
|
||||||
|
*
|
||||||
|
* and may conversely be undefined as follows:
|
||||||
|
*
|
||||||
|
* @code #include <asio/unyield.hpp>@endcode
|
||||||
|
*
|
||||||
|
* <b>reenter</b>
|
||||||
|
*
|
||||||
|
* The @c reenter macro is used to define the body of a coroutine. It takes a
|
||||||
|
* single argument: a pointer or reference to a coroutine object. For example,
|
||||||
|
* if the base class is a coroutine object you may write:
|
||||||
|
*
|
||||||
|
* @code reenter (this)
|
||||||
|
* {
|
||||||
|
* ... coroutine body ...
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* and if a data member or other variable you can write:
|
||||||
|
*
|
||||||
|
* @code reenter (coro_)
|
||||||
|
* {
|
||||||
|
* ... coroutine body ...
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* When @c reenter is executed at runtime, control jumps to the location of the
|
||||||
|
* last @c yield or @c fork.
|
||||||
|
*
|
||||||
|
* The coroutine body may also be a single statement, such as:
|
||||||
|
*
|
||||||
|
* @code reenter (this) for (;;)
|
||||||
|
* {
|
||||||
|
* ...
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* @b Limitation: The @c reenter macro is implemented using a switch. This
|
||||||
|
* means that you must take care when using local variables within the
|
||||||
|
* coroutine body. The local variable is not allowed in a position where
|
||||||
|
* reentering the coroutine could bypass the variable definition.
|
||||||
|
*
|
||||||
|
* <b>yield <em>statement</em></b>
|
||||||
|
*
|
||||||
|
* This form of the @c yield keyword is often used with asynchronous operations:
|
||||||
|
*
|
||||||
|
* @code yield socket_->async_read_some(buffer(*buffer_), *this); @endcode
|
||||||
|
*
|
||||||
|
* This divides into four logical steps:
|
||||||
|
*
|
||||||
|
* @li @c yield saves the current state of the coroutine.
|
||||||
|
* @li The statement initiates the asynchronous operation.
|
||||||
|
* @li The resume point is defined immediately following the statement.
|
||||||
|
* @li Control is transferred to the end of the coroutine body.
|
||||||
|
*
|
||||||
|
* When the asynchronous operation completes, the function object is invoked
|
||||||
|
* and @c reenter causes control to transfer to the resume point. It is
|
||||||
|
* important to remember to carry the coroutine state forward with the
|
||||||
|
* asynchronous operation. In the above snippet, the current class is a
|
||||||
|
* function object object with a coroutine object as base class or data member.
|
||||||
|
*
|
||||||
|
* The statement may also be a compound statement, and this permits us to
|
||||||
|
* define local variables with limited scope:
|
||||||
|
*
|
||||||
|
* @code yield
|
||||||
|
* {
|
||||||
|
* mutable_buffers_1 b = buffer(*buffer_);
|
||||||
|
* socket_->async_read_some(b, *this);
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* <b>yield return <em>expression</em> ;</b>
|
||||||
|
*
|
||||||
|
* This form of @c yield is often used in generators or coroutine-based parsers.
|
||||||
|
* For example, the function object:
|
||||||
|
*
|
||||||
|
* @code struct interleave : coroutine
|
||||||
|
* {
|
||||||
|
* istream& is1;
|
||||||
|
* istream& is2;
|
||||||
|
* char operator()(char c)
|
||||||
|
* {
|
||||||
|
* reenter (this) for (;;)
|
||||||
|
* {
|
||||||
|
* yield return is1.get();
|
||||||
|
* yield return is2.get();
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* }; @endcode
|
||||||
|
*
|
||||||
|
* defines a trivial coroutine that interleaves the characters from two input
|
||||||
|
* streams.
|
||||||
|
*
|
||||||
|
* This type of @c yield divides into three logical steps:
|
||||||
|
*
|
||||||
|
* @li @c yield saves the current state of the coroutine.
|
||||||
|
* @li The resume point is defined immediately following the semicolon.
|
||||||
|
* @li The value of the expression is returned from the function.
|
||||||
|
*
|
||||||
|
* <b>yield ;</b>
|
||||||
|
*
|
||||||
|
* This form of @c yield is equivalent to the following steps:
|
||||||
|
*
|
||||||
|
* @li @c yield saves the current state of the coroutine.
|
||||||
|
* @li The resume point is defined immediately following the semicolon.
|
||||||
|
* @li Control is transferred to the end of the coroutine body.
|
||||||
|
*
|
||||||
|
* This form might be applied when coroutines are used for cooperative
|
||||||
|
* threading and scheduling is explicitly managed. For example:
|
||||||
|
*
|
||||||
|
* @code struct task : coroutine
|
||||||
|
* {
|
||||||
|
* ...
|
||||||
|
* void operator()()
|
||||||
|
* {
|
||||||
|
* reenter (this)
|
||||||
|
* {
|
||||||
|
* while (... not finished ...)
|
||||||
|
* {
|
||||||
|
* ... do something ...
|
||||||
|
* yield;
|
||||||
|
* ... do some more ...
|
||||||
|
* yield;
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* }
|
||||||
|
* ...
|
||||||
|
* };
|
||||||
|
* ...
|
||||||
|
* task t1, t2;
|
||||||
|
* for (;;)
|
||||||
|
* {
|
||||||
|
* t1();
|
||||||
|
* t2();
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* <b>yield break ;</b>
|
||||||
|
*
|
||||||
|
* The final form of @c yield is used to explicitly terminate the coroutine.
|
||||||
|
* This form is comprised of two steps:
|
||||||
|
*
|
||||||
|
* @li @c yield sets the coroutine state to indicate termination.
|
||||||
|
* @li Control is transferred to the end of the coroutine body.
|
||||||
|
*
|
||||||
|
* Once terminated, calls to is_complete() return true and the coroutine cannot
|
||||||
|
* be reentered.
|
||||||
|
*
|
||||||
|
* Note that a coroutine may also be implicitly terminated if the coroutine
|
||||||
|
* body is exited without a yield, e.g. by return, throw or by running to the
|
||||||
|
* end of the body.
|
||||||
|
*
|
||||||
|
* <b>fork <em>statement</em></b>
|
||||||
|
*
|
||||||
|
* The @c fork pseudo-keyword is used when "forking" a coroutine, i.e. splitting
|
||||||
|
* it into two (or more) copies. One use of @c fork is in a server, where a new
|
||||||
|
* coroutine is created to handle each client connection:
|
||||||
|
*
|
||||||
|
* @code reenter (this)
|
||||||
|
* {
|
||||||
|
* do
|
||||||
|
* {
|
||||||
|
* socket_.reset(new tcp::socket(my_context_));
|
||||||
|
* yield acceptor->async_accept(*socket_, *this);
|
||||||
|
* fork server(*this)();
|
||||||
|
* } while (is_parent());
|
||||||
|
* ... client-specific handling follows ...
|
||||||
|
* } @endcode
|
||||||
|
*
|
||||||
|
* The logical steps involved in a @c fork are:
|
||||||
|
*
|
||||||
|
* @li @c fork saves the current state of the coroutine.
|
||||||
|
* @li The statement creates a copy of the coroutine and either executes it
|
||||||
|
* immediately or schedules it for later execution.
|
||||||
|
* @li The resume point is defined immediately following the semicolon.
|
||||||
|
* @li For the "parent", control immediately continues from the next line.
|
||||||
|
*
|
||||||
|
* The functions is_parent() and is_child() can be used to differentiate
|
||||||
|
* between parent and child. You would use these functions to alter subsequent
|
||||||
|
* control flow.
|
||||||
|
*
|
||||||
|
* Note that @c fork doesn't do the actual forking by itself. It is the
|
||||||
|
* application's responsibility to create a clone of the coroutine and call it.
|
||||||
|
* The clone can be called immediately, as above, or scheduled for delayed
|
||||||
|
* execution using something like asio::post().
|
||||||
|
*
|
||||||
|
* @par Alternate macro names
|
||||||
|
*
|
||||||
|
* If preferred, an application can use macro names that follow a more typical
|
||||||
|
* naming convention, rather than the pseudo-keywords. These are:
|
||||||
|
*
|
||||||
|
* @li @c ASIO_CORO_REENTER instead of @c reenter
|
||||||
|
* @li @c ASIO_CORO_YIELD instead of @c yield
|
||||||
|
* @li @c ASIO_CORO_FORK instead of @c fork
|
||||||
|
*/
|
||||||
|
class coroutine
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// Constructs a coroutine in its initial state.
|
||||||
|
coroutine() : value_(0) {}
|
||||||
|
|
||||||
|
/// Returns true if the coroutine is the child of a fork.
|
||||||
|
bool is_child() const { return value_ < 0; }
|
||||||
|
|
||||||
|
/// Returns true if the coroutine is the parent of a fork.
|
||||||
|
bool is_parent() const { return !is_child(); }
|
||||||
|
|
||||||
|
/// Returns true if the coroutine has reached its terminal state.
|
||||||
|
bool is_complete() const { return value_ == -1; }
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class detail::coroutine_ref;
|
||||||
|
int value_;
|
||||||
|
};
|
||||||
|
|
||||||
|
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class coroutine_ref
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
coroutine_ref(coroutine& c) : value_(c.value_), modified_(false) {}
|
||||||
|
coroutine_ref(coroutine* c) : value_(c->value_), modified_(false) {}
|
||||||
|
~coroutine_ref() { if (!modified_) value_ = -1; }
|
||||||
|
operator int() const { return value_; }
|
||||||
|
int& operator=(int v) { modified_ = true; return value_ = v; }
|
||||||
|
private:
|
||||||
|
void operator=(const coroutine_ref&);
|
||||||
|
int& value_;
|
||||||
|
bool modified_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#define ASIO_CORO_REENTER(c) \
|
||||||
|
switch (::asio::detail::coroutine_ref _coro_value = c) \
|
||||||
|
case -1: if (_coro_value) \
|
||||||
|
{ \
|
||||||
|
goto terminate_coroutine; \
|
||||||
|
terminate_coroutine: \
|
||||||
|
_coro_value = -1; \
|
||||||
|
goto bail_out_of_coroutine; \
|
||||||
|
bail_out_of_coroutine: \
|
||||||
|
break; \
|
||||||
|
} \
|
||||||
|
else /* fall-through */ case 0:
|
||||||
|
|
||||||
|
#define ASIO_CORO_YIELD_IMPL(n) \
|
||||||
|
for (_coro_value = (n);;) \
|
||||||
|
if (_coro_value == 0) \
|
||||||
|
{ \
|
||||||
|
case (n): ; \
|
||||||
|
break; \
|
||||||
|
} \
|
||||||
|
else \
|
||||||
|
switch (_coro_value ? 0 : 1) \
|
||||||
|
for (;;) \
|
||||||
|
/* fall-through */ case -1: if (_coro_value) \
|
||||||
|
goto terminate_coroutine; \
|
||||||
|
else for (;;) \
|
||||||
|
/* fall-through */ case 1: if (_coro_value) \
|
||||||
|
goto bail_out_of_coroutine; \
|
||||||
|
else /* fall-through */ case 0:
|
||||||
|
|
||||||
|
#define ASIO_CORO_FORK_IMPL(n) \
|
||||||
|
for (_coro_value = -(n);; _coro_value = (n)) \
|
||||||
|
if (_coro_value == (n)) \
|
||||||
|
{ \
|
||||||
|
case -(n): ; \
|
||||||
|
break; \
|
||||||
|
} \
|
||||||
|
else
|
||||||
|
|
||||||
|
#if defined(_MSC_VER)
|
||||||
|
# define ASIO_CORO_YIELD ASIO_CORO_YIELD_IMPL(__COUNTER__ + 1)
|
||||||
|
# define ASIO_CORO_FORK ASIO_CORO_FORK_IMPL(__COUNTER__ + 1)
|
||||||
|
#else // defined(_MSC_VER)
|
||||||
|
# define ASIO_CORO_YIELD ASIO_CORO_YIELD_IMPL(__LINE__)
|
||||||
|
# define ASIO_CORO_FORK ASIO_CORO_FORK_IMPL(__LINE__)
|
||||||
|
#endif // defined(_MSC_VER)
|
||||||
|
|
||||||
|
#endif // ASIO_COROUTINE_HPP
|
||||||
|
|
@ -0,0 +1,38 @@
|
||||||
|
//
|
||||||
|
// deadline_timer.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DEADLINE_TIMER_HPP
|
||||||
|
#define ASIO_DEADLINE_TIMER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_BOOST_DATE_TIME) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#include "asio/detail/socket_types.hpp" // Must come before posix_time.
|
||||||
|
#include "asio/basic_deadline_timer.hpp"
|
||||||
|
|
||||||
|
#include <boost/date_time/posix_time/posix_time_types.hpp>
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Typedef for the typical usage of timer. Uses a UTC clock.
|
||||||
|
typedef basic_deadline_timer<boost::posix_time::ptime> deadline_timer;
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_DATE_TIME)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
#endif // ASIO_DEADLINE_TIMER_HPP
|
||||||
|
|
@ -0,0 +1,200 @@
|
||||||
|
//
|
||||||
|
// defer.hpp
|
||||||
|
// ~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DEFER_HPP
|
||||||
|
#define ASIO_DEFER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/async_result.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/execution/executor.hpp"
|
||||||
|
#include "asio/is_executor.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Submits a completion token or function object for execution.
|
||||||
|
/**
|
||||||
|
* This function submits an object for execution using the object's associated
|
||||||
|
* executor. The function object is queued for execution, and is never called
|
||||||
|
* from the current thread prior to returning from <tt>defer()</tt>.
|
||||||
|
*
|
||||||
|
* The use of @c defer(), rather than @ref post(), indicates the caller's
|
||||||
|
* preference that the executor defer the queueing of the function object. This
|
||||||
|
* may allow the executor to optimise queueing for cases when the function
|
||||||
|
* object represents a continuation of the current call context.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(); @endcode
|
||||||
|
*
|
||||||
|
* @returns This function returns <tt>async_initiate<NullaryToken,
|
||||||
|
* void()>(Init{}, token)</tt>, where @c Init is a function object type defined
|
||||||
|
* as:
|
||||||
|
*
|
||||||
|
* @code class Init
|
||||||
|
* {
|
||||||
|
* public:
|
||||||
|
* template <typename CompletionHandler>
|
||||||
|
* void operator()(CompletionHandler&& completion_handler) const;
|
||||||
|
* }; @endcode
|
||||||
|
*
|
||||||
|
* The function call operator of @c Init:
|
||||||
|
*
|
||||||
|
* @li Obtains the handler's associated executor object @c ex of type @c Ex by
|
||||||
|
* performing @code auto ex = get_associated_executor(handler); @endcode
|
||||||
|
*
|
||||||
|
* @li Obtains the handler's associated allocator object @c alloc by performing
|
||||||
|
* @code auto alloc = get_associated_allocator(handler); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
|
||||||
|
* @code execution::execute(
|
||||||
|
* prefer(
|
||||||
|
* require(ex, execution::blocking.never),
|
||||||
|
* execution::relationship.continuation,
|
||||||
|
* execution::allocator(alloc)),
|
||||||
|
* std::forward<CompletionHandler>(completion_handler)); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
|
||||||
|
* @code ex.defer(
|
||||||
|
* std::forward<CompletionHandler>(completion_handler),
|
||||||
|
* alloc); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void() @endcode
|
||||||
|
*/
|
||||||
|
template <ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
|
||||||
|
ASIO_MOVE_ARG(NullaryToken) token);
|
||||||
|
|
||||||
|
/// Submits a completion token or function object for execution.
|
||||||
|
/**
|
||||||
|
* This function submits an object for execution using the specified executor.
|
||||||
|
* The function object is queued for execution, and is never called from the
|
||||||
|
* current thread prior to returning from <tt>defer()</tt>.
|
||||||
|
*
|
||||||
|
* The use of @c defer(), rather than @ref post(), indicates the caller's
|
||||||
|
* preference that the executor defer the queueing of the function object. This
|
||||||
|
* may allow the executor to optimise queueing for cases when the function
|
||||||
|
* object represents a continuation of the current call context.
|
||||||
|
*
|
||||||
|
* @param ex The target executor.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(); @endcode
|
||||||
|
*
|
||||||
|
* @returns This function returns <tt>async_initiate<NullaryToken,
|
||||||
|
* void()>(Init{ex}, token)</tt>, where @c Init is a function object type
|
||||||
|
* defined as:
|
||||||
|
*
|
||||||
|
* @code class Init
|
||||||
|
* {
|
||||||
|
* public:
|
||||||
|
* using executor_type = Executor;
|
||||||
|
* explicit Init(const Executor& ex) : ex_(ex) {}
|
||||||
|
* executor_type get_executor() const noexcept { return ex_; }
|
||||||
|
* template <typename CompletionHandler>
|
||||||
|
* void operator()(CompletionHandler&& completion_handler) const;
|
||||||
|
* private:
|
||||||
|
* Executor ex_; // exposition only
|
||||||
|
* }; @endcode
|
||||||
|
*
|
||||||
|
* The function call operator of @c Init:
|
||||||
|
*
|
||||||
|
* @li Obtains the handler's associated executor object @c ex1 of type @c Ex1 by
|
||||||
|
* performing @code auto ex1 = get_associated_executor(handler, ex); @endcode
|
||||||
|
*
|
||||||
|
* @li Obtains the handler's associated allocator object @c alloc by performing
|
||||||
|
* @code auto alloc = get_associated_allocator(handler); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex1>::value</tt> is true, constructs a
|
||||||
|
* function object @c f with a member @c executor_ that is initialised with
|
||||||
|
* <tt>prefer(ex1, execution::outstanding_work.tracked)</tt>, a member @c
|
||||||
|
* handler_ that is a decay-copy of @c completion_handler, and a function call
|
||||||
|
* operator that performs:
|
||||||
|
* @code auto a = get_associated_allocator(handler_);
|
||||||
|
* execution::execute(
|
||||||
|
* prefer(executor_,
|
||||||
|
* execution::blocking.possibly,
|
||||||
|
* execution::allocator(a)),
|
||||||
|
* std::move(handler_)); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex1>::value</tt> is false, constructs a
|
||||||
|
* function object @c f with a member @c work_ that is initialised with
|
||||||
|
* <tt>make_work_guard(ex1)</tt>, a member @c handler_ that is a decay-copy of
|
||||||
|
* @c completion_handler, and a function call operator that performs:
|
||||||
|
* @code auto a = get_associated_allocator(handler_);
|
||||||
|
* work_.get_executor().dispatch(std::move(handler_), a);
|
||||||
|
* work_.reset(); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex>::value</tt> is true, performs
|
||||||
|
* @code execution::execute(
|
||||||
|
* prefer(
|
||||||
|
* require(ex, execution::blocking.never),
|
||||||
|
* execution::relationship.continuation,
|
||||||
|
* execution::allocator(alloc)),
|
||||||
|
* std::move(f)); @endcode
|
||||||
|
*
|
||||||
|
* @li If <tt>execution::is_executor<Ex>::value</tt> is false, performs
|
||||||
|
* @code ex.defer(std::move(f), alloc); @endcode
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void() @endcode
|
||||||
|
*/
|
||||||
|
template <typename Executor,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(Executor)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
|
||||||
|
const Executor& ex,
|
||||||
|
ASIO_MOVE_ARG(NullaryToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(Executor),
|
||||||
|
typename constraint<
|
||||||
|
execution::is_executor<Executor>::value || is_executor<Executor>::value
|
||||||
|
>::type = 0);
|
||||||
|
|
||||||
|
/// Submits a completion token or function object for execution.
|
||||||
|
/**
|
||||||
|
* @param ctx An execution context, from which the target executor is obtained.
|
||||||
|
*
|
||||||
|
* @param token The @ref completion_token that will be used to produce a
|
||||||
|
* completion handler. The function signature of the completion handler must be:
|
||||||
|
* @code void handler(); @endcode
|
||||||
|
*
|
||||||
|
* @returns <tt>defer(ctx.get_executor(), forward<NullaryToken>(token))</tt>.
|
||||||
|
*
|
||||||
|
* @par Completion Signature
|
||||||
|
* @code void() @endcode
|
||||||
|
*/
|
||||||
|
template <typename ExecutionContext,
|
||||||
|
ASIO_COMPLETION_TOKEN_FOR(void()) NullaryToken
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN_TYPE(
|
||||||
|
typename ExecutionContext::executor_type)>
|
||||||
|
ASIO_INITFN_AUTO_RESULT_TYPE(NullaryToken, void()) defer(
|
||||||
|
ExecutionContext& ctx,
|
||||||
|
ASIO_MOVE_ARG(NullaryToken) token
|
||||||
|
ASIO_DEFAULT_COMPLETION_TOKEN(
|
||||||
|
typename ExecutionContext::executor_type),
|
||||||
|
typename constraint<is_convertible<
|
||||||
|
ExecutionContext&, execution_context&>::value>::type = 0);
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/defer.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DEFER_HPP
|
||||||
|
|
@ -0,0 +1,112 @@
|
||||||
|
//
|
||||||
|
// detached.hpp
|
||||||
|
// ~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETACHED_HPP
|
||||||
|
#define ASIO_DETACHED_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <memory>
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
/// Class used to specify that an asynchronous operation is detached.
|
||||||
|
/**
|
||||||
|
|
||||||
|
* The detached_t class is used to indicate that an asynchronous operation is
|
||||||
|
* detached. That is, there is no completion handler waiting for the
|
||||||
|
* operation's result. A detached_t object may be passed as a handler to an
|
||||||
|
* asynchronous operation, typically using the special value
|
||||||
|
* @c asio::detached. For example:
|
||||||
|
|
||||||
|
* @code my_socket.async_send(my_buffer, asio::detached);
|
||||||
|
* @endcode
|
||||||
|
*/
|
||||||
|
class detached_t
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
/// Constructor.
|
||||||
|
ASIO_CONSTEXPR detached_t()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Adapts an executor to add the @c detached_t completion token as the
|
||||||
|
/// default.
|
||||||
|
template <typename InnerExecutor>
|
||||||
|
struct executor_with_default : InnerExecutor
|
||||||
|
{
|
||||||
|
/// Specify @c detached_t as the default completion token type.
|
||||||
|
typedef detached_t default_completion_token_type;
|
||||||
|
|
||||||
|
/// Construct the adapted executor from the inner executor type.
|
||||||
|
executor_with_default(const InnerExecutor& ex) ASIO_NOEXCEPT
|
||||||
|
: InnerExecutor(ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Convert the specified executor to the inner executor type, then use
|
||||||
|
/// that to construct the adapted executor.
|
||||||
|
template <typename OtherExecutor>
|
||||||
|
executor_with_default(const OtherExecutor& ex,
|
||||||
|
typename constraint<
|
||||||
|
is_convertible<OtherExecutor, InnerExecutor>::value
|
||||||
|
>::type = 0) ASIO_NOEXCEPT
|
||||||
|
: InnerExecutor(ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/// Type alias to adapt an I/O object to use @c detached_t as its
|
||||||
|
/// default completion token type.
|
||||||
|
#if defined(ASIO_HAS_ALIAS_TEMPLATES) \
|
||||||
|
|| defined(GENERATING_DOCUMENTATION)
|
||||||
|
template <typename T>
|
||||||
|
using as_default_on_t = typename T::template rebind_executor<
|
||||||
|
executor_with_default<typename T::executor_type> >::other;
|
||||||
|
#endif // defined(ASIO_HAS_ALIAS_TEMPLATES)
|
||||||
|
// || defined(GENERATING_DOCUMENTATION)
|
||||||
|
|
||||||
|
/// Function helper to adapt an I/O object to use @c detached_t as its
|
||||||
|
/// default completion token type.
|
||||||
|
template <typename T>
|
||||||
|
static typename decay<T>::type::template rebind_executor<
|
||||||
|
executor_with_default<typename decay<T>::type::executor_type>
|
||||||
|
>::other
|
||||||
|
as_default_on(ASIO_MOVE_ARG(T) object)
|
||||||
|
{
|
||||||
|
return typename decay<T>::type::template rebind_executor<
|
||||||
|
executor_with_default<typename decay<T>::type::executor_type>
|
||||||
|
>::other(ASIO_MOVE_CAST(T)(object));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
/// A special value, similar to std::nothrow.
|
||||||
|
/**
|
||||||
|
* See the documentation for asio::detached_t for a usage example.
|
||||||
|
*/
|
||||||
|
#if defined(ASIO_HAS_CONSTEXPR) || defined(GENERATING_DOCUMENTATION)
|
||||||
|
constexpr detached_t detached;
|
||||||
|
#elif defined(ASIO_MSVC)
|
||||||
|
__declspec(selectany) detached_t detached;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/impl/detached.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETACHED_HPP
|
||||||
|
|
@ -0,0 +1,38 @@
|
||||||
|
//
|
||||||
|
// detail/array.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_ARRAY_HPP
|
||||||
|
#define ASIO_DETAIL_ARRAY_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
# include <array>
|
||||||
|
#else // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
# include <boost/array.hpp>
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
using std::array;
|
||||||
|
#else // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
using boost::array;
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_ARRAY_HPP
|
||||||
|
|
@ -0,0 +1,34 @@
|
||||||
|
//
|
||||||
|
// detail/array_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_ARRAY_FWD_HPP
|
||||||
|
#define ASIO_DETAIL_ARRAY_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
namespace boost {
|
||||||
|
|
||||||
|
template<class T, std::size_t N>
|
||||||
|
class array;
|
||||||
|
|
||||||
|
} // namespace boost
|
||||||
|
|
||||||
|
// Standard library components can't be forward declared, so we'll have to
|
||||||
|
// include the array header. Fortunately, it's fairly lightweight and doesn't
|
||||||
|
// add significantly to the compile time.
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
# include <array>
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_ARRAY_FWD_HPP
|
||||||
|
|
@ -0,0 +1,32 @@
|
||||||
|
//
|
||||||
|
// detail/assert.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_ASSERT_HPP
|
||||||
|
#define ASIO_DETAIL_ASSERT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
# include <boost/assert.hpp>
|
||||||
|
#else // defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
# include <cassert>
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
# define ASIO_ASSERT(expr) BOOST_ASSERT(expr)
|
||||||
|
#else // defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
# define ASIO_ASSERT(expr) assert(expr)
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_ASSERT)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_ASSERT_HPP
|
||||||
|
|
@ -0,0 +1,67 @@
|
||||||
|
//
|
||||||
|
// detail/atomic_count.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_ATOMIC_COUNT_HPP
|
||||||
|
#define ASIO_DETAIL_ATOMIC_COUNT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_THREADS)
|
||||||
|
// Nothing to include.
|
||||||
|
#elif defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
# include <atomic>
|
||||||
|
#else // defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
# include <boost/detail/atomic_count.hpp>
|
||||||
|
#endif // defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_THREADS)
|
||||||
|
typedef long atomic_count;
|
||||||
|
inline void increment(atomic_count& a, long b) { a += b; }
|
||||||
|
inline void decrement(atomic_count& a, long b) { a -= b; }
|
||||||
|
inline void ref_count_up(atomic_count& a) { ++a; }
|
||||||
|
inline bool ref_count_down(atomic_count& a) { return --a == 0; }
|
||||||
|
#elif defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
typedef std::atomic<long> atomic_count;
|
||||||
|
inline void increment(atomic_count& a, long b) { a += b; }
|
||||||
|
inline void decrement(atomic_count& a, long b) { a -= b; }
|
||||||
|
|
||||||
|
inline void ref_count_up(atomic_count& a)
|
||||||
|
{
|
||||||
|
a.fetch_add(1, std::memory_order_relaxed);
|
||||||
|
}
|
||||||
|
|
||||||
|
inline bool ref_count_down(atomic_count& a)
|
||||||
|
{
|
||||||
|
if (a.fetch_sub(1, std::memory_order_release) == 1)
|
||||||
|
{
|
||||||
|
std::atomic_thread_fence(std::memory_order_acquire);
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
#else // defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
typedef boost::detail::atomic_count atomic_count;
|
||||||
|
inline void increment(atomic_count& a, long b) { while (b > 0) ++a, --b; }
|
||||||
|
inline void decrement(atomic_count& a, long b) { while (b > 0) --a, --b; }
|
||||||
|
inline void ref_count_up(atomic_count& a) { ++a; }
|
||||||
|
inline bool ref_count_down(atomic_count& a) { return --a == 0; }
|
||||||
|
#endif // defined(ASIO_HAS_STD_ATOMIC)
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_ATOMIC_COUNT_HPP
|
||||||
|
|
@ -0,0 +1,163 @@
|
||||||
|
//
|
||||||
|
// detail/base_from_cancellation_state.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
|
||||||
|
#define ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/associated_cancellation_slot.hpp"
|
||||||
|
#include "asio/cancellation_state.hpp"
|
||||||
|
#include "asio/detail/type_traits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Handler, typename = void>
|
||||||
|
class base_from_cancellation_state
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef cancellation_slot cancellation_slot_type;
|
||||||
|
|
||||||
|
cancellation_slot_type get_cancellation_slot() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_state_.slot();
|
||||||
|
}
|
||||||
|
|
||||||
|
cancellation_state get_cancellation_state() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_state_;
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
explicit base_from_cancellation_state(const Handler& handler)
|
||||||
|
: cancellation_state_(
|
||||||
|
asio::get_associated_cancellation_slot(handler))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Filter>
|
||||||
|
base_from_cancellation_state(const Handler& handler, Filter filter)
|
||||||
|
: cancellation_state_(
|
||||||
|
asio::get_associated_cancellation_slot(handler), filter, filter)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename InFilter, typename OutFilter>
|
||||||
|
base_from_cancellation_state(const Handler& handler,
|
||||||
|
ASIO_MOVE_ARG(InFilter) in_filter,
|
||||||
|
ASIO_MOVE_ARG(OutFilter) out_filter)
|
||||||
|
: cancellation_state_(
|
||||||
|
asio::get_associated_cancellation_slot(handler),
|
||||||
|
ASIO_MOVE_CAST(InFilter)(in_filter),
|
||||||
|
ASIO_MOVE_CAST(OutFilter)(out_filter))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void reset_cancellation_state(const Handler& handler)
|
||||||
|
{
|
||||||
|
cancellation_state_ = cancellation_state(
|
||||||
|
asio::get_associated_cancellation_slot(handler));
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Filter>
|
||||||
|
void reset_cancellation_state(const Handler& handler, Filter filter)
|
||||||
|
{
|
||||||
|
cancellation_state_ = cancellation_state(
|
||||||
|
asio::get_associated_cancellation_slot(handler), filter, filter);
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename InFilter, typename OutFilter>
|
||||||
|
void reset_cancellation_state(const Handler& handler,
|
||||||
|
ASIO_MOVE_ARG(InFilter) in_filter,
|
||||||
|
ASIO_MOVE_ARG(OutFilter) out_filter)
|
||||||
|
{
|
||||||
|
cancellation_state_ = cancellation_state(
|
||||||
|
asio::get_associated_cancellation_slot(handler),
|
||||||
|
ASIO_MOVE_CAST(InFilter)(in_filter),
|
||||||
|
ASIO_MOVE_CAST(OutFilter)(out_filter));
|
||||||
|
}
|
||||||
|
|
||||||
|
cancellation_type_t cancelled() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_state_.cancelled();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
cancellation_state cancellation_state_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Handler>
|
||||||
|
class base_from_cancellation_state<Handler,
|
||||||
|
typename enable_if<
|
||||||
|
is_same<
|
||||||
|
typename associated_cancellation_slot<
|
||||||
|
Handler, cancellation_slot
|
||||||
|
>::asio_associated_cancellation_slot_is_unspecialised,
|
||||||
|
void
|
||||||
|
>::value
|
||||||
|
>::type>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
cancellation_state get_cancellation_state() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_state();
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
explicit base_from_cancellation_state(const Handler&)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Filter>
|
||||||
|
base_from_cancellation_state(const Handler&, Filter)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename InFilter, typename OutFilter>
|
||||||
|
base_from_cancellation_state(const Handler&,
|
||||||
|
ASIO_MOVE_ARG(InFilter),
|
||||||
|
ASIO_MOVE_ARG(OutFilter))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void reset_cancellation_state(const Handler&)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Filter>
|
||||||
|
void reset_cancellation_state(const Handler&, Filter)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename InFilter, typename OutFilter>
|
||||||
|
void reset_cancellation_state(const Handler&,
|
||||||
|
ASIO_MOVE_ARG(InFilter),
|
||||||
|
ASIO_MOVE_ARG(OutFilter))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_CONSTEXPR cancellation_type_t cancelled() const ASIO_NOEXCEPT
|
||||||
|
{
|
||||||
|
return cancellation_type::none;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BASE_FROM_CANCELLATION_STATE_HPP
|
||||||
|
|
@ -0,0 +1,69 @@
|
||||||
|
//
|
||||||
|
// detail/base_from_completion_cond.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
|
||||||
|
#define ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/completion_condition.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename CompletionCondition>
|
||||||
|
class base_from_completion_cond
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
explicit base_from_completion_cond(CompletionCondition& completion_condition)
|
||||||
|
: completion_condition_(
|
||||||
|
ASIO_MOVE_CAST(CompletionCondition)(completion_condition))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t check_for_completion(
|
||||||
|
const asio::error_code& ec,
|
||||||
|
std::size_t total_transferred)
|
||||||
|
{
|
||||||
|
return detail::adapt_completion_condition_result(
|
||||||
|
completion_condition_(ec, total_transferred));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
CompletionCondition completion_condition_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class base_from_completion_cond<transfer_all_t>
|
||||||
|
{
|
||||||
|
protected:
|
||||||
|
explicit base_from_completion_cond(transfer_all_t)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static std::size_t check_for_completion(
|
||||||
|
const asio::error_code& ec,
|
||||||
|
std::size_t total_transferred)
|
||||||
|
{
|
||||||
|
return transfer_all_t()(ec, total_transferred);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BASE_FROM_COMPLETION_COND_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,107 @@
|
||||||
|
//
|
||||||
|
// detail/blocking_executor_op.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
|
||||||
|
#define ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/event.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_invoke_helpers.hpp"
|
||||||
|
#include "asio/detail/mutex.hpp"
|
||||||
|
#include "asio/detail/scheduler_operation.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Operation = scheduler_operation>
|
||||||
|
class blocking_executor_op_base : public Operation
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
blocking_executor_op_base(typename Operation::func_type complete_func)
|
||||||
|
: Operation(complete_func),
|
||||||
|
is_complete_(false)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void wait()
|
||||||
|
{
|
||||||
|
asio::detail::mutex::scoped_lock lock(mutex_);
|
||||||
|
while (!is_complete_)
|
||||||
|
event_.wait(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
protected:
|
||||||
|
struct do_complete_cleanup
|
||||||
|
{
|
||||||
|
~do_complete_cleanup()
|
||||||
|
{
|
||||||
|
asio::detail::mutex::scoped_lock lock(op_->mutex_);
|
||||||
|
op_->is_complete_ = true;
|
||||||
|
op_->event_.unlock_and_signal_one_for_destruction(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
blocking_executor_op_base* op_;
|
||||||
|
};
|
||||||
|
|
||||||
|
private:
|
||||||
|
asio::detail::mutex mutex_;
|
||||||
|
asio::detail::event event_;
|
||||||
|
bool is_complete_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Handler, typename Operation = scheduler_operation>
|
||||||
|
class blocking_executor_op : public blocking_executor_op_base<Operation>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
blocking_executor_op(Handler& h)
|
||||||
|
: blocking_executor_op_base<Operation>(&blocking_executor_op::do_complete),
|
||||||
|
handler_(h)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, Operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
blocking_executor_op* o(static_cast<blocking_executor_op*>(base));
|
||||||
|
|
||||||
|
typename blocking_executor_op_base<Operation>::do_complete_cleanup
|
||||||
|
on_exit = { o };
|
||||||
|
(void)on_exit;
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*o));
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN(());
|
||||||
|
asio_handler_invoke_helpers::invoke(o->handler_, o->handler_);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler& handler_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BLOCKING_EXECUTOR_OP_HPP
|
||||||
|
|
@ -0,0 +1,66 @@
|
||||||
|
//
|
||||||
|
// detail/buffer_resize_guard.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
|
||||||
|
#define ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/limits.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper class to manage buffer resizing in an exception safe way.
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_resize_guard
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Constructor.
|
||||||
|
buffer_resize_guard(Buffer& buffer)
|
||||||
|
: buffer_(buffer),
|
||||||
|
old_size_(buffer.size())
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destructor rolls back the buffer resize unless commit was called.
|
||||||
|
~buffer_resize_guard()
|
||||||
|
{
|
||||||
|
if (old_size_ != (std::numeric_limits<size_t>::max)())
|
||||||
|
{
|
||||||
|
buffer_.resize(old_size_);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Commit the resize transaction.
|
||||||
|
void commit()
|
||||||
|
{
|
||||||
|
old_size_ = (std::numeric_limits<size_t>::max)();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// The buffer being managed.
|
||||||
|
Buffer& buffer_;
|
||||||
|
|
||||||
|
// The size of the buffer at the time the guard was constructed.
|
||||||
|
size_t old_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BUFFER_RESIZE_GUARD_HPP
|
||||||
|
|
@ -0,0 +1,841 @@
|
||||||
|
//
|
||||||
|
// detail/buffer_sequence_adapter.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
|
||||||
|
#define ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/array_fwd.hpp"
|
||||||
|
#include "asio/detail/socket_types.hpp"
|
||||||
|
#include "asio/registered_buffer.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
public:
|
||||||
|
// The maximum number of buffers to support in a single operation.
|
||||||
|
enum { max_buffers = 1 };
|
||||||
|
|
||||||
|
protected:
|
||||||
|
typedef Windows::Storage::Streams::IBuffer^ native_buffer_type;
|
||||||
|
|
||||||
|
ASIO_DECL static void init_native_buffer(
|
||||||
|
native_buffer_type& buf,
|
||||||
|
const asio::mutable_buffer& buffer);
|
||||||
|
|
||||||
|
ASIO_DECL static void init_native_buffer(
|
||||||
|
native_buffer_type& buf,
|
||||||
|
const asio::const_buffer& buffer);
|
||||||
|
#elif defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||||
|
public:
|
||||||
|
// The maximum number of buffers to support in a single operation.
|
||||||
|
enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
|
||||||
|
|
||||||
|
protected:
|
||||||
|
typedef WSABUF native_buffer_type;
|
||||||
|
|
||||||
|
static void init_native_buffer(WSABUF& buf,
|
||||||
|
const asio::mutable_buffer& buffer)
|
||||||
|
{
|
||||||
|
buf.buf = static_cast<char*>(buffer.data());
|
||||||
|
buf.len = static_cast<ULONG>(buffer.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
static void init_native_buffer(WSABUF& buf,
|
||||||
|
const asio::const_buffer& buffer)
|
||||||
|
{
|
||||||
|
buf.buf = const_cast<char*>(static_cast<const char*>(buffer.data()));
|
||||||
|
buf.len = static_cast<ULONG>(buffer.size());
|
||||||
|
}
|
||||||
|
#else // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||||
|
public:
|
||||||
|
// The maximum number of buffers to support in a single operation.
|
||||||
|
enum { max_buffers = 64 < max_iov_len ? 64 : max_iov_len };
|
||||||
|
|
||||||
|
protected:
|
||||||
|
typedef iovec native_buffer_type;
|
||||||
|
|
||||||
|
static void init_iov_base(void*& base, void* addr)
|
||||||
|
{
|
||||||
|
base = addr;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename T>
|
||||||
|
static void init_iov_base(T& base, void* addr)
|
||||||
|
{
|
||||||
|
base = static_cast<T>(addr);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void init_native_buffer(iovec& iov,
|
||||||
|
const asio::mutable_buffer& buffer)
|
||||||
|
{
|
||||||
|
init_iov_base(iov.iov_base, buffer.data());
|
||||||
|
iov.iov_len = buffer.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
static void init_native_buffer(iovec& iov,
|
||||||
|
const asio::const_buffer& buffer)
|
||||||
|
{
|
||||||
|
init_iov_base(iov.iov_base, const_cast<void*>(buffer.data()));
|
||||||
|
iov.iov_len = buffer.size();
|
||||||
|
}
|
||||||
|
#endif // defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper class to translate buffers into the native buffer representation.
|
||||||
|
template <typename Buffer, typename Buffers>
|
||||||
|
class buffer_sequence_adapter
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = false };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(const Buffers& buffer_sequence)
|
||||||
|
: count_(0), total_buffer_size_(0)
|
||||||
|
{
|
||||||
|
buffer_sequence_adapter::init(
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return buffers_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return count_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const Buffers& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence_adapter::all_empty(
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const Buffers& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence_adapter::validate(
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const Buffers& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence_adapter::first(
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 8192 };
|
||||||
|
|
||||||
|
static Buffer linearise(const Buffers& buffer_sequence,
|
||||||
|
const asio::mutable_buffer& storage)
|
||||||
|
{
|
||||||
|
return buffer_sequence_adapter::linearise(
|
||||||
|
asio::buffer_sequence_begin(buffer_sequence),
|
||||||
|
asio::buffer_sequence_end(buffer_sequence), storage);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
template <typename Iterator>
|
||||||
|
void init(Iterator begin, Iterator end)
|
||||||
|
{
|
||||||
|
Iterator iter = begin;
|
||||||
|
for (; iter != end && count_ < max_buffers; ++iter, ++count_)
|
||||||
|
{
|
||||||
|
Buffer buffer(*iter);
|
||||||
|
init_native_buffer(buffers_[count_], buffer);
|
||||||
|
total_buffer_size_ += buffer.size();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Iterator>
|
||||||
|
static bool all_empty(Iterator begin, Iterator end)
|
||||||
|
{
|
||||||
|
Iterator iter = begin;
|
||||||
|
std::size_t i = 0;
|
||||||
|
for (; iter != end && i < max_buffers; ++iter, ++i)
|
||||||
|
if (Buffer(*iter).size() > 0)
|
||||||
|
return false;
|
||||||
|
return true;
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Iterator>
|
||||||
|
static void validate(Iterator begin, Iterator end)
|
||||||
|
{
|
||||||
|
Iterator iter = begin;
|
||||||
|
for (; iter != end; ++iter)
|
||||||
|
{
|
||||||
|
Buffer buffer(*iter);
|
||||||
|
buffer.data();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Iterator>
|
||||||
|
static Buffer first(Iterator begin, Iterator end)
|
||||||
|
{
|
||||||
|
Iterator iter = begin;
|
||||||
|
for (; iter != end; ++iter)
|
||||||
|
{
|
||||||
|
Buffer buffer(*iter);
|
||||||
|
if (buffer.size() != 0)
|
||||||
|
return buffer;
|
||||||
|
}
|
||||||
|
return Buffer();
|
||||||
|
}
|
||||||
|
|
||||||
|
template <typename Iterator>
|
||||||
|
static Buffer linearise(Iterator begin, Iterator end,
|
||||||
|
const asio::mutable_buffer& storage)
|
||||||
|
{
|
||||||
|
asio::mutable_buffer unused_storage = storage;
|
||||||
|
Iterator iter = begin;
|
||||||
|
while (iter != end && unused_storage.size() != 0)
|
||||||
|
{
|
||||||
|
Buffer buffer(*iter);
|
||||||
|
++iter;
|
||||||
|
if (buffer.size() == 0)
|
||||||
|
continue;
|
||||||
|
if (unused_storage.size() == storage.size())
|
||||||
|
{
|
||||||
|
if (iter == end)
|
||||||
|
return buffer;
|
||||||
|
if (buffer.size() >= unused_storage.size())
|
||||||
|
return buffer;
|
||||||
|
}
|
||||||
|
unused_storage += asio::buffer_copy(unused_storage, buffer);
|
||||||
|
}
|
||||||
|
return Buffer(storage.data(), storage.size() - unused_storage.size());
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type buffers_[max_buffers];
|
||||||
|
std::size_t count_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::mutable_buffer>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::mutable_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, Buffer(buffer_sequence));
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const asio::mutable_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const asio::mutable_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const asio::mutable_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(const asio::mutable_buffer& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::const_buffer>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::const_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, Buffer(buffer_sequence));
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const asio::const_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const asio::const_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const asio::const_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(const asio::const_buffer& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::mutable_buffers_1>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::mutable_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, Buffer(buffer_sequence));
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const asio::mutable_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const asio::mutable_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const asio::mutable_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(const asio::mutable_buffers_1& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::const_buffers_1>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::const_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, Buffer(buffer_sequence));
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const asio::const_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const asio::const_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const asio::const_buffers_1& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(const asio::const_buffers_1& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::mutable_registered_buffer>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = true };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::mutable_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, buffer_sequence.buffer());
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
registered_id_ = buffer_sequence.id();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_id_;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(
|
||||||
|
const asio::mutable_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(
|
||||||
|
const asio::mutable_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(
|
||||||
|
const asio::mutable_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence.buffer());
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(
|
||||||
|
const asio::mutable_registered_buffer& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence.buffer());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
registered_buffer_id registered_id_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer>
|
||||||
|
class buffer_sequence_adapter<Buffer, asio::const_registered_buffer>
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = true };
|
||||||
|
enum { is_registered_buffer = true };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const asio::const_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffer_, buffer_sequence.buffer());
|
||||||
|
total_buffer_size_ = buffer_sequence.size();
|
||||||
|
registered_id_ = buffer_sequence.id();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return &buffer_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_id_;
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(
|
||||||
|
const asio::const_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence.size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(
|
||||||
|
const asio::const_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence.data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(
|
||||||
|
const asio::const_registered_buffer& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence.buffer());
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 1 };
|
||||||
|
|
||||||
|
static Buffer linearise(
|
||||||
|
const asio::const_registered_buffer& buffer_sequence,
|
||||||
|
const Buffer&)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence.buffer());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffer_;
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
registered_buffer_id registered_id_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer, typename Elem>
|
||||||
|
class buffer_sequence_adapter<Buffer, boost::array<Elem, 2> >
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = false };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const boost::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
|
||||||
|
init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
|
||||||
|
total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return buffers_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const boost::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const boost::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence[0].data();
|
||||||
|
buffer_sequence[1].data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const boost::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence[0].size() != 0
|
||||||
|
? buffer_sequence[0] : buffer_sequence[1]);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 8192 };
|
||||||
|
|
||||||
|
static Buffer linearise(const boost::array<Elem, 2>& buffer_sequence,
|
||||||
|
const asio::mutable_buffer& storage)
|
||||||
|
{
|
||||||
|
if (buffer_sequence[0].size() == 0)
|
||||||
|
return Buffer(buffer_sequence[1]);
|
||||||
|
if (buffer_sequence[1].size() == 0)
|
||||||
|
return Buffer(buffer_sequence[0]);
|
||||||
|
return Buffer(storage.data(),
|
||||||
|
asio::buffer_copy(storage, buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffers_[2];
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
template <typename Buffer, typename Elem>
|
||||||
|
class buffer_sequence_adapter<Buffer, std::array<Elem, 2> >
|
||||||
|
: buffer_sequence_adapter_base
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum { is_single_buffer = false };
|
||||||
|
enum { is_registered_buffer = false };
|
||||||
|
|
||||||
|
explicit buffer_sequence_adapter(
|
||||||
|
const std::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
init_native_buffer(buffers_[0], Buffer(buffer_sequence[0]));
|
||||||
|
init_native_buffer(buffers_[1], Buffer(buffer_sequence[1]));
|
||||||
|
total_buffer_size_ = buffer_sequence[0].size() + buffer_sequence[1].size();
|
||||||
|
}
|
||||||
|
|
||||||
|
native_buffer_type* buffers()
|
||||||
|
{
|
||||||
|
return buffers_;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t count() const
|
||||||
|
{
|
||||||
|
return 2;
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_size() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
registered_buffer_id registered_id() const
|
||||||
|
{
|
||||||
|
return registered_buffer_id();
|
||||||
|
}
|
||||||
|
|
||||||
|
bool all_empty() const
|
||||||
|
{
|
||||||
|
return total_buffer_size_ == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static bool all_empty(const std::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
return buffer_sequence[0].size() == 0 && buffer_sequence[1].size() == 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
static void validate(const std::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
buffer_sequence[0].data();
|
||||||
|
buffer_sequence[1].data();
|
||||||
|
}
|
||||||
|
|
||||||
|
static Buffer first(const std::array<Elem, 2>& buffer_sequence)
|
||||||
|
{
|
||||||
|
return Buffer(buffer_sequence[0].size() != 0
|
||||||
|
? buffer_sequence[0] : buffer_sequence[1]);
|
||||||
|
}
|
||||||
|
|
||||||
|
enum { linearisation_storage_size = 8192 };
|
||||||
|
|
||||||
|
static Buffer linearise(const std::array<Elem, 2>& buffer_sequence,
|
||||||
|
const asio::mutable_buffer& storage)
|
||||||
|
{
|
||||||
|
if (buffer_sequence[0].size() == 0)
|
||||||
|
return Buffer(buffer_sequence[1]);
|
||||||
|
if (buffer_sequence[1].size() == 0)
|
||||||
|
return Buffer(buffer_sequence[0]);
|
||||||
|
return Buffer(storage.data(),
|
||||||
|
asio::buffer_copy(storage, buffer_sequence));
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
native_buffer_type buffers_[2];
|
||||||
|
std::size_t total_buffer_size_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/detail/impl/buffer_sequence_adapter.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BUFFER_SEQUENCE_ADAPTER_HPP
|
||||||
|
|
@ -0,0 +1,126 @@
|
||||||
|
//
|
||||||
|
// detail/buffered_stream_storage.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
|
||||||
|
#define ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/assert.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include <cstring>
|
||||||
|
#include <vector>
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class buffered_stream_storage
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// The type of the bytes stored in the buffer.
|
||||||
|
typedef unsigned char byte_type;
|
||||||
|
|
||||||
|
// The type used for offsets into the buffer.
|
||||||
|
typedef std::size_t size_type;
|
||||||
|
|
||||||
|
// Constructor.
|
||||||
|
explicit buffered_stream_storage(std::size_t buffer_capacity)
|
||||||
|
: begin_offset_(0),
|
||||||
|
end_offset_(0),
|
||||||
|
buffer_(buffer_capacity)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Clear the buffer.
|
||||||
|
void clear()
|
||||||
|
{
|
||||||
|
begin_offset_ = 0;
|
||||||
|
end_offset_ = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return a pointer to the beginning of the unread data.
|
||||||
|
mutable_buffer data()
|
||||||
|
{
|
||||||
|
return asio::buffer(buffer_) + begin_offset_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return a pointer to the beginning of the unread data.
|
||||||
|
const_buffer data() const
|
||||||
|
{
|
||||||
|
return asio::buffer(buffer_) + begin_offset_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Is there no unread data in the buffer.
|
||||||
|
bool empty() const
|
||||||
|
{
|
||||||
|
return begin_offset_ == end_offset_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return the amount of unread data the is in the buffer.
|
||||||
|
size_type size() const
|
||||||
|
{
|
||||||
|
return end_offset_ - begin_offset_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Resize the buffer to the specified length.
|
||||||
|
void resize(size_type length)
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(length <= capacity());
|
||||||
|
if (begin_offset_ + length <= capacity())
|
||||||
|
{
|
||||||
|
end_offset_ = begin_offset_ + length;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
using namespace std; // For memmove.
|
||||||
|
memmove(&buffer_[0], &buffer_[0] + begin_offset_, size());
|
||||||
|
end_offset_ = length;
|
||||||
|
begin_offset_ = 0;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Return the maximum size for data in the buffer.
|
||||||
|
size_type capacity() const
|
||||||
|
{
|
||||||
|
return buffer_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Consume multiple bytes from the beginning of the buffer.
|
||||||
|
void consume(size_type count)
|
||||||
|
{
|
||||||
|
ASIO_ASSERT(begin_offset_ + count <= end_offset_);
|
||||||
|
begin_offset_ += count;
|
||||||
|
if (empty())
|
||||||
|
clear();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// The offset to the beginning of the unread data.
|
||||||
|
size_type begin_offset_;
|
||||||
|
|
||||||
|
// The offset to the end of the unread data.
|
||||||
|
size_type end_offset_;
|
||||||
|
|
||||||
|
// The data in the buffer.
|
||||||
|
std::vector<byte_type> buffer_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BUFFERED_STREAM_STORAGE_HPP
|
||||||
|
|
@ -0,0 +1,88 @@
|
||||||
|
//
|
||||||
|
// detail/bulk_executor_op.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_BULK_EXECUTOR_OP_HPP
|
||||||
|
#define ASIO_DETAIL_BULK_EXECUTOR_OP_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_alloc_helpers.hpp"
|
||||||
|
#include "asio/detail/handler_invoke_helpers.hpp"
|
||||||
|
#include "asio/detail/scheduler_operation.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Handler, typename Alloc,
|
||||||
|
typename Operation = scheduler_operation>
|
||||||
|
class bulk_executor_op : public Operation
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(bulk_executor_op);
|
||||||
|
|
||||||
|
template <typename H>
|
||||||
|
bulk_executor_op(ASIO_MOVE_ARG(H) h,
|
||||||
|
const Alloc& allocator, std::size_t i)
|
||||||
|
: Operation(&bulk_executor_op::do_complete),
|
||||||
|
handler_(ASIO_MOVE_CAST(H)(h)),
|
||||||
|
allocator_(allocator),
|
||||||
|
index_(i)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, Operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
// Take ownership of the handler object.
|
||||||
|
bulk_executor_op* o(static_cast<bulk_executor_op*>(base));
|
||||||
|
Alloc allocator(o->allocator_);
|
||||||
|
ptr p = { detail::addressof(allocator), o, o };
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*o));
|
||||||
|
|
||||||
|
// Make a copy of the handler so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the handler may be the true owner of the memory associated
|
||||||
|
// with the handler. Consequently, a local copy of the handler is required
|
||||||
|
// to ensure that any owning sub-object remains valid until after we have
|
||||||
|
// deallocated the memory here.
|
||||||
|
detail::binder1<Handler, std::size_t> handler(o->handler_, o->index_);
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN(());
|
||||||
|
asio_handler_invoke_helpers::invoke(handler, handler.handler_);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler handler_;
|
||||||
|
Alloc allocator_;
|
||||||
|
std::size_t index_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_BULK_EXECUTOR_OP_HPP
|
||||||
|
|
@ -0,0 +1,125 @@
|
||||||
|
//
|
||||||
|
// detail/call_stack.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CALL_STACK_HPP
|
||||||
|
#define ASIO_DETAIL_CALL_STACK_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/tss_ptr.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper class to determine whether or not the current thread is inside an
|
||||||
|
// invocation of io_context::run() for a specified io_context object.
|
||||||
|
template <typename Key, typename Value = unsigned char>
|
||||||
|
class call_stack
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Context class automatically pushes the key/value pair on to the stack.
|
||||||
|
class context
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Push the key on to the stack.
|
||||||
|
explicit context(Key* k)
|
||||||
|
: key_(k),
|
||||||
|
next_(call_stack<Key, Value>::top_)
|
||||||
|
{
|
||||||
|
value_ = reinterpret_cast<unsigned char*>(this);
|
||||||
|
call_stack<Key, Value>::top_ = this;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Push the key/value pair on to the stack.
|
||||||
|
context(Key* k, Value& v)
|
||||||
|
: key_(k),
|
||||||
|
value_(&v),
|
||||||
|
next_(call_stack<Key, Value>::top_)
|
||||||
|
{
|
||||||
|
call_stack<Key, Value>::top_ = this;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Pop the key/value pair from the stack.
|
||||||
|
~context()
|
||||||
|
{
|
||||||
|
call_stack<Key, Value>::top_ = next_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Find the next context with the same key.
|
||||||
|
Value* next_by_key() const
|
||||||
|
{
|
||||||
|
context* elem = next_;
|
||||||
|
while (elem)
|
||||||
|
{
|
||||||
|
if (elem->key_ == key_)
|
||||||
|
return elem->value_;
|
||||||
|
elem = elem->next_;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class call_stack<Key, Value>;
|
||||||
|
|
||||||
|
// The key associated with the context.
|
||||||
|
Key* key_;
|
||||||
|
|
||||||
|
// The value associated with the context.
|
||||||
|
Value* value_;
|
||||||
|
|
||||||
|
// The next element in the stack.
|
||||||
|
context* next_;
|
||||||
|
};
|
||||||
|
|
||||||
|
friend class context;
|
||||||
|
|
||||||
|
// Determine whether the specified owner is on the stack. Returns address of
|
||||||
|
// key if present, 0 otherwise.
|
||||||
|
static Value* contains(Key* k)
|
||||||
|
{
|
||||||
|
context* elem = top_;
|
||||||
|
while (elem)
|
||||||
|
{
|
||||||
|
if (elem->key_ == k)
|
||||||
|
return elem->value_;
|
||||||
|
elem = elem->next_;
|
||||||
|
}
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Obtain the value at the top of the stack.
|
||||||
|
static Value* top()
|
||||||
|
{
|
||||||
|
context* elem = top_;
|
||||||
|
return elem ? elem->value_ : 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// The top of the stack of calls for the current thread.
|
||||||
|
static tss_ptr<context> top_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Key, typename Value>
|
||||||
|
tss_ptr<typename call_stack<Key, Value>::context>
|
||||||
|
call_stack<Key, Value>::top_;
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CALL_STACK_HPP
|
||||||
|
|
@ -0,0 +1,66 @@
|
||||||
|
//
|
||||||
|
// detail/chrono.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CHRONO_HPP
|
||||||
|
#define ASIO_DETAIL_CHRONO_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_CHRONO)
|
||||||
|
# include <chrono>
|
||||||
|
#elif defined(ASIO_HAS_BOOST_CHRONO)
|
||||||
|
# include <boost/chrono/system_clocks.hpp>
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_CHRONO)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace chrono {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_CHRONO)
|
||||||
|
using std::chrono::duration;
|
||||||
|
using std::chrono::time_point;
|
||||||
|
using std::chrono::duration_cast;
|
||||||
|
using std::chrono::nanoseconds;
|
||||||
|
using std::chrono::microseconds;
|
||||||
|
using std::chrono::milliseconds;
|
||||||
|
using std::chrono::seconds;
|
||||||
|
using std::chrono::minutes;
|
||||||
|
using std::chrono::hours;
|
||||||
|
using std::chrono::time_point_cast;
|
||||||
|
#if defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
|
||||||
|
typedef std::chrono::monotonic_clock steady_clock;
|
||||||
|
#else // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
|
||||||
|
using std::chrono::steady_clock;
|
||||||
|
#endif // defined(ASIO_HAS_STD_CHRONO_MONOTONIC_CLOCK)
|
||||||
|
using std::chrono::system_clock;
|
||||||
|
using std::chrono::high_resolution_clock;
|
||||||
|
#elif defined(ASIO_HAS_BOOST_CHRONO)
|
||||||
|
using boost::chrono::duration;
|
||||||
|
using boost::chrono::time_point;
|
||||||
|
using boost::chrono::duration_cast;
|
||||||
|
using boost::chrono::nanoseconds;
|
||||||
|
using boost::chrono::microseconds;
|
||||||
|
using boost::chrono::milliseconds;
|
||||||
|
using boost::chrono::seconds;
|
||||||
|
using boost::chrono::minutes;
|
||||||
|
using boost::chrono::hours;
|
||||||
|
using boost::chrono::time_point_cast;
|
||||||
|
using boost::chrono::system_clock;
|
||||||
|
using boost::chrono::steady_clock;
|
||||||
|
using boost::chrono::high_resolution_clock;
|
||||||
|
#endif // defined(ASIO_HAS_BOOST_CHRONO)
|
||||||
|
|
||||||
|
} // namespace chrono
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CHRONO_HPP
|
||||||
|
|
@ -0,0 +1,190 @@
|
||||||
|
//
|
||||||
|
// detail/chrono_time_traits.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
|
||||||
|
#define ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/cstdint.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper template to compute the greatest common divisor.
|
||||||
|
template <int64_t v1, int64_t v2>
|
||||||
|
struct gcd { enum { value = gcd<v2, v1 % v2>::value }; };
|
||||||
|
|
||||||
|
template <int64_t v1>
|
||||||
|
struct gcd<v1, 0> { enum { value = v1 }; };
|
||||||
|
|
||||||
|
// Adapts std::chrono clocks for use with a deadline timer.
|
||||||
|
template <typename Clock, typename WaitTraits>
|
||||||
|
struct chrono_time_traits
|
||||||
|
{
|
||||||
|
// The clock type.
|
||||||
|
typedef Clock clock_type;
|
||||||
|
|
||||||
|
// The duration type of the clock.
|
||||||
|
typedef typename clock_type::duration duration_type;
|
||||||
|
|
||||||
|
// The time point type of the clock.
|
||||||
|
typedef typename clock_type::time_point time_type;
|
||||||
|
|
||||||
|
// The period of the clock.
|
||||||
|
typedef typename duration_type::period period_type;
|
||||||
|
|
||||||
|
// Get the current time.
|
||||||
|
static time_type now()
|
||||||
|
{
|
||||||
|
return clock_type::now();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Add a duration to a time.
|
||||||
|
static time_type add(const time_type& t, const duration_type& d)
|
||||||
|
{
|
||||||
|
const time_type epoch;
|
||||||
|
if (t >= epoch)
|
||||||
|
{
|
||||||
|
if ((time_type::max)() - t < d)
|
||||||
|
return (time_type::max)();
|
||||||
|
}
|
||||||
|
else // t < epoch
|
||||||
|
{
|
||||||
|
if (-(t - (time_type::min)()) > d)
|
||||||
|
return (time_type::min)();
|
||||||
|
}
|
||||||
|
|
||||||
|
return t + d;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Subtract one time from another.
|
||||||
|
static duration_type subtract(const time_type& t1, const time_type& t2)
|
||||||
|
{
|
||||||
|
const time_type epoch;
|
||||||
|
if (t1 >= epoch)
|
||||||
|
{
|
||||||
|
if (t2 >= epoch)
|
||||||
|
{
|
||||||
|
return t1 - t2;
|
||||||
|
}
|
||||||
|
else if (t2 == (time_type::min)())
|
||||||
|
{
|
||||||
|
return (duration_type::max)();
|
||||||
|
}
|
||||||
|
else if ((time_type::max)() - t1 < epoch - t2)
|
||||||
|
{
|
||||||
|
return (duration_type::max)();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return t1 - t2;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
else // t1 < epoch
|
||||||
|
{
|
||||||
|
if (t2 < epoch)
|
||||||
|
{
|
||||||
|
return t1 - t2;
|
||||||
|
}
|
||||||
|
else if (t1 == (time_type::min)())
|
||||||
|
{
|
||||||
|
return (duration_type::min)();
|
||||||
|
}
|
||||||
|
else if ((time_type::max)() - t2 < epoch - t1)
|
||||||
|
{
|
||||||
|
return (duration_type::min)();
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
return -(t2 - t1);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test whether one time is less than another.
|
||||||
|
static bool less_than(const time_type& t1, const time_type& t2)
|
||||||
|
{
|
||||||
|
return t1 < t2;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Implement just enough of the posix_time::time_duration interface to supply
|
||||||
|
// what the timer_queue requires.
|
||||||
|
class posix_time_duration
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit posix_time_duration(const duration_type& d)
|
||||||
|
: d_(d)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
int64_t ticks() const
|
||||||
|
{
|
||||||
|
return d_.count();
|
||||||
|
}
|
||||||
|
|
||||||
|
int64_t total_seconds() const
|
||||||
|
{
|
||||||
|
return duration_cast<1, 1>();
|
||||||
|
}
|
||||||
|
|
||||||
|
int64_t total_milliseconds() const
|
||||||
|
{
|
||||||
|
return duration_cast<1, 1000>();
|
||||||
|
}
|
||||||
|
|
||||||
|
int64_t total_microseconds() const
|
||||||
|
{
|
||||||
|
return duration_cast<1, 1000000>();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
template <int64_t Num, int64_t Den>
|
||||||
|
int64_t duration_cast() const
|
||||||
|
{
|
||||||
|
const int64_t num1 = period_type::num / gcd<period_type::num, Num>::value;
|
||||||
|
const int64_t num2 = Num / gcd<period_type::num, Num>::value;
|
||||||
|
|
||||||
|
const int64_t den1 = period_type::den / gcd<period_type::den, Den>::value;
|
||||||
|
const int64_t den2 = Den / gcd<period_type::den, Den>::value;
|
||||||
|
|
||||||
|
const int64_t num = num1 * den2;
|
||||||
|
const int64_t den = num2 * den1;
|
||||||
|
|
||||||
|
if (num == 1 && den == 1)
|
||||||
|
return ticks();
|
||||||
|
else if (num != 1 && den == 1)
|
||||||
|
return ticks() * num;
|
||||||
|
else if (num == 1 && period_type::den != 1)
|
||||||
|
return ticks() / den;
|
||||||
|
else
|
||||||
|
return ticks() * num / den;
|
||||||
|
}
|
||||||
|
|
||||||
|
duration_type d_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Convert to POSIX duration type.
|
||||||
|
static posix_time_duration to_posix_duration(const duration_type& d)
|
||||||
|
{
|
||||||
|
return posix_time_duration(WaitTraits::to_wait_duration(d));
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CHRONO_TIME_TRAITS_HPP
|
||||||
|
|
@ -0,0 +1,88 @@
|
||||||
|
//
|
||||||
|
// detail/completion_handler.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_COMPLETION_HANDLER_HPP
|
||||||
|
#define ASIO_DETAIL_COMPLETION_HANDLER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_alloc_helpers.hpp"
|
||||||
|
#include "asio/detail/handler_work.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/detail/operation.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Handler, typename IoExecutor>
|
||||||
|
class completion_handler : public operation
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_DEFINE_HANDLER_PTR(completion_handler);
|
||||||
|
|
||||||
|
completion_handler(Handler& h, const IoExecutor& io_ex)
|
||||||
|
: operation(&completion_handler::do_complete),
|
||||||
|
handler_(ASIO_MOVE_CAST(Handler)(h)),
|
||||||
|
work_(handler_, io_ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
// Take ownership of the handler object.
|
||||||
|
completion_handler* h(static_cast<completion_handler*>(base));
|
||||||
|
ptr p = { asio::detail::addressof(h->handler_), h, h };
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*h));
|
||||||
|
|
||||||
|
// Take ownership of the operation's outstanding work.
|
||||||
|
handler_work<Handler, IoExecutor> w(
|
||||||
|
ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
|
||||||
|
h->work_));
|
||||||
|
|
||||||
|
// Make a copy of the handler so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the handler may be the true owner of the memory associated
|
||||||
|
// with the handler. Consequently, a local copy of the handler is required
|
||||||
|
// to ensure that any owning sub-object remains valid until after we have
|
||||||
|
// deallocated the memory here.
|
||||||
|
Handler handler(ASIO_MOVE_CAST(Handler)(h->handler_));
|
||||||
|
p.h = asio::detail::addressof(handler);
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN(());
|
||||||
|
w.complete(handler, handler);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler handler_;
|
||||||
|
handler_work<Handler, IoExecutor> work_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_COMPLETION_HANDLER_HPP
|
||||||
|
|
@ -0,0 +1,94 @@
|
||||||
|
//
|
||||||
|
// detail/concurrency_hint.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CONCURRENCY_HINT_HPP
|
||||||
|
#define ASIO_DETAIL_CONCURRENCY_HINT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
|
||||||
|
// The concurrency hint ID and mask are used to identify when a "well-known"
|
||||||
|
// concurrency hint value has been passed to the io_context.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_ID 0xA5100000u
|
||||||
|
#define ASIO_CONCURRENCY_HINT_ID_MASK 0xFFFF0000u
|
||||||
|
|
||||||
|
// If set, this bit indicates that the scheduler should perform locking.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER 0x1u
|
||||||
|
|
||||||
|
// If set, this bit indicates that the reactor should perform locking when
|
||||||
|
// managing descriptor registrations.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION 0x2u
|
||||||
|
|
||||||
|
// If set, this bit indicates that the reactor should perform locking for I/O.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO 0x4u
|
||||||
|
|
||||||
|
// Helper macro to determine if we have a special concurrency hint.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_IS_SPECIAL(hint) \
|
||||||
|
((static_cast<unsigned>(hint) \
|
||||||
|
& ASIO_CONCURRENCY_HINT_ID_MASK) \
|
||||||
|
== ASIO_CONCURRENCY_HINT_ID)
|
||||||
|
|
||||||
|
// Helper macro to determine if locking is enabled for a given facility.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_IS_LOCKING(facility, hint) \
|
||||||
|
(((static_cast<unsigned>(hint) \
|
||||||
|
& (ASIO_CONCURRENCY_HINT_ID_MASK \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_ ## facility)) \
|
||||||
|
^ ASIO_CONCURRENCY_HINT_ID) != 0)
|
||||||
|
|
||||||
|
// This special concurrency hint disables locking in both the scheduler and
|
||||||
|
// reactor I/O. This hint has the following restrictions:
|
||||||
|
//
|
||||||
|
// - Care must be taken to ensure that all operations on the io_context and any
|
||||||
|
// of its associated I/O objects (such as sockets and timers) occur in only
|
||||||
|
// one thread at a time.
|
||||||
|
//
|
||||||
|
// - Asynchronous resolve operations fail with operation_not_supported.
|
||||||
|
//
|
||||||
|
// - If a signal_set is used with the io_context, signal_set objects cannot be
|
||||||
|
// used with any other io_context in the program.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_UNSAFE \
|
||||||
|
static_cast<int>(ASIO_CONCURRENCY_HINT_ID)
|
||||||
|
|
||||||
|
// This special concurrency hint disables locking in the reactor I/O. This hint
|
||||||
|
// has the following restrictions:
|
||||||
|
//
|
||||||
|
// - Care must be taken to ensure that run functions on the io_context, and all
|
||||||
|
// operations on the io_context's associated I/O objects (such as sockets and
|
||||||
|
// timers), occur in only one thread at a time.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_UNSAFE_IO \
|
||||||
|
static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION)
|
||||||
|
|
||||||
|
// The special concurrency hint provides full thread safety.
|
||||||
|
#define ASIO_CONCURRENCY_HINT_SAFE \
|
||||||
|
static_cast<int>(ASIO_CONCURRENCY_HINT_ID \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_SCHEDULER \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_REGISTRATION \
|
||||||
|
| ASIO_CONCURRENCY_HINT_LOCKING_REACTOR_IO)
|
||||||
|
|
||||||
|
// This #define may be overridden at compile time to specify a program-wide
|
||||||
|
// default concurrency hint, used by the zero-argument io_context constructor.
|
||||||
|
#if !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
|
||||||
|
# define ASIO_CONCURRENCY_HINT_DEFAULT -1
|
||||||
|
#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
|
||||||
|
|
||||||
|
// This #define may be overridden at compile time to specify a program-wide
|
||||||
|
// concurrency hint, used by the one-argument io_context constructor when
|
||||||
|
// passed a value of 1.
|
||||||
|
#if !defined(ASIO_CONCURRENCY_HINT_1)
|
||||||
|
# define ASIO_CONCURRENCY_HINT_1 1
|
||||||
|
#endif // !defined(ASIO_CONCURRENCY_HINT_DEFAULT)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CONCURRENCY_HINT_HPP
|
||||||
|
|
@ -0,0 +1,120 @@
|
||||||
|
//
|
||||||
|
// detail/conditionally_enabled_event.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
|
||||||
|
#define ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/conditionally_enabled_mutex.hpp"
|
||||||
|
#include "asio/detail/event.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/null_event.hpp"
|
||||||
|
#include "asio/detail/scoped_lock.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Mutex adapter used to conditionally enable or disable locking.
|
||||||
|
class conditionally_enabled_event
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Constructor.
|
||||||
|
conditionally_enabled_event()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
~conditionally_enabled_event()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Signal the event. (Retained for backward compatibility.)
|
||||||
|
void signal(conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.signal(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Signal all waiters.
|
||||||
|
void signal_all(conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.signal_all(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Unlock the mutex and signal one waiter.
|
||||||
|
void unlock_and_signal_one(
|
||||||
|
conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.unlock_and_signal_one(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Unlock the mutex and signal one waiter who may destroy us.
|
||||||
|
void unlock_and_signal_one_for_destruction(
|
||||||
|
conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.unlock_and_signal_one(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// If there's a waiter, unlock the mutex and signal it.
|
||||||
|
bool maybe_unlock_and_signal_one(
|
||||||
|
conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
return event_.maybe_unlock_and_signal_one(lock);
|
||||||
|
else
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reset the event.
|
||||||
|
void clear(conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.clear(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait for the event to become signalled.
|
||||||
|
void wait(conditionally_enabled_mutex::scoped_lock& lock)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
event_.wait(lock);
|
||||||
|
else
|
||||||
|
null_event().wait(lock);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Timed wait for the event to become signalled.
|
||||||
|
bool wait_for_usec(
|
||||||
|
conditionally_enabled_mutex::scoped_lock& lock, long usec)
|
||||||
|
{
|
||||||
|
if (lock.mutex_.enabled_)
|
||||||
|
return event_.wait_for_usec(lock, usec);
|
||||||
|
else
|
||||||
|
return null_event().wait_for_usec(lock, usec);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
asio::detail::event event_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_EVENT_HPP
|
||||||
|
|
@ -0,0 +1,149 @@
|
||||||
|
//
|
||||||
|
// detail/conditionally_enabled_mutex.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
|
||||||
|
#define ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/mutex.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/scoped_lock.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Mutex adapter used to conditionally enable or disable locking.
|
||||||
|
class conditionally_enabled_mutex
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Helper class to lock and unlock a mutex automatically.
|
||||||
|
class scoped_lock
|
||||||
|
: private noncopyable
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Tag type used to distinguish constructors.
|
||||||
|
enum adopt_lock_t { adopt_lock };
|
||||||
|
|
||||||
|
// Constructor adopts a lock that is already held.
|
||||||
|
scoped_lock(conditionally_enabled_mutex& m, adopt_lock_t)
|
||||||
|
: mutex_(m),
|
||||||
|
locked_(m.enabled_)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Constructor acquires the lock.
|
||||||
|
explicit scoped_lock(conditionally_enabled_mutex& m)
|
||||||
|
: mutex_(m)
|
||||||
|
{
|
||||||
|
if (m.enabled_)
|
||||||
|
{
|
||||||
|
mutex_.mutex_.lock();
|
||||||
|
locked_ = true;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
locked_ = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destructor releases the lock.
|
||||||
|
~scoped_lock()
|
||||||
|
{
|
||||||
|
if (locked_)
|
||||||
|
mutex_.mutex_.unlock();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Explicitly acquire the lock.
|
||||||
|
void lock()
|
||||||
|
{
|
||||||
|
if (mutex_.enabled_ && !locked_)
|
||||||
|
{
|
||||||
|
mutex_.mutex_.lock();
|
||||||
|
locked_ = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Explicitly release the lock.
|
||||||
|
void unlock()
|
||||||
|
{
|
||||||
|
if (locked_)
|
||||||
|
{
|
||||||
|
mutex_.unlock();
|
||||||
|
locked_ = false;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Test whether the lock is held.
|
||||||
|
bool locked() const
|
||||||
|
{
|
||||||
|
return locked_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the underlying mutex.
|
||||||
|
asio::detail::mutex& mutex()
|
||||||
|
{
|
||||||
|
return mutex_.mutex_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class conditionally_enabled_event;
|
||||||
|
conditionally_enabled_mutex& mutex_;
|
||||||
|
bool locked_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Constructor.
|
||||||
|
explicit conditionally_enabled_mutex(bool enabled)
|
||||||
|
: enabled_(enabled)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
~conditionally_enabled_mutex()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine whether locking is enabled.
|
||||||
|
bool enabled() const
|
||||||
|
{
|
||||||
|
return enabled_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Lock the mutex.
|
||||||
|
void lock()
|
||||||
|
{
|
||||||
|
if (enabled_)
|
||||||
|
mutex_.lock();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Unlock the mutex.
|
||||||
|
void unlock()
|
||||||
|
{
|
||||||
|
if (enabled_)
|
||||||
|
mutex_.unlock();
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
friend class scoped_lock;
|
||||||
|
friend class conditionally_enabled_event;
|
||||||
|
asio::detail::mutex mutex_;
|
||||||
|
const bool enabled_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CONDITIONALLY_ENABLED_MUTEX_HPP
|
||||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,451 @@
|
||||||
|
//
|
||||||
|
// detail/consuming_buffers.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CONSUMING_BUFFERS_HPP
|
||||||
|
#define ASIO_DETAIL_CONSUMING_BUFFERS_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/buffer.hpp"
|
||||||
|
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||||
|
#include "asio/detail/limits.hpp"
|
||||||
|
#include "asio/registered_buffer.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
// Helper template to determine the maximum number of prepared buffers.
|
||||||
|
template <typename Buffers>
|
||||||
|
struct prepared_buffers_max
|
||||||
|
{
|
||||||
|
enum { value = buffer_sequence_adapter_base::max_buffers };
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Elem, std::size_t N>
|
||||||
|
struct prepared_buffers_max<boost::array<Elem, N> >
|
||||||
|
{
|
||||||
|
enum { value = N };
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
template <typename Elem, std::size_t N>
|
||||||
|
struct prepared_buffers_max<std::array<Elem, N> >
|
||||||
|
{
|
||||||
|
enum { value = N };
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
// A buffer sequence used to represent a subsequence of the buffers.
|
||||||
|
template <typename Buffer, std::size_t MaxBuffers>
|
||||||
|
struct prepared_buffers
|
||||||
|
{
|
||||||
|
typedef Buffer value_type;
|
||||||
|
typedef const Buffer* const_iterator;
|
||||||
|
|
||||||
|
enum { max_buffers = MaxBuffers < 16 ? MaxBuffers : 16 };
|
||||||
|
|
||||||
|
prepared_buffers() : count(0) {}
|
||||||
|
const_iterator begin() const { return elems; }
|
||||||
|
const_iterator end() const { return elems + count; }
|
||||||
|
|
||||||
|
Buffer elems[max_buffers];
|
||||||
|
std::size_t count;
|
||||||
|
};
|
||||||
|
|
||||||
|
// A proxy for a sub-range in a list of buffers.
|
||||||
|
template <typename Buffer, typename Buffers, typename Buffer_Iterator>
|
||||||
|
class consuming_buffers
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
typedef prepared_buffers<Buffer, prepared_buffers_max<Buffers>::value>
|
||||||
|
prepared_buffers_type;
|
||||||
|
|
||||||
|
// Construct to represent the entire list of buffers.
|
||||||
|
explicit consuming_buffers(const Buffers& buffers)
|
||||||
|
: buffers_(buffers),
|
||||||
|
total_consumed_(0),
|
||||||
|
next_elem_(0),
|
||||||
|
next_elem_offset_(0)
|
||||||
|
{
|
||||||
|
using asio::buffer_size;
|
||||||
|
total_size_ = buffer_size(buffers);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine if we are at the end of the buffers.
|
||||||
|
bool empty() const
|
||||||
|
{
|
||||||
|
return total_consumed_ >= total_size_;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the buffer for a single transfer, with a size.
|
||||||
|
prepared_buffers_type prepare(std::size_t max_size)
|
||||||
|
{
|
||||||
|
prepared_buffers_type result;
|
||||||
|
|
||||||
|
Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
|
||||||
|
Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
|
||||||
|
|
||||||
|
std::advance(next, next_elem_);
|
||||||
|
std::size_t elem_offset = next_elem_offset_;
|
||||||
|
while (next != end && max_size > 0 && (result.count) < result.max_buffers)
|
||||||
|
{
|
||||||
|
Buffer next_buf = Buffer(*next) + elem_offset;
|
||||||
|
result.elems[result.count] = asio::buffer(next_buf, max_size);
|
||||||
|
max_size -= result.elems[result.count].size();
|
||||||
|
elem_offset = 0;
|
||||||
|
if (result.elems[result.count].size() > 0)
|
||||||
|
++result.count;
|
||||||
|
++next;
|
||||||
|
}
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Consume the specified number of bytes from the buffers.
|
||||||
|
void consume(std::size_t size)
|
||||||
|
{
|
||||||
|
total_consumed_ += size;
|
||||||
|
|
||||||
|
Buffer_Iterator next = asio::buffer_sequence_begin(buffers_);
|
||||||
|
Buffer_Iterator end = asio::buffer_sequence_end(buffers_);
|
||||||
|
|
||||||
|
std::advance(next, next_elem_);
|
||||||
|
while (next != end && size > 0)
|
||||||
|
{
|
||||||
|
Buffer next_buf = Buffer(*next) + next_elem_offset_;
|
||||||
|
if (size < next_buf.size())
|
||||||
|
{
|
||||||
|
next_elem_offset_ += size;
|
||||||
|
size = 0;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
size -= next_buf.size();
|
||||||
|
next_elem_offset_ = 0;
|
||||||
|
++next_elem_;
|
||||||
|
++next;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the total number of bytes consumed from the buffers.
|
||||||
|
std::size_t total_consumed() const
|
||||||
|
{
|
||||||
|
return total_consumed_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Buffers buffers_;
|
||||||
|
std::size_t total_size_;
|
||||||
|
std::size_t total_consumed_;
|
||||||
|
std::size_t next_elem_;
|
||||||
|
std::size_t next_elem_offset_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Base class of all consuming_buffers specialisations for single buffers.
|
||||||
|
template <typename Buffer>
|
||||||
|
class consuming_single_buffer
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Construct to represent the entire list of buffers.
|
||||||
|
template <typename Buffer1>
|
||||||
|
explicit consuming_single_buffer(const Buffer1& buffer)
|
||||||
|
: buffer_(buffer),
|
||||||
|
total_consumed_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine if we are at the end of the buffers.
|
||||||
|
bool empty() const
|
||||||
|
{
|
||||||
|
return total_consumed_ >= buffer_.size();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the buffer for a single transfer, with a size.
|
||||||
|
Buffer prepare(std::size_t max_size)
|
||||||
|
{
|
||||||
|
return asio::buffer(buffer_ + total_consumed_, max_size);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Consume the specified number of bytes from the buffers.
|
||||||
|
void consume(std::size_t size)
|
||||||
|
{
|
||||||
|
total_consumed_ += size;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the total number of bytes consumed from the buffers.
|
||||||
|
std::size_t total_consumed() const
|
||||||
|
{
|
||||||
|
return total_consumed_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Buffer buffer_;
|
||||||
|
std::size_t total_consumed_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<mutable_buffer, mutable_buffer, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_buffer& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer, mutable_buffer, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_CONST_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_buffer& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer, const_buffer, const const_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_CONST_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const const_buffer& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#if !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<mutable_buffer,
|
||||||
|
mutable_buffers_1, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_MUTABLE_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_buffers_1& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_MUTABLE_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer, mutable_buffers_1, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_CONST_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_buffers_1& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer, const_buffers_1, const const_buffer*>
|
||||||
|
: public consuming_single_buffer<ASIO_CONST_BUFFER>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const const_buffers_1& buffer)
|
||||||
|
: consuming_single_buffer<ASIO_CONST_BUFFER>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_NO_DEPRECATED)
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<mutable_buffer,
|
||||||
|
mutable_registered_buffer, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<mutable_registered_buffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_registered_buffer& buffer)
|
||||||
|
: consuming_single_buffer<mutable_registered_buffer>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer,
|
||||||
|
mutable_registered_buffer, const mutable_buffer*>
|
||||||
|
: public consuming_single_buffer<mutable_registered_buffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const mutable_registered_buffer& buffer)
|
||||||
|
: consuming_single_buffer<mutable_registered_buffer>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <>
|
||||||
|
class consuming_buffers<const_buffer,
|
||||||
|
const_registered_buffer, const const_buffer*>
|
||||||
|
: public consuming_single_buffer<const_registered_buffer>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
explicit consuming_buffers(const const_registered_buffer& buffer)
|
||||||
|
: consuming_single_buffer<const_registered_buffer>(buffer)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename Buffer, typename Elem>
|
||||||
|
class consuming_buffers<Buffer, boost::array<Elem, 2>,
|
||||||
|
typename boost::array<Elem, 2>::const_iterator>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Construct to represent the entire list of buffers.
|
||||||
|
explicit consuming_buffers(const boost::array<Elem, 2>& buffers)
|
||||||
|
: buffers_(buffers),
|
||||||
|
total_consumed_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine if we are at the end of the buffers.
|
||||||
|
bool empty() const
|
||||||
|
{
|
||||||
|
return total_consumed_ >=
|
||||||
|
Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the buffer for a single transfer, with a size.
|
||||||
|
boost::array<Buffer, 2> prepare(std::size_t max_size)
|
||||||
|
{
|
||||||
|
boost::array<Buffer, 2> result = {{
|
||||||
|
Buffer(buffers_[0]), Buffer(buffers_[1]) }};
|
||||||
|
std::size_t buffer0_size = result[0].size();
|
||||||
|
result[0] = asio::buffer(result[0] + total_consumed_, max_size);
|
||||||
|
result[1] = asio::buffer(
|
||||||
|
result[1] + (total_consumed_ < buffer0_size
|
||||||
|
? 0 : total_consumed_ - buffer0_size),
|
||||||
|
max_size - result[0].size());
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Consume the specified number of bytes from the buffers.
|
||||||
|
void consume(std::size_t size)
|
||||||
|
{
|
||||||
|
total_consumed_ += size;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the total number of bytes consumed from the buffers.
|
||||||
|
std::size_t total_consumed() const
|
||||||
|
{
|
||||||
|
return total_consumed_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
boost::array<Elem, 2> buffers_;
|
||||||
|
std::size_t total_consumed_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
template <typename Buffer, typename Elem>
|
||||||
|
class consuming_buffers<Buffer, std::array<Elem, 2>,
|
||||||
|
typename std::array<Elem, 2>::const_iterator>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Construct to represent the entire list of buffers.
|
||||||
|
explicit consuming_buffers(const std::array<Elem, 2>& buffers)
|
||||||
|
: buffers_(buffers),
|
||||||
|
total_consumed_(0)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Determine if we are at the end of the buffers.
|
||||||
|
bool empty() const
|
||||||
|
{
|
||||||
|
return total_consumed_ >=
|
||||||
|
Buffer(buffers_[0]).size() + Buffer(buffers_[1]).size();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the buffer for a single transfer, with a size.
|
||||||
|
std::array<Buffer, 2> prepare(std::size_t max_size)
|
||||||
|
{
|
||||||
|
std::array<Buffer, 2> result = {{
|
||||||
|
Buffer(buffers_[0]), Buffer(buffers_[1]) }};
|
||||||
|
std::size_t buffer0_size = result[0].size();
|
||||||
|
result[0] = asio::buffer(result[0] + total_consumed_, max_size);
|
||||||
|
result[1] = asio::buffer(
|
||||||
|
result[1] + (total_consumed_ < buffer0_size
|
||||||
|
? 0 : total_consumed_ - buffer0_size),
|
||||||
|
max_size - result[0].size());
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Consume the specified number of bytes from the buffers.
|
||||||
|
void consume(std::size_t size)
|
||||||
|
{
|
||||||
|
total_consumed_ += size;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the total number of bytes consumed from the buffers.
|
||||||
|
std::size_t total_consumed() const
|
||||||
|
{
|
||||||
|
return total_consumed_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
std::array<Elem, 2> buffers_;
|
||||||
|
std::size_t total_consumed_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_STD_ARRAY)
|
||||||
|
|
||||||
|
// Specialisation for null_buffers to ensure that the null_buffers type is
|
||||||
|
// always passed through to the underlying read or write operation.
|
||||||
|
template <typename Buffer>
|
||||||
|
class consuming_buffers<Buffer, null_buffers, const mutable_buffer*>
|
||||||
|
: public asio::null_buffers
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
consuming_buffers(const null_buffers&)
|
||||||
|
{
|
||||||
|
// No-op.
|
||||||
|
}
|
||||||
|
|
||||||
|
bool empty()
|
||||||
|
{
|
||||||
|
return false;
|
||||||
|
}
|
||||||
|
|
||||||
|
null_buffers prepare(std::size_t)
|
||||||
|
{
|
||||||
|
return null_buffers();
|
||||||
|
}
|
||||||
|
|
||||||
|
void consume(std::size_t)
|
||||||
|
{
|
||||||
|
// No-op.
|
||||||
|
}
|
||||||
|
|
||||||
|
std::size_t total_consumed() const
|
||||||
|
{
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CONSUMING_BUFFERS_HPP
|
||||||
|
|
@ -0,0 +1,31 @@
|
||||||
|
//
|
||||||
|
// detail/cstddef.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CSTDDEF_HPP
|
||||||
|
#define ASIO_DETAIL_CSTDDEF_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_NULLPTR)
|
||||||
|
using std::nullptr_t;
|
||||||
|
#else // defined(ASIO_HAS_NULLPTR)
|
||||||
|
struct nullptr_t {};
|
||||||
|
#endif // defined(ASIO_HAS_NULLPTR)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CSTDDEF_HPP
|
||||||
|
|
@ -0,0 +1,62 @@
|
||||||
|
//
|
||||||
|
// detail/cstdint.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_CSTDINT_HPP
|
||||||
|
#define ASIO_DETAIL_CSTDINT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_CSTDINT)
|
||||||
|
# include <cstdint>
|
||||||
|
#else // defined(ASIO_HAS_CSTDINT)
|
||||||
|
# include <boost/cstdint.hpp>
|
||||||
|
#endif // defined(ASIO_HAS_CSTDINT)
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_CSTDINT)
|
||||||
|
using std::int16_t;
|
||||||
|
using std::int_least16_t;
|
||||||
|
using std::uint16_t;
|
||||||
|
using std::uint_least16_t;
|
||||||
|
using std::int32_t;
|
||||||
|
using std::int_least32_t;
|
||||||
|
using std::uint32_t;
|
||||||
|
using std::uint_least32_t;
|
||||||
|
using std::int64_t;
|
||||||
|
using std::int_least64_t;
|
||||||
|
using std::uint64_t;
|
||||||
|
using std::uint_least64_t;
|
||||||
|
using std::uintptr_t;
|
||||||
|
using std::uintmax_t;
|
||||||
|
#else // defined(ASIO_HAS_CSTDINT)
|
||||||
|
using boost::int16_t;
|
||||||
|
using boost::int_least16_t;
|
||||||
|
using boost::uint16_t;
|
||||||
|
using boost::uint_least16_t;
|
||||||
|
using boost::int32_t;
|
||||||
|
using boost::int_least32_t;
|
||||||
|
using boost::uint32_t;
|
||||||
|
using boost::uint_least32_t;
|
||||||
|
using boost::int64_t;
|
||||||
|
using boost::int_least64_t;
|
||||||
|
using boost::uint64_t;
|
||||||
|
using boost::uint_least64_t;
|
||||||
|
using boost::uintptr_t;
|
||||||
|
using boost::uintmax_t;
|
||||||
|
#endif // defined(ASIO_HAS_CSTDINT)
|
||||||
|
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_CSTDINT_HPP
|
||||||
|
|
@ -0,0 +1,34 @@
|
||||||
|
//
|
||||||
|
// detail/date_time_fwd.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DATE_TIME_FWD_HPP
|
||||||
|
#define ASIO_DETAIL_DATE_TIME_FWD_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
namespace boost {
|
||||||
|
namespace date_time {
|
||||||
|
|
||||||
|
template<class T, class TimeSystem>
|
||||||
|
class base_time;
|
||||||
|
|
||||||
|
} // namespace date_time
|
||||||
|
namespace posix_time {
|
||||||
|
|
||||||
|
class ptime;
|
||||||
|
|
||||||
|
} // namespace posix_time
|
||||||
|
} // namespace boost
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DATE_TIME_FWD_HPP
|
||||||
|
|
@ -0,0 +1,335 @@
|
||||||
|
//
|
||||||
|
// detail/deadline_timer_service.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
|
||||||
|
#define ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/associated_cancellation_slot.hpp"
|
||||||
|
#include "asio/cancellation_type.hpp"
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/detail/noncopyable.hpp"
|
||||||
|
#include "asio/detail/socket_ops.hpp"
|
||||||
|
#include "asio/detail/socket_types.hpp"
|
||||||
|
#include "asio/detail/timer_queue.hpp"
|
||||||
|
#include "asio/detail/timer_queue_ptime.hpp"
|
||||||
|
#include "asio/detail/timer_scheduler.hpp"
|
||||||
|
#include "asio/detail/wait_handler.hpp"
|
||||||
|
#include "asio/detail/wait_op.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
# include <chrono>
|
||||||
|
# include <thread>
|
||||||
|
#endif // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Time_Traits>
|
||||||
|
class deadline_timer_service
|
||||||
|
: public execution_context_service_base<deadline_timer_service<Time_Traits> >
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// The time type.
|
||||||
|
typedef typename Time_Traits::time_type time_type;
|
||||||
|
|
||||||
|
// The duration type.
|
||||||
|
typedef typename Time_Traits::duration_type duration_type;
|
||||||
|
|
||||||
|
// The implementation type of the timer. This type is dependent on the
|
||||||
|
// underlying implementation of the timer service.
|
||||||
|
struct implementation_type
|
||||||
|
: private asio::detail::noncopyable
|
||||||
|
{
|
||||||
|
time_type expiry;
|
||||||
|
bool might_have_pending_waits;
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data timer_data;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Constructor.
|
||||||
|
deadline_timer_service(execution_context& context)
|
||||||
|
: execution_context_service_base<
|
||||||
|
deadline_timer_service<Time_Traits> >(context),
|
||||||
|
scheduler_(asio::use_service<timer_scheduler>(context))
|
||||||
|
{
|
||||||
|
scheduler_.init_task();
|
||||||
|
scheduler_.add_timer_queue(timer_queue_);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
~deadline_timer_service()
|
||||||
|
{
|
||||||
|
scheduler_.remove_timer_queue(timer_queue_);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destroy all user-defined handler objects owned by the service.
|
||||||
|
void shutdown()
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
// Construct a new timer implementation.
|
||||||
|
void construct(implementation_type& impl)
|
||||||
|
{
|
||||||
|
impl.expiry = time_type();
|
||||||
|
impl.might_have_pending_waits = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Destroy a timer implementation.
|
||||||
|
void destroy(implementation_type& impl)
|
||||||
|
{
|
||||||
|
asio::error_code ec;
|
||||||
|
cancel(impl, ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Move-construct a new timer implementation.
|
||||||
|
void move_construct(implementation_type& impl,
|
||||||
|
implementation_type& other_impl)
|
||||||
|
{
|
||||||
|
scheduler_.move_timer(timer_queue_, impl.timer_data, other_impl.timer_data);
|
||||||
|
|
||||||
|
impl.expiry = other_impl.expiry;
|
||||||
|
other_impl.expiry = time_type();
|
||||||
|
|
||||||
|
impl.might_have_pending_waits = other_impl.might_have_pending_waits;
|
||||||
|
other_impl.might_have_pending_waits = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Move-assign from another timer implementation.
|
||||||
|
void move_assign(implementation_type& impl,
|
||||||
|
deadline_timer_service& other_service,
|
||||||
|
implementation_type& other_impl)
|
||||||
|
{
|
||||||
|
if (this != &other_service)
|
||||||
|
if (impl.might_have_pending_waits)
|
||||||
|
scheduler_.cancel_timer(timer_queue_, impl.timer_data);
|
||||||
|
|
||||||
|
other_service.scheduler_.move_timer(other_service.timer_queue_,
|
||||||
|
impl.timer_data, other_impl.timer_data);
|
||||||
|
|
||||||
|
impl.expiry = other_impl.expiry;
|
||||||
|
other_impl.expiry = time_type();
|
||||||
|
|
||||||
|
impl.might_have_pending_waits = other_impl.might_have_pending_waits;
|
||||||
|
other_impl.might_have_pending_waits = false;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Move-construct a new timer implementation.
|
||||||
|
void converting_move_construct(implementation_type& impl,
|
||||||
|
deadline_timer_service&, implementation_type& other_impl)
|
||||||
|
{
|
||||||
|
move_construct(impl, other_impl);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Move-assign from another timer implementation.
|
||||||
|
void converting_move_assign(implementation_type& impl,
|
||||||
|
deadline_timer_service& other_service,
|
||||||
|
implementation_type& other_impl)
|
||||||
|
{
|
||||||
|
move_assign(impl, other_service, other_impl);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Cancel any asynchronous wait operations associated with the timer.
|
||||||
|
std::size_t cancel(implementation_type& impl, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
if (!impl.might_have_pending_waits)
|
||||||
|
{
|
||||||
|
ec = asio::error_code();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_HANDLER_OPERATION((scheduler_.context(),
|
||||||
|
"deadline_timer", &impl, 0, "cancel"));
|
||||||
|
|
||||||
|
std::size_t count = scheduler_.cancel_timer(timer_queue_, impl.timer_data);
|
||||||
|
impl.might_have_pending_waits = false;
|
||||||
|
ec = asio::error_code();
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Cancels one asynchronous wait operation associated with the timer.
|
||||||
|
std::size_t cancel_one(implementation_type& impl,
|
||||||
|
asio::error_code& ec)
|
||||||
|
{
|
||||||
|
if (!impl.might_have_pending_waits)
|
||||||
|
{
|
||||||
|
ec = asio::error_code();
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_HANDLER_OPERATION((scheduler_.context(),
|
||||||
|
"deadline_timer", &impl, 0, "cancel_one"));
|
||||||
|
|
||||||
|
std::size_t count = scheduler_.cancel_timer(
|
||||||
|
timer_queue_, impl.timer_data, 1);
|
||||||
|
if (count == 0)
|
||||||
|
impl.might_have_pending_waits = false;
|
||||||
|
ec = asio::error_code();
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the expiry time for the timer as an absolute time.
|
||||||
|
time_type expiry(const implementation_type& impl) const
|
||||||
|
{
|
||||||
|
return impl.expiry;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the expiry time for the timer as an absolute time.
|
||||||
|
time_type expires_at(const implementation_type& impl) const
|
||||||
|
{
|
||||||
|
return impl.expiry;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Get the expiry time for the timer relative to now.
|
||||||
|
duration_type expires_from_now(const implementation_type& impl) const
|
||||||
|
{
|
||||||
|
return Time_Traits::subtract(this->expiry(impl), Time_Traits::now());
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set the expiry time for the timer as an absolute time.
|
||||||
|
std::size_t expires_at(implementation_type& impl,
|
||||||
|
const time_type& expiry_time, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
std::size_t count = cancel(impl, ec);
|
||||||
|
impl.expiry = expiry_time;
|
||||||
|
ec = asio::error_code();
|
||||||
|
return count;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set the expiry time for the timer relative to now.
|
||||||
|
std::size_t expires_after(implementation_type& impl,
|
||||||
|
const duration_type& expiry_time, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return expires_at(impl,
|
||||||
|
Time_Traits::add(Time_Traits::now(), expiry_time), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set the expiry time for the timer relative to now.
|
||||||
|
std::size_t expires_from_now(implementation_type& impl,
|
||||||
|
const duration_type& expiry_time, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
return expires_at(impl,
|
||||||
|
Time_Traits::add(Time_Traits::now(), expiry_time), ec);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Perform a blocking wait on the timer.
|
||||||
|
void wait(implementation_type& impl, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
time_type now = Time_Traits::now();
|
||||||
|
ec = asio::error_code();
|
||||||
|
while (Time_Traits::less_than(now, impl.expiry) && !ec)
|
||||||
|
{
|
||||||
|
this->do_wait(Time_Traits::to_posix_duration(
|
||||||
|
Time_Traits::subtract(impl.expiry, now)), ec);
|
||||||
|
now = Time_Traits::now();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Start an asynchronous wait on the timer.
|
||||||
|
template <typename Handler, typename IoExecutor>
|
||||||
|
void async_wait(implementation_type& impl,
|
||||||
|
Handler& handler, const IoExecutor& io_ex)
|
||||||
|
{
|
||||||
|
typename associated_cancellation_slot<Handler>::type slot
|
||||||
|
= asio::get_associated_cancellation_slot(handler);
|
||||||
|
|
||||||
|
// Allocate and construct an operation to wrap the handler.
|
||||||
|
typedef wait_handler<Handler, IoExecutor> op;
|
||||||
|
typename op::ptr p = { asio::detail::addressof(handler),
|
||||||
|
op::ptr::allocate(handler), 0 };
|
||||||
|
p.p = new (p.v) op(handler, io_ex);
|
||||||
|
|
||||||
|
// Optionally register for per-operation cancellation.
|
||||||
|
if (slot.is_connected())
|
||||||
|
{
|
||||||
|
p.p->cancellation_key_ =
|
||||||
|
&slot.template emplace<op_cancellation>(this, &impl.timer_data);
|
||||||
|
}
|
||||||
|
|
||||||
|
impl.might_have_pending_waits = true;
|
||||||
|
|
||||||
|
ASIO_HANDLER_CREATION((scheduler_.context(),
|
||||||
|
*p.p, "deadline_timer", &impl, 0, "async_wait"));
|
||||||
|
|
||||||
|
scheduler_.schedule_timer(timer_queue_, impl.expiry, impl.timer_data, p.p);
|
||||||
|
p.v = p.p = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Helper function to wait given a duration type. The duration type should
|
||||||
|
// either be of type boost::posix_time::time_duration, or implement the
|
||||||
|
// required subset of its interface.
|
||||||
|
template <typename Duration>
|
||||||
|
void do_wait(const Duration& timeout, asio::error_code& ec)
|
||||||
|
{
|
||||||
|
#if defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
std::this_thread::sleep_for(
|
||||||
|
std::chrono::seconds(timeout.total_seconds())
|
||||||
|
+ std::chrono::microseconds(timeout.total_microseconds()));
|
||||||
|
ec = asio::error_code();
|
||||||
|
#else // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
::timeval tv;
|
||||||
|
tv.tv_sec = timeout.total_seconds();
|
||||||
|
tv.tv_usec = timeout.total_microseconds() % 1000000;
|
||||||
|
socket_ops::select(0, 0, 0, 0, &tv, ec);
|
||||||
|
#endif // defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Helper class used to implement per-operation cancellation.
|
||||||
|
class op_cancellation
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
op_cancellation(deadline_timer_service* s,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data* p)
|
||||||
|
: service_(s),
|
||||||
|
timer_data_(p)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void operator()(cancellation_type_t type)
|
||||||
|
{
|
||||||
|
if (!!(type &
|
||||||
|
(cancellation_type::terminal
|
||||||
|
| cancellation_type::partial
|
||||||
|
| cancellation_type::total)))
|
||||||
|
{
|
||||||
|
service_->scheduler_.cancel_timer_by_key(
|
||||||
|
service_->timer_queue_, timer_data_, this);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
deadline_timer_service* service_;
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data* timer_data_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// The queue of timers.
|
||||||
|
timer_queue<Time_Traits> timer_queue_;
|
||||||
|
|
||||||
|
// The object that schedules and executes timers. Usually a reactor.
|
||||||
|
timer_scheduler& scheduler_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DEADLINE_TIMER_SERVICE_HPP
|
||||||
|
|
@ -0,0 +1,36 @@
|
||||||
|
//
|
||||||
|
// detail/dependent_type.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DEPENDENT_TYPE_HPP
|
||||||
|
#define ASIO_DETAIL_DEPENDENT_TYPE_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename DependsOn, typename T>
|
||||||
|
struct dependent_type
|
||||||
|
{
|
||||||
|
typedef T type;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DEPENDENT_TYPE_HPP
|
||||||
|
|
@ -0,0 +1,179 @@
|
||||||
|
//
|
||||||
|
// detail/descriptor_ops.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DESCRIPTOR_OPS_HPP
|
||||||
|
#define ASIO_DETAIL_DESCRIPTOR_OPS_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_WINDOWS) \
|
||||||
|
&& !defined(ASIO_WINDOWS_RUNTIME) \
|
||||||
|
&& !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include "asio/error.hpp"
|
||||||
|
#include "asio/error_code.hpp"
|
||||||
|
#include "asio/detail/cstdint.hpp"
|
||||||
|
#include "asio/detail/socket_types.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
namespace descriptor_ops {
|
||||||
|
|
||||||
|
// Descriptor state bits.
|
||||||
|
enum
|
||||||
|
{
|
||||||
|
// The user wants a non-blocking descriptor.
|
||||||
|
user_set_non_blocking = 1,
|
||||||
|
|
||||||
|
// The descriptor has been set non-blocking.
|
||||||
|
internal_non_blocking = 2,
|
||||||
|
|
||||||
|
// Helper "state" used to determine whether the descriptor is non-blocking.
|
||||||
|
non_blocking = user_set_non_blocking | internal_non_blocking,
|
||||||
|
|
||||||
|
// The descriptor may have been dup()-ed.
|
||||||
|
possible_dup = 4
|
||||||
|
};
|
||||||
|
|
||||||
|
typedef unsigned char state_type;
|
||||||
|
|
||||||
|
inline void get_last_error(
|
||||||
|
asio::error_code& ec, bool is_error_condition)
|
||||||
|
{
|
||||||
|
if (!is_error_condition)
|
||||||
|
{
|
||||||
|
ec.assign(0, ec.category());
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
ec = asio::error_code(errno,
|
||||||
|
asio::error::get_system_category());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_DECL int open(const char* path, int flags,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int open(const char* path, int flags, unsigned mode,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int close(int d, state_type& state,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool set_user_non_blocking(int d,
|
||||||
|
state_type& state, bool value, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool set_internal_non_blocking(int d,
|
||||||
|
state_type& state, bool value, asio::error_code& ec);
|
||||||
|
|
||||||
|
typedef iovec buf;
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_read(int d, state_type state, buf* bufs,
|
||||||
|
std::size_t count, bool all_empty, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_read1(int d, state_type state, void* data,
|
||||||
|
std::size_t size, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_read(int d, buf* bufs, std::size_t count,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_read1(int d, void* data, std::size_t size,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_write(int d, state_type state,
|
||||||
|
const buf* bufs, std::size_t count, bool all_empty,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_write1(int d, state_type state,
|
||||||
|
const void* data, std::size_t size, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_write(int d,
|
||||||
|
const buf* bufs, std::size_t count,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_write1(int d,
|
||||||
|
const void* data, std::size_t size,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_FILE)
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_read_at(int d, state_type state,
|
||||||
|
uint64_t offset, buf* bufs, std::size_t count, bool all_empty,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_read_at1(int d, state_type state,
|
||||||
|
uint64_t offset, void* data, std::size_t size,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_read_at(int d, uint64_t offset,
|
||||||
|
buf* bufs, std::size_t count, asio::error_code& ec,
|
||||||
|
std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_read_at1(int d, uint64_t offset,
|
||||||
|
void* data, std::size_t size, asio::error_code& ec,
|
||||||
|
std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_write_at(int d, state_type state,
|
||||||
|
uint64_t offset, const buf* bufs, std::size_t count, bool all_empty,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL std::size_t sync_write_at1(int d, state_type state,
|
||||||
|
uint64_t offset, const void* data, std::size_t size,
|
||||||
|
asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_write_at(int d,
|
||||||
|
uint64_t offset, const buf* bufs, std::size_t count,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
ASIO_DECL bool non_blocking_write_at1(int d,
|
||||||
|
uint64_t offset, const void* data, std::size_t size,
|
||||||
|
asio::error_code& ec, std::size_t& bytes_transferred);
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_FILE)
|
||||||
|
|
||||||
|
ASIO_DECL int ioctl(int d, state_type& state, long cmd,
|
||||||
|
ioctl_arg_type* arg, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int fcntl(int d, int cmd, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int fcntl(int d, int cmd,
|
||||||
|
long arg, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int poll_read(int d,
|
||||||
|
state_type state, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int poll_write(int d,
|
||||||
|
state_type state, asio::error_code& ec);
|
||||||
|
|
||||||
|
ASIO_DECL int poll_error(int d,
|
||||||
|
state_type state, asio::error_code& ec);
|
||||||
|
|
||||||
|
} // namespace descriptor_ops
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/detail/impl/descriptor_ops.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_WINDOWS)
|
||||||
|
// && !defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
// && !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DESCRIPTOR_OPS_HPP
|
||||||
|
|
@ -0,0 +1,148 @@
|
||||||
|
//
|
||||||
|
// detail/descriptor_read_op.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
|
||||||
|
#define ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||||
|
#include "asio/detail/descriptor_ops.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_work.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/detail/reactor_op.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename MutableBufferSequence>
|
||||||
|
class descriptor_read_op_base : public reactor_op
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
descriptor_read_op_base(const asio::error_code& success_ec,
|
||||||
|
int descriptor, const MutableBufferSequence& buffers,
|
||||||
|
func_type complete_func)
|
||||||
|
: reactor_op(success_ec,
|
||||||
|
&descriptor_read_op_base::do_perform, complete_func),
|
||||||
|
descriptor_(descriptor),
|
||||||
|
buffers_(buffers)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static status do_perform(reactor_op* base)
|
||||||
|
{
|
||||||
|
descriptor_read_op_base* o(static_cast<descriptor_read_op_base*>(base));
|
||||||
|
|
||||||
|
typedef buffer_sequence_adapter<asio::mutable_buffer,
|
||||||
|
MutableBufferSequence> bufs_type;
|
||||||
|
|
||||||
|
status result;
|
||||||
|
if (bufs_type::is_single_buffer)
|
||||||
|
{
|
||||||
|
result = descriptor_ops::non_blocking_read1(o->descriptor_,
|
||||||
|
bufs_type::first(o->buffers_).data(),
|
||||||
|
bufs_type::first(o->buffers_).size(),
|
||||||
|
o->ec_, o->bytes_transferred_) ? done : not_done;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
bufs_type bufs(o->buffers_);
|
||||||
|
result = descriptor_ops::non_blocking_read(o->descriptor_,
|
||||||
|
bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
|
||||||
|
? done : not_done;
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_read",
|
||||||
|
o->ec_, o->bytes_transferred_));
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
int descriptor_;
|
||||||
|
MutableBufferSequence buffers_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename MutableBufferSequence, typename Handler, typename IoExecutor>
|
||||||
|
class descriptor_read_op
|
||||||
|
: public descriptor_read_op_base<MutableBufferSequence>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_DEFINE_HANDLER_PTR(descriptor_read_op);
|
||||||
|
|
||||||
|
descriptor_read_op(const asio::error_code& success_ec,
|
||||||
|
int descriptor, const MutableBufferSequence& buffers,
|
||||||
|
Handler& handler, const IoExecutor& io_ex)
|
||||||
|
: descriptor_read_op_base<MutableBufferSequence>(success_ec,
|
||||||
|
descriptor, buffers, &descriptor_read_op::do_complete),
|
||||||
|
handler_(ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
work_(handler_, io_ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
// Take ownership of the handler object.
|
||||||
|
descriptor_read_op* o(static_cast<descriptor_read_op*>(base));
|
||||||
|
ptr p = { asio::detail::addressof(o->handler_), o, o };
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*o));
|
||||||
|
|
||||||
|
// Take ownership of the operation's outstanding work.
|
||||||
|
handler_work<Handler, IoExecutor> w(
|
||||||
|
ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
|
||||||
|
o->work_));
|
||||||
|
|
||||||
|
// Make a copy of the handler so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the handler may be the true owner of the memory associated
|
||||||
|
// with the handler. Consequently, a local copy of the handler is required
|
||||||
|
// to ensure that any owning sub-object remains valid until after we have
|
||||||
|
// deallocated the memory here.
|
||||||
|
detail::binder2<Handler, asio::error_code, std::size_t>
|
||||||
|
handler(o->handler_, o->ec_, o->bytes_transferred_);
|
||||||
|
p.h = asio::detail::addressof(handler.handler_);
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
|
||||||
|
w.complete(handler, handler.handler_);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler handler_;
|
||||||
|
handler_work<Handler, IoExecutor> work_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DESCRIPTOR_READ_OP_HPP
|
||||||
|
|
@ -0,0 +1,148 @@
|
||||||
|
//
|
||||||
|
// detail/descriptor_write_op.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
|
||||||
|
#define ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#include "asio/detail/bind_handler.hpp"
|
||||||
|
#include "asio/detail/buffer_sequence_adapter.hpp"
|
||||||
|
#include "asio/detail/descriptor_ops.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_work.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
#include "asio/detail/reactor_op.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename ConstBufferSequence>
|
||||||
|
class descriptor_write_op_base : public reactor_op
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
descriptor_write_op_base(const asio::error_code& success_ec,
|
||||||
|
int descriptor, const ConstBufferSequence& buffers,
|
||||||
|
func_type complete_func)
|
||||||
|
: reactor_op(success_ec,
|
||||||
|
&descriptor_write_op_base::do_perform, complete_func),
|
||||||
|
descriptor_(descriptor),
|
||||||
|
buffers_(buffers)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static status do_perform(reactor_op* base)
|
||||||
|
{
|
||||||
|
descriptor_write_op_base* o(static_cast<descriptor_write_op_base*>(base));
|
||||||
|
|
||||||
|
typedef buffer_sequence_adapter<asio::const_buffer,
|
||||||
|
ConstBufferSequence> bufs_type;
|
||||||
|
|
||||||
|
status result;
|
||||||
|
if (bufs_type::is_single_buffer)
|
||||||
|
{
|
||||||
|
result = descriptor_ops::non_blocking_write1(o->descriptor_,
|
||||||
|
bufs_type::first(o->buffers_).data(),
|
||||||
|
bufs_type::first(o->buffers_).size(),
|
||||||
|
o->ec_, o->bytes_transferred_) ? done : not_done;
|
||||||
|
}
|
||||||
|
else
|
||||||
|
{
|
||||||
|
bufs_type bufs(o->buffers_);
|
||||||
|
result = descriptor_ops::non_blocking_write(o->descriptor_,
|
||||||
|
bufs.buffers(), bufs.count(), o->ec_, o->bytes_transferred_)
|
||||||
|
? done : not_done;
|
||||||
|
}
|
||||||
|
|
||||||
|
ASIO_HANDLER_REACTOR_OPERATION((*o, "non_blocking_write",
|
||||||
|
o->ec_, o->bytes_transferred_));
|
||||||
|
|
||||||
|
return result;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
int descriptor_;
|
||||||
|
ConstBufferSequence buffers_;
|
||||||
|
};
|
||||||
|
|
||||||
|
template <typename ConstBufferSequence, typename Handler, typename IoExecutor>
|
||||||
|
class descriptor_write_op
|
||||||
|
: public descriptor_write_op_base<ConstBufferSequence>
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_DEFINE_HANDLER_PTR(descriptor_write_op);
|
||||||
|
|
||||||
|
descriptor_write_op(const asio::error_code& success_ec,
|
||||||
|
int descriptor, const ConstBufferSequence& buffers,
|
||||||
|
Handler& handler, const IoExecutor& io_ex)
|
||||||
|
: descriptor_write_op_base<ConstBufferSequence>(success_ec,
|
||||||
|
descriptor, buffers, &descriptor_write_op::do_complete),
|
||||||
|
handler_(ASIO_MOVE_CAST(Handler)(handler)),
|
||||||
|
work_(handler_, io_ex)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
// Take ownership of the handler object.
|
||||||
|
descriptor_write_op* o(static_cast<descriptor_write_op*>(base));
|
||||||
|
ptr p = { asio::detail::addressof(o->handler_), o, o };
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*o));
|
||||||
|
|
||||||
|
// Take ownership of the operation's outstanding work.
|
||||||
|
handler_work<Handler, IoExecutor> w(
|
||||||
|
ASIO_MOVE_CAST2(handler_work<Handler, IoExecutor>)(
|
||||||
|
o->work_));
|
||||||
|
|
||||||
|
// Make a copy of the handler so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the handler may be the true owner of the memory associated
|
||||||
|
// with the handler. Consequently, a local copy of the handler is required
|
||||||
|
// to ensure that any owning sub-object remains valid until after we have
|
||||||
|
// deallocated the memory here.
|
||||||
|
detail::binder2<Handler, asio::error_code, std::size_t>
|
||||||
|
handler(o->handler_, o->ec_, o->bytes_transferred_);
|
||||||
|
p.h = asio::detail::addressof(handler.handler_);
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN((handler.arg1_, handler.arg2_));
|
||||||
|
w.complete(handler, handler.handler_);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler handler_;
|
||||||
|
handler_work<Handler, IoExecutor> work_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_WINDOWS) && !defined(__CYGWIN__)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DESCRIPTOR_WRITE_OP_HPP
|
||||||
|
|
@ -0,0 +1,230 @@
|
||||||
|
//
|
||||||
|
// detail/dev_poll_reactor.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_DEV_POLL_REACTOR_HPP
|
||||||
|
#define ASIO_DETAIL_DEV_POLL_REACTOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_DEV_POLL)
|
||||||
|
|
||||||
|
#include <cstddef>
|
||||||
|
#include <vector>
|
||||||
|
#include <sys/devpoll.h>
|
||||||
|
#include "asio/detail/hash_map.hpp"
|
||||||
|
#include "asio/detail/limits.hpp"
|
||||||
|
#include "asio/detail/mutex.hpp"
|
||||||
|
#include "asio/detail/op_queue.hpp"
|
||||||
|
#include "asio/detail/reactor_op.hpp"
|
||||||
|
#include "asio/detail/reactor_op_queue.hpp"
|
||||||
|
#include "asio/detail/scheduler_task.hpp"
|
||||||
|
#include "asio/detail/select_interrupter.hpp"
|
||||||
|
#include "asio/detail/socket_types.hpp"
|
||||||
|
#include "asio/detail/timer_queue_base.hpp"
|
||||||
|
#include "asio/detail/timer_queue_set.hpp"
|
||||||
|
#include "asio/detail/wait_op.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class dev_poll_reactor
|
||||||
|
: public execution_context_service_base<dev_poll_reactor>,
|
||||||
|
public scheduler_task
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
enum op_types { read_op = 0, write_op = 1,
|
||||||
|
connect_op = 1, except_op = 2, max_ops = 3 };
|
||||||
|
|
||||||
|
// Per-descriptor data.
|
||||||
|
struct per_descriptor_data
|
||||||
|
{
|
||||||
|
};
|
||||||
|
|
||||||
|
// Constructor.
|
||||||
|
ASIO_DECL dev_poll_reactor(asio::execution_context& ctx);
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
ASIO_DECL ~dev_poll_reactor();
|
||||||
|
|
||||||
|
// Destroy all user-defined handler objects owned by the service.
|
||||||
|
ASIO_DECL void shutdown();
|
||||||
|
|
||||||
|
// Recreate internal descriptors following a fork.
|
||||||
|
ASIO_DECL void notify_fork(
|
||||||
|
asio::execution_context::fork_event fork_ev);
|
||||||
|
|
||||||
|
// Initialise the task.
|
||||||
|
ASIO_DECL void init_task();
|
||||||
|
|
||||||
|
// Register a socket with the reactor. Returns 0 on success, system error
|
||||||
|
// code on failure.
|
||||||
|
ASIO_DECL int register_descriptor(socket_type, per_descriptor_data&);
|
||||||
|
|
||||||
|
// Register a descriptor with an associated single operation. Returns 0 on
|
||||||
|
// success, system error code on failure.
|
||||||
|
ASIO_DECL int register_internal_descriptor(
|
||||||
|
int op_type, socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data, reactor_op* op);
|
||||||
|
|
||||||
|
// Move descriptor registration from one descriptor_data object to another.
|
||||||
|
ASIO_DECL void move_descriptor(socket_type descriptor,
|
||||||
|
per_descriptor_data& target_descriptor_data,
|
||||||
|
per_descriptor_data& source_descriptor_data);
|
||||||
|
|
||||||
|
// Post a reactor operation for immediate completion.
|
||||||
|
void post_immediate_completion(reactor_op* op, bool is_continuation);
|
||||||
|
|
||||||
|
// Start a new operation. The reactor operation will be performed when the
|
||||||
|
// given descriptor is flagged as ready, or an error has occurred.
|
||||||
|
ASIO_DECL void start_op(int op_type, socket_type descriptor,
|
||||||
|
per_descriptor_data&, reactor_op* op,
|
||||||
|
bool is_continuation, bool allow_speculative);
|
||||||
|
|
||||||
|
// Cancel all operations associated with the given descriptor. The
|
||||||
|
// handlers associated with the descriptor will be invoked with the
|
||||||
|
// operation_aborted error.
|
||||||
|
ASIO_DECL void cancel_ops(socket_type descriptor, per_descriptor_data&);
|
||||||
|
|
||||||
|
// Cancel all operations associated with the given descriptor and key. The
|
||||||
|
// handlers associated with the descriptor will be invoked with the
|
||||||
|
// operation_aborted error.
|
||||||
|
ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data,
|
||||||
|
int op_type, void* cancellation_key);
|
||||||
|
|
||||||
|
// Cancel any operations that are running against the descriptor and remove
|
||||||
|
// its registration from the reactor. The reactor resources associated with
|
||||||
|
// the descriptor must be released by calling cleanup_descriptor_data.
|
||||||
|
ASIO_DECL void deregister_descriptor(socket_type descriptor,
|
||||||
|
per_descriptor_data&, bool closing);
|
||||||
|
|
||||||
|
// Remove the descriptor's registration from the reactor. The reactor
|
||||||
|
// resources associated with the descriptor must be released by calling
|
||||||
|
// cleanup_descriptor_data.
|
||||||
|
ASIO_DECL void deregister_internal_descriptor(
|
||||||
|
socket_type descriptor, per_descriptor_data&);
|
||||||
|
|
||||||
|
// Perform any post-deregistration cleanup tasks associated with the
|
||||||
|
// descriptor data.
|
||||||
|
ASIO_DECL void cleanup_descriptor_data(per_descriptor_data&);
|
||||||
|
|
||||||
|
// Add a new timer queue to the reactor.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void add_timer_queue(timer_queue<Time_Traits>& queue);
|
||||||
|
|
||||||
|
// Remove a timer queue from the reactor.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void remove_timer_queue(timer_queue<Time_Traits>& queue);
|
||||||
|
|
||||||
|
// Schedule a new operation in the given timer queue to expire at the
|
||||||
|
// specified absolute time.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void schedule_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
const typename Time_Traits::time_type& time,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
|
||||||
|
|
||||||
|
// Cancel the timer operations associated with the given token. Returns the
|
||||||
|
// number of operations that have been posted or dispatched.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& timer,
|
||||||
|
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
|
||||||
|
|
||||||
|
// Cancel the timer operations associated with the given key.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data* timer,
|
||||||
|
void* cancellation_key);
|
||||||
|
|
||||||
|
// Move the timer operations associated with the given timer.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void move_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& target,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& source);
|
||||||
|
|
||||||
|
// Run /dev/poll once until interrupted or events are ready to be dispatched.
|
||||||
|
ASIO_DECL void run(long usec, op_queue<operation>& ops);
|
||||||
|
|
||||||
|
// Interrupt the select loop.
|
||||||
|
ASIO_DECL void interrupt();
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Create the /dev/poll file descriptor. Throws an exception if the descriptor
|
||||||
|
// cannot be created.
|
||||||
|
ASIO_DECL static int do_dev_poll_create();
|
||||||
|
|
||||||
|
// Helper function to add a new timer queue.
|
||||||
|
ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
|
||||||
|
|
||||||
|
// Helper function to remove a timer queue.
|
||||||
|
ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
|
||||||
|
|
||||||
|
// Get the timeout value for the /dev/poll DP_POLL operation. The timeout
|
||||||
|
// value is returned as a number of milliseconds. A return value of -1
|
||||||
|
// indicates that the poll should block indefinitely.
|
||||||
|
ASIO_DECL int get_timeout(int msec);
|
||||||
|
|
||||||
|
// Cancel all operations associated with the given descriptor. The do_cancel
|
||||||
|
// function of the handler objects will be invoked. This function does not
|
||||||
|
// acquire the dev_poll_reactor's mutex.
|
||||||
|
ASIO_DECL void cancel_ops_unlocked(socket_type descriptor,
|
||||||
|
const asio::error_code& ec);
|
||||||
|
|
||||||
|
// Add a pending event entry for the given descriptor.
|
||||||
|
ASIO_DECL ::pollfd& add_pending_event_change(int descriptor);
|
||||||
|
|
||||||
|
// The scheduler implementation used to post completions.
|
||||||
|
scheduler& scheduler_;
|
||||||
|
|
||||||
|
// Mutex to protect access to internal data.
|
||||||
|
asio::detail::mutex mutex_;
|
||||||
|
|
||||||
|
// The /dev/poll file descriptor.
|
||||||
|
int dev_poll_fd_;
|
||||||
|
|
||||||
|
// Vector of /dev/poll events waiting to be written to the descriptor.
|
||||||
|
std::vector< ::pollfd> pending_event_changes_;
|
||||||
|
|
||||||
|
// Hash map to associate a descriptor with a pending event change index.
|
||||||
|
hash_map<int, std::size_t> pending_event_change_index_;
|
||||||
|
|
||||||
|
// The interrupter is used to break a blocking DP_POLL operation.
|
||||||
|
select_interrupter interrupter_;
|
||||||
|
|
||||||
|
// The queues of read, write and except operations.
|
||||||
|
reactor_op_queue<socket_type> op_queue_[max_ops];
|
||||||
|
|
||||||
|
// The timer queues.
|
||||||
|
timer_queue_set timer_queues_;
|
||||||
|
|
||||||
|
// Whether the service has been shut down.
|
||||||
|
bool shutdown_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/impl/dev_poll_reactor.hpp"
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/detail/impl/dev_poll_reactor.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_DEV_POLL)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_DEV_POLL_REACTOR_HPP
|
||||||
|
|
@ -0,0 +1,278 @@
|
||||||
|
//
|
||||||
|
// detail/epoll_reactor.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_EPOLL_REACTOR_HPP
|
||||||
|
#define ASIO_DETAIL_EPOLL_REACTOR_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_EPOLL)
|
||||||
|
|
||||||
|
#include "asio/detail/atomic_count.hpp"
|
||||||
|
#include "asio/detail/conditionally_enabled_mutex.hpp"
|
||||||
|
#include "asio/detail/limits.hpp"
|
||||||
|
#include "asio/detail/object_pool.hpp"
|
||||||
|
#include "asio/detail/op_queue.hpp"
|
||||||
|
#include "asio/detail/reactor_op.hpp"
|
||||||
|
#include "asio/detail/scheduler_task.hpp"
|
||||||
|
#include "asio/detail/select_interrupter.hpp"
|
||||||
|
#include "asio/detail/socket_types.hpp"
|
||||||
|
#include "asio/detail/timer_queue_base.hpp"
|
||||||
|
#include "asio/detail/timer_queue_set.hpp"
|
||||||
|
#include "asio/detail/wait_op.hpp"
|
||||||
|
#include "asio/execution_context.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_TIMERFD)
|
||||||
|
# include <sys/timerfd.h>
|
||||||
|
#endif // defined(ASIO_HAS_TIMERFD)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class epoll_reactor
|
||||||
|
: public execution_context_service_base<epoll_reactor>,
|
||||||
|
public scheduler_task
|
||||||
|
{
|
||||||
|
private:
|
||||||
|
// The mutex type used by this reactor.
|
||||||
|
typedef conditionally_enabled_mutex mutex;
|
||||||
|
|
||||||
|
public:
|
||||||
|
enum op_types { read_op = 0, write_op = 1,
|
||||||
|
connect_op = 1, except_op = 2, max_ops = 3 };
|
||||||
|
|
||||||
|
// Per-descriptor queues.
|
||||||
|
class descriptor_state : operation
|
||||||
|
{
|
||||||
|
friend class epoll_reactor;
|
||||||
|
friend class object_pool_access;
|
||||||
|
|
||||||
|
descriptor_state* next_;
|
||||||
|
descriptor_state* prev_;
|
||||||
|
|
||||||
|
mutex mutex_;
|
||||||
|
epoll_reactor* reactor_;
|
||||||
|
int descriptor_;
|
||||||
|
uint32_t registered_events_;
|
||||||
|
op_queue<reactor_op> op_queue_[max_ops];
|
||||||
|
bool try_speculative_[max_ops];
|
||||||
|
bool shutdown_;
|
||||||
|
|
||||||
|
ASIO_DECL descriptor_state(bool locking);
|
||||||
|
void set_ready_events(uint32_t events) { task_result_ = events; }
|
||||||
|
void add_ready_events(uint32_t events) { task_result_ |= events; }
|
||||||
|
ASIO_DECL operation* perform_io(uint32_t events);
|
||||||
|
ASIO_DECL static void do_complete(
|
||||||
|
void* owner, operation* base,
|
||||||
|
const asio::error_code& ec, std::size_t bytes_transferred);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Per-descriptor data.
|
||||||
|
typedef descriptor_state* per_descriptor_data;
|
||||||
|
|
||||||
|
// Constructor.
|
||||||
|
ASIO_DECL epoll_reactor(asio::execution_context& ctx);
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
ASIO_DECL ~epoll_reactor();
|
||||||
|
|
||||||
|
// Destroy all user-defined handler objects owned by the service.
|
||||||
|
ASIO_DECL void shutdown();
|
||||||
|
|
||||||
|
// Recreate internal descriptors following a fork.
|
||||||
|
ASIO_DECL void notify_fork(
|
||||||
|
asio::execution_context::fork_event fork_ev);
|
||||||
|
|
||||||
|
// Initialise the task.
|
||||||
|
ASIO_DECL void init_task();
|
||||||
|
|
||||||
|
// Register a socket with the reactor. Returns 0 on success, system error
|
||||||
|
// code on failure.
|
||||||
|
ASIO_DECL int register_descriptor(socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data);
|
||||||
|
|
||||||
|
// Register a descriptor with an associated single operation. Returns 0 on
|
||||||
|
// success, system error code on failure.
|
||||||
|
ASIO_DECL int register_internal_descriptor(
|
||||||
|
int op_type, socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data, reactor_op* op);
|
||||||
|
|
||||||
|
// Move descriptor registration from one descriptor_data object to another.
|
||||||
|
ASIO_DECL void move_descriptor(socket_type descriptor,
|
||||||
|
per_descriptor_data& target_descriptor_data,
|
||||||
|
per_descriptor_data& source_descriptor_data);
|
||||||
|
|
||||||
|
// Post a reactor operation for immediate completion.
|
||||||
|
void post_immediate_completion(operation* op, bool is_continuation);
|
||||||
|
|
||||||
|
// Start a new operation. The reactor operation will be performed when the
|
||||||
|
// given descriptor is flagged as ready, or an error has occurred.
|
||||||
|
ASIO_DECL void start_op(int op_type, socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data, reactor_op* op,
|
||||||
|
bool is_continuation, bool allow_speculative);
|
||||||
|
|
||||||
|
// Cancel all operations associated with the given descriptor. The
|
||||||
|
// handlers associated with the descriptor will be invoked with the
|
||||||
|
// operation_aborted error.
|
||||||
|
ASIO_DECL void cancel_ops(socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data);
|
||||||
|
|
||||||
|
// Cancel all operations associated with the given descriptor and key. The
|
||||||
|
// handlers associated with the descriptor will be invoked with the
|
||||||
|
// operation_aborted error.
|
||||||
|
ASIO_DECL void cancel_ops_by_key(socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data,
|
||||||
|
int op_type, void* cancellation_key);
|
||||||
|
|
||||||
|
// Cancel any operations that are running against the descriptor and remove
|
||||||
|
// its registration from the reactor. The reactor resources associated with
|
||||||
|
// the descriptor must be released by calling cleanup_descriptor_data.
|
||||||
|
ASIO_DECL void deregister_descriptor(socket_type descriptor,
|
||||||
|
per_descriptor_data& descriptor_data, bool closing);
|
||||||
|
|
||||||
|
// Remove the descriptor's registration from the reactor. The reactor
|
||||||
|
// resources associated with the descriptor must be released by calling
|
||||||
|
// cleanup_descriptor_data.
|
||||||
|
ASIO_DECL void deregister_internal_descriptor(
|
||||||
|
socket_type descriptor, per_descriptor_data& descriptor_data);
|
||||||
|
|
||||||
|
// Perform any post-deregistration cleanup tasks associated with the
|
||||||
|
// descriptor data.
|
||||||
|
ASIO_DECL void cleanup_descriptor_data(
|
||||||
|
per_descriptor_data& descriptor_data);
|
||||||
|
|
||||||
|
// Add a new timer queue to the reactor.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void add_timer_queue(timer_queue<Time_Traits>& timer_queue);
|
||||||
|
|
||||||
|
// Remove a timer queue from the reactor.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void remove_timer_queue(timer_queue<Time_Traits>& timer_queue);
|
||||||
|
|
||||||
|
// Schedule a new operation in the given timer queue to expire at the
|
||||||
|
// specified absolute time.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void schedule_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
const typename Time_Traits::time_type& time,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& timer, wait_op* op);
|
||||||
|
|
||||||
|
// Cancel the timer operations associated with the given token. Returns the
|
||||||
|
// number of operations that have been posted or dispatched.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
std::size_t cancel_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& timer,
|
||||||
|
std::size_t max_cancelled = (std::numeric_limits<std::size_t>::max)());
|
||||||
|
|
||||||
|
// Cancel the timer operations associated with the given key.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void cancel_timer_by_key(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data* timer,
|
||||||
|
void* cancellation_key);
|
||||||
|
|
||||||
|
// Move the timer operations associated with the given timer.
|
||||||
|
template <typename Time_Traits>
|
||||||
|
void move_timer(timer_queue<Time_Traits>& queue,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& target,
|
||||||
|
typename timer_queue<Time_Traits>::per_timer_data& source);
|
||||||
|
|
||||||
|
// Run epoll once until interrupted or events are ready to be dispatched.
|
||||||
|
ASIO_DECL void run(long usec, op_queue<operation>& ops);
|
||||||
|
|
||||||
|
// Interrupt the select loop.
|
||||||
|
ASIO_DECL void interrupt();
|
||||||
|
|
||||||
|
private:
|
||||||
|
// The hint to pass to epoll_create to size its data structures.
|
||||||
|
enum { epoll_size = 20000 };
|
||||||
|
|
||||||
|
// Create the epoll file descriptor. Throws an exception if the descriptor
|
||||||
|
// cannot be created.
|
||||||
|
ASIO_DECL static int do_epoll_create();
|
||||||
|
|
||||||
|
// Create the timerfd file descriptor. Does not throw.
|
||||||
|
ASIO_DECL static int do_timerfd_create();
|
||||||
|
|
||||||
|
// Allocate a new descriptor state object.
|
||||||
|
ASIO_DECL descriptor_state* allocate_descriptor_state();
|
||||||
|
|
||||||
|
// Free an existing descriptor state object.
|
||||||
|
ASIO_DECL void free_descriptor_state(descriptor_state* s);
|
||||||
|
|
||||||
|
// Helper function to add a new timer queue.
|
||||||
|
ASIO_DECL void do_add_timer_queue(timer_queue_base& queue);
|
||||||
|
|
||||||
|
// Helper function to remove a timer queue.
|
||||||
|
ASIO_DECL void do_remove_timer_queue(timer_queue_base& queue);
|
||||||
|
|
||||||
|
// Called to recalculate and update the timeout.
|
||||||
|
ASIO_DECL void update_timeout();
|
||||||
|
|
||||||
|
// Get the timeout value for the epoll_wait call. The timeout value is
|
||||||
|
// returned as a number of milliseconds. A return value of -1 indicates
|
||||||
|
// that epoll_wait should block indefinitely.
|
||||||
|
ASIO_DECL int get_timeout(int msec);
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_TIMERFD)
|
||||||
|
// Get the timeout value for the timer descriptor. The return value is the
|
||||||
|
// flag argument to be used when calling timerfd_settime.
|
||||||
|
ASIO_DECL int get_timeout(itimerspec& ts);
|
||||||
|
#endif // defined(ASIO_HAS_TIMERFD)
|
||||||
|
|
||||||
|
// The scheduler implementation used to post completions.
|
||||||
|
scheduler& scheduler_;
|
||||||
|
|
||||||
|
// Mutex to protect access to internal data.
|
||||||
|
mutex mutex_;
|
||||||
|
|
||||||
|
// The interrupter is used to break a blocking epoll_wait call.
|
||||||
|
select_interrupter interrupter_;
|
||||||
|
|
||||||
|
// The epoll file descriptor.
|
||||||
|
int epoll_fd_;
|
||||||
|
|
||||||
|
// The timer file descriptor.
|
||||||
|
int timer_fd_;
|
||||||
|
|
||||||
|
// The timer queues.
|
||||||
|
timer_queue_set timer_queues_;
|
||||||
|
|
||||||
|
// Whether the service has been shut down.
|
||||||
|
bool shutdown_;
|
||||||
|
|
||||||
|
// Mutex to protect access to the registered descriptors.
|
||||||
|
mutex registered_descriptors_mutex_;
|
||||||
|
|
||||||
|
// Keep track of all registered descriptors.
|
||||||
|
object_pool<descriptor_state> registered_descriptors_;
|
||||||
|
|
||||||
|
// Helper class to do post-perform_io cleanup.
|
||||||
|
struct perform_io_cleanup_on_block_exit;
|
||||||
|
friend struct perform_io_cleanup_on_block_exit;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/impl/epoll_reactor.hpp"
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/detail/impl/epoll_reactor.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_EPOLL)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_EPOLL_REACTOR_HPP
|
||||||
|
|
@ -0,0 +1,48 @@
|
||||||
|
//
|
||||||
|
// detail/event.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_EVENT_HPP
|
||||||
|
#define ASIO_DETAIL_EVENT_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_THREADS)
|
||||||
|
# include "asio/detail/null_event.hpp"
|
||||||
|
#elif defined(ASIO_WINDOWS)
|
||||||
|
# include "asio/detail/win_event.hpp"
|
||||||
|
#elif defined(ASIO_HAS_PTHREADS)
|
||||||
|
# include "asio/detail/posix_event.hpp"
|
||||||
|
#elif defined(ASIO_HAS_STD_MUTEX_AND_CONDVAR)
|
||||||
|
# include "asio/detail/std_event.hpp"
|
||||||
|
#else
|
||||||
|
# error Only Windows, POSIX and std::condition_variable are supported!
|
||||||
|
#endif
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if !defined(ASIO_HAS_THREADS)
|
||||||
|
typedef null_event event;
|
||||||
|
#elif defined(ASIO_WINDOWS)
|
||||||
|
typedef win_event event;
|
||||||
|
#elif defined(ASIO_HAS_PTHREADS)
|
||||||
|
typedef posix_event event;
|
||||||
|
#elif defined(ASIO_HAS_STD_MUTEX_AND_CONDVAR)
|
||||||
|
typedef std_event event;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_EVENT_HPP
|
||||||
|
|
@ -0,0 +1,83 @@
|
||||||
|
//
|
||||||
|
// detail/eventfd_select_interrupter.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
// Copyright (c) 2008 Roelof Naude (roelof.naude at gmail dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
|
||||||
|
#define ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_EVENTFD)
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
class eventfd_select_interrupter
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
// Constructor.
|
||||||
|
ASIO_DECL eventfd_select_interrupter();
|
||||||
|
|
||||||
|
// Destructor.
|
||||||
|
ASIO_DECL ~eventfd_select_interrupter();
|
||||||
|
|
||||||
|
// Recreate the interrupter's descriptors. Used after a fork.
|
||||||
|
ASIO_DECL void recreate();
|
||||||
|
|
||||||
|
// Interrupt the select call.
|
||||||
|
ASIO_DECL void interrupt();
|
||||||
|
|
||||||
|
// Reset the select interrupter. Returns true if the reset was successful.
|
||||||
|
ASIO_DECL bool reset();
|
||||||
|
|
||||||
|
// Get the read descriptor to be passed to select.
|
||||||
|
int read_descriptor() const
|
||||||
|
{
|
||||||
|
return read_descriptor_;
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Open the descriptors. Throws on error.
|
||||||
|
ASIO_DECL void open_descriptors();
|
||||||
|
|
||||||
|
// Close the descriptors.
|
||||||
|
ASIO_DECL void close_descriptors();
|
||||||
|
|
||||||
|
// The read end of a connection used to interrupt the select call. This file
|
||||||
|
// descriptor is passed to select such that when it is time to stop, a single
|
||||||
|
// 64bit value will be written on the other end of the connection and this
|
||||||
|
// descriptor will become readable.
|
||||||
|
int read_descriptor_;
|
||||||
|
|
||||||
|
// The write end of a connection used to interrupt the select call. A single
|
||||||
|
// 64bit non-zero value may be written to this to wake up the select which is
|
||||||
|
// waiting for the other end to become readable. This descriptor will only
|
||||||
|
// differ from the read descriptor when a pipe is used.
|
||||||
|
int write_descriptor_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#if defined(ASIO_HEADER_ONLY)
|
||||||
|
# include "asio/detail/impl/eventfd_select_interrupter.ipp"
|
||||||
|
#endif // defined(ASIO_HEADER_ONLY)
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_EVENTFD)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_EVENTFD_SELECT_INTERRUPTER_HPP
|
||||||
|
|
@ -0,0 +1,204 @@
|
||||||
|
//
|
||||||
|
// detail/executor_function.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
|
||||||
|
#define ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/handler_alloc_helpers.hpp"
|
||||||
|
#include "asio/detail/handler_invoke_helpers.hpp"
|
||||||
|
#include "asio/detail/memory.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
// Lightweight, move-only function object wrapper.
|
||||||
|
class executor_function
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename F, typename Alloc>
|
||||||
|
explicit executor_function(F f, const Alloc& a)
|
||||||
|
{
|
||||||
|
// Allocate and construct an object to wrap the function.
|
||||||
|
typedef impl<F, Alloc> impl_type;
|
||||||
|
typename impl_type::ptr p = {
|
||||||
|
detail::addressof(a), impl_type::ptr::allocate(a), 0 };
|
||||||
|
impl_ = new (p.v) impl_type(ASIO_MOVE_CAST(F)(f), a);
|
||||||
|
p.v = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
executor_function(executor_function&& other) ASIO_NOEXCEPT
|
||||||
|
: impl_(other.impl_)
|
||||||
|
{
|
||||||
|
other.impl_ = 0;
|
||||||
|
}
|
||||||
|
|
||||||
|
~executor_function()
|
||||||
|
{
|
||||||
|
if (impl_)
|
||||||
|
impl_->complete_(impl_, false);
|
||||||
|
}
|
||||||
|
|
||||||
|
void operator()()
|
||||||
|
{
|
||||||
|
if (impl_)
|
||||||
|
{
|
||||||
|
impl_base* i = impl_;
|
||||||
|
impl_ = 0;
|
||||||
|
i->complete_(i, true);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Base class for polymorphic function implementations.
|
||||||
|
struct impl_base
|
||||||
|
{
|
||||||
|
void (*complete_)(impl_base*, bool);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Polymorphic function implementation.
|
||||||
|
template <typename Function, typename Alloc>
|
||||||
|
struct impl : impl_base
|
||||||
|
{
|
||||||
|
ASIO_DEFINE_TAGGED_HANDLER_ALLOCATOR_PTR(
|
||||||
|
thread_info_base::executor_function_tag, impl);
|
||||||
|
|
||||||
|
template <typename F>
|
||||||
|
impl(ASIO_MOVE_ARG(F) f, const Alloc& a)
|
||||||
|
: function_(ASIO_MOVE_CAST(F)(f)),
|
||||||
|
allocator_(a)
|
||||||
|
{
|
||||||
|
complete_ = &executor_function::complete<Function, Alloc>;
|
||||||
|
}
|
||||||
|
|
||||||
|
Function function_;
|
||||||
|
Alloc allocator_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to complete function invocation.
|
||||||
|
template <typename Function, typename Alloc>
|
||||||
|
static void complete(impl_base* base, bool call)
|
||||||
|
{
|
||||||
|
// Take ownership of the function object.
|
||||||
|
impl<Function, Alloc>* i(static_cast<impl<Function, Alloc>*>(base));
|
||||||
|
Alloc allocator(i->allocator_);
|
||||||
|
typename impl<Function, Alloc>::ptr p = {
|
||||||
|
detail::addressof(allocator), i, i };
|
||||||
|
|
||||||
|
// Make a copy of the function so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the function may be the true owner of the memory
|
||||||
|
// associated with the function. Consequently, a local copy of the function
|
||||||
|
// is required to ensure that any owning sub-object remains valid until
|
||||||
|
// after we have deallocated the memory here.
|
||||||
|
Function function(ASIO_MOVE_CAST(Function)(i->function_));
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (call)
|
||||||
|
{
|
||||||
|
asio_handler_invoke_helpers::invoke(function, function);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl_base* impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#else // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
// Not so lightweight, copyable function object wrapper.
|
||||||
|
class executor_function
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename F, typename Alloc>
|
||||||
|
explicit executor_function(const F& f, const Alloc&)
|
||||||
|
: impl_(new impl<typename decay<F>::type>(f))
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void operator()()
|
||||||
|
{
|
||||||
|
impl_->complete_(impl_.get());
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Base class for polymorphic function implementations.
|
||||||
|
struct impl_base
|
||||||
|
{
|
||||||
|
void (*complete_)(impl_base*);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Polymorphic function implementation.
|
||||||
|
template <typename F>
|
||||||
|
struct impl : impl_base
|
||||||
|
{
|
||||||
|
impl(const F& f)
|
||||||
|
: function_(f)
|
||||||
|
{
|
||||||
|
complete_ = &executor_function::complete<F>;
|
||||||
|
}
|
||||||
|
|
||||||
|
F function_;
|
||||||
|
};
|
||||||
|
|
||||||
|
// Helper to complete function invocation.
|
||||||
|
template <typename F>
|
||||||
|
static void complete(impl_base* i)
|
||||||
|
{
|
||||||
|
static_cast<impl<F>*>(i)->function_();
|
||||||
|
}
|
||||||
|
|
||||||
|
shared_ptr<impl_base> impl_;
|
||||||
|
};
|
||||||
|
|
||||||
|
#endif // defined(ASIO_HAS_MOVE)
|
||||||
|
|
||||||
|
// Lightweight, non-owning, copyable function object wrapper.
|
||||||
|
class executor_function_view
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
template <typename F>
|
||||||
|
explicit executor_function_view(F& f) ASIO_NOEXCEPT
|
||||||
|
: complete_(&executor_function_view::complete<F>),
|
||||||
|
function_(&f)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
void operator()()
|
||||||
|
{
|
||||||
|
complete_(function_);
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
// Helper to complete function invocation.
|
||||||
|
template <typename F>
|
||||||
|
static void complete(void* f)
|
||||||
|
{
|
||||||
|
(*static_cast<F*>(f))();
|
||||||
|
}
|
||||||
|
|
||||||
|
void (*complete_)(void*);
|
||||||
|
void* function_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_EXECUTOR_FUNCTION_HPP
|
||||||
|
|
@ -0,0 +1,84 @@
|
||||||
|
//
|
||||||
|
// detail/executor_op.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_EXECUTOR_OP_HPP
|
||||||
|
#define ASIO_DETAIL_EXECUTOR_OP_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
#include "asio/detail/fenced_block.hpp"
|
||||||
|
#include "asio/detail/handler_alloc_helpers.hpp"
|
||||||
|
#include "asio/detail/handler_invoke_helpers.hpp"
|
||||||
|
#include "asio/detail/scheduler_operation.hpp"
|
||||||
|
|
||||||
|
#include "asio/detail/push_options.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
template <typename Handler, typename Alloc,
|
||||||
|
typename Operation = scheduler_operation>
|
||||||
|
class executor_op : public Operation
|
||||||
|
{
|
||||||
|
public:
|
||||||
|
ASIO_DEFINE_HANDLER_ALLOCATOR_PTR(executor_op);
|
||||||
|
|
||||||
|
template <typename H>
|
||||||
|
executor_op(ASIO_MOVE_ARG(H) h, const Alloc& allocator)
|
||||||
|
: Operation(&executor_op::do_complete),
|
||||||
|
handler_(ASIO_MOVE_CAST(H)(h)),
|
||||||
|
allocator_(allocator)
|
||||||
|
{
|
||||||
|
}
|
||||||
|
|
||||||
|
static void do_complete(void* owner, Operation* base,
|
||||||
|
const asio::error_code& /*ec*/,
|
||||||
|
std::size_t /*bytes_transferred*/)
|
||||||
|
{
|
||||||
|
// Take ownership of the handler object.
|
||||||
|
executor_op* o(static_cast<executor_op*>(base));
|
||||||
|
Alloc allocator(o->allocator_);
|
||||||
|
ptr p = { detail::addressof(allocator), o, o };
|
||||||
|
|
||||||
|
ASIO_HANDLER_COMPLETION((*o));
|
||||||
|
|
||||||
|
// Make a copy of the handler so that the memory can be deallocated before
|
||||||
|
// the upcall is made. Even if we're not about to make an upcall, a
|
||||||
|
// sub-object of the handler may be the true owner of the memory associated
|
||||||
|
// with the handler. Consequently, a local copy of the handler is required
|
||||||
|
// to ensure that any owning sub-object remains valid until after we have
|
||||||
|
// deallocated the memory here.
|
||||||
|
Handler handler(ASIO_MOVE_CAST(Handler)(o->handler_));
|
||||||
|
p.reset();
|
||||||
|
|
||||||
|
// Make the upcall if required.
|
||||||
|
if (owner)
|
||||||
|
{
|
||||||
|
fenced_block b(fenced_block::half);
|
||||||
|
ASIO_HANDLER_INVOCATION_BEGIN(());
|
||||||
|
asio_handler_invoke_helpers::invoke(handler, handler);
|
||||||
|
ASIO_HANDLER_INVOCATION_END;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
private:
|
||||||
|
Handler handler_;
|
||||||
|
Alloc allocator_;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#include "asio/detail/pop_options.hpp"
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_EXECUTOR_OP_HPP
|
||||||
|
|
@ -0,0 +1,39 @@
|
||||||
|
//
|
||||||
|
// detail/fd_set_adapter.hpp
|
||||||
|
// ~~~~~~~~~~~~~~~~~~~~~~~~~
|
||||||
|
//
|
||||||
|
// Copyright (c) 2003-2022 Christopher M. Kohlhoff (chris at kohlhoff dot com)
|
||||||
|
//
|
||||||
|
// Distributed under the Boost Software License, Version 1.0. (See accompanying
|
||||||
|
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||||
|
//
|
||||||
|
|
||||||
|
#ifndef ASIO_DETAIL_FD_SET_ADAPTER_HPP
|
||||||
|
#define ASIO_DETAIL_FD_SET_ADAPTER_HPP
|
||||||
|
|
||||||
|
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
# pragma once
|
||||||
|
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
|
||||||
|
|
||||||
|
#include "asio/detail/config.hpp"
|
||||||
|
|
||||||
|
#if !defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
|
||||||
|
#include "asio/detail/posix_fd_set_adapter.hpp"
|
||||||
|
#include "asio/detail/win_fd_set_adapter.hpp"
|
||||||
|
|
||||||
|
namespace asio {
|
||||||
|
namespace detail {
|
||||||
|
|
||||||
|
#if defined(ASIO_WINDOWS) || defined(__CYGWIN__)
|
||||||
|
typedef win_fd_set_adapter fd_set_adapter;
|
||||||
|
#else
|
||||||
|
typedef posix_fd_set_adapter fd_set_adapter;
|
||||||
|
#endif
|
||||||
|
|
||||||
|
} // namespace detail
|
||||||
|
} // namespace asio
|
||||||
|
|
||||||
|
#endif // !defined(ASIO_WINDOWS_RUNTIME)
|
||||||
|
|
||||||
|
#endif // ASIO_DETAIL_FD_SET_ADAPTER_HPP
|
||||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue