From 352fb66987fe28a208f5841236b3a8dcd3c640e9 Mon Sep 17 00:00:00 2001 From: realaravinth Date: Fri, 8 Oct 2021 10:07:55 +0000 Subject: [PATCH] =?UTF-8?q?Deploying=20to=20gh-pages=20from=20=20@=2053720?= =?UTF-8?q?ff7401d3875f11092f4b055a0fdede92ac2=20=F0=9F=9A=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- COPYRIGHT.txt | 14 +- FiraSans-LICENSE.txt | 4 +- SourceCodePro-It.ttf.woff2 | Bin 0 -> 44896 bytes SourceCodePro-Regular.ttf.woff2 | Bin 0 -> 52228 bytes SourceCodePro-Semibold.ttf.woff2 | Bin 0 -> 52348 bytes SourceSerif4-Bold.ttf.woff2 | Bin 0 -> 81320 bytes SourceSerif4-It.ttf.woff2 | Bin 0 -> 59860 bytes SourceSerif4-Regular.ttf.woff2 | Bin 0 -> 76180 bytes ayu.css | 2 +- dark.css | 2 +- implementors/core/clone/trait.Clone.js | 4 +- implementors/core/cmp/trait.PartialEq.js | 2 +- implementors/core/convert/trait.From.js | 4 +- implementors/core/default/trait.Default.js | 2 +- implementors/core/fmt/trait.Debug.js | 4 +- implementors/core/fmt/trait.Display.js | 2 +- implementors/core/marker/trait.Freeze.js | 4 +- implementors/core/marker/trait.Send.js | 6 +- .../core/marker/trait.StructuralPartialEq.js | 2 +- implementors/core/marker/trait.Sync.js | 6 +- implementors/core/marker/trait.Unpin.js | 6 +- implementors/core/ops/deref/trait.Deref.js | 4 +- implementors/sailfish/private/trait.Sealed.js | 2 +- implementors/sailfish/trait.TemplateOnce.js | 2 +- implementors/std/error/trait.Error.js | 2 +- implementors/std/panic/trait.RefUnwindSafe.js | 6 +- implementors/std/panic/trait.UnwindSafe.js | 6 +- light.css | 2 +- main.js | 2 +- mcaptcha/all.html | 8 +- mcaptcha/api/index.html | 8 +- .../api/v1/account/delete/fn.services.html | 6 +- mcaptcha/api/v1/account/delete/index.html | 12 +- .../delete/runners/fn.delete_user.html | 6 +- .../api/v1/account/delete/runners/index.html | 8 +- .../account/delete/struct.delete_account.html | 154 ++++++------- .../api/v1/account/email/fn.services.html | 6 +- mcaptcha/api/v1/account/email/index.html | 12 +- .../api/v1/account/email/struct.Email.html | 177 ++++++++------- .../v1/account/email/struct.email_exists.html | 154 ++++++------- .../v1/account/email/struct.set_email.html | 156 +++++++------- mcaptcha/api/v1/account/fn.services.html | 6 +- mcaptcha/api/v1/account/index.html | 14 +- .../api/v1/account/password/fn.services.html | 6 +- .../password/fn.update_password_runner.html | 6 +- mcaptcha/api/v1/account/password/index.html | 10 +- .../password/struct.ChangePasswordReqest.html | 183 ++++++++-------- .../password/struct.UpdatePassword.html | 163 +++++++------- .../password/struct.update_user_password.html | 154 ++++++------- mcaptcha/api/v1/account/routes/index.html | 8 +- .../api/v1/account/routes/struct.Account.html | 173 ++++++++------- .../api/v1/account/secret/fn.services.html | 6 +- mcaptcha/api/v1/account/secret/index.html | 10 +- .../api/v1/account/secret/struct.Secret.html | 177 ++++++++------- .../v1/account/secret/struct.get_secret.html | 154 ++++++------- .../secret/struct.update_user_secret.html | 154 ++++++------- .../account/struct.AccountCheckPayload.html | 177 ++++++++------- .../v1/account/struct.AccountCheckResp.html | 177 ++++++++------- .../api/v1/account/username/fn.services.html | 6 +- mcaptcha/api/v1/account/username/index.html | 14 +- .../username/runners/fn.username_exists.html | 6 +- .../v1/account/username/runners/index.html | 8 +- .../v1/account/username/struct.Username.html | 177 ++++++++------- .../account/username/struct.set_username.html | 156 +++++++------- .../username/struct.username_exists.html | 154 ++++++------- mcaptcha/api/v1/auth/fn.services.html | 6 +- mcaptcha/api/v1/auth/index.html | 12 +- mcaptcha/api/v1/auth/routes/index.html | 8 +- mcaptcha/api/v1/auth/routes/struct.Auth.html | 163 +++++++------- .../api/v1/auth/runners/fn.login_runner.html | 8 +- .../v1/auth/runners/fn.register_runner.html | 6 +- mcaptcha/api/v1/auth/runners/index.html | 12 +- .../api/v1/auth/runners/struct.Login.html | 179 ++++++++------- .../api/v1/auth/runners/struct.Password.html | 177 ++++++++------- .../api/v1/auth/runners/struct.Register.html | 183 ++++++++-------- mcaptcha/api/v1/auth/struct.login.html | 154 ++++++------- mcaptcha/api/v1/auth/struct.register.html | 154 ++++++------- mcaptcha/api/v1/auth/struct.signout.html | 154 ++++++------- mcaptcha/api/v1/fn.services.html | 6 +- mcaptcha/api/v1/index.html | 12 +- .../captcha/fn.add_mcaptcha_util.html | 6 +- .../api/v1/mcaptcha/captcha/fn.services.html | 6 +- .../captcha/fn.update_token_helper.html | 6 +- mcaptcha/api/v1/mcaptcha/captcha/index.html | 12 +- .../api/v1/mcaptcha/captcha/routes/index.html | 8 +- .../captcha/routes/struct.MCaptcha.html | 163 +++++++------- .../captcha/struct.DeleteCaptcha.html | 179 ++++++++------- .../captcha/struct.MCaptchaDetails.html | 179 ++++++++------- .../mcaptcha/captcha/struct.MCaptchaID.html | 177 ++++++++------- .../mcaptcha/captcha/struct.StatsPayload.html | 177 ++++++++------- .../captcha/struct.delete_mcaptcha.html | 154 ++++++------- .../v1/mcaptcha/captcha/struct.get_stats.html | 154 ++++++------- .../mcaptcha/captcha/struct.update_token.html | 154 ++++++------- .../api/v1/mcaptcha/duration/fn.services.html | 6 +- mcaptcha/api/v1/mcaptcha/duration/index.html | 12 +- .../v1/mcaptcha/duration/routes/index.html | 8 +- .../duration/routes/struct.Duration.html | 161 +++++++------- .../mcaptcha/duration/struct.GetDuration.html | 163 +++++++------- .../duration/struct.GetDurationResp.html | 163 +++++++------- .../duration/struct.UpdateDuration.html | 165 +++++++------- .../duration/struct.get_duration.html | 154 ++++++------- .../duration/struct.update_duration.html | 154 ++++++------- mcaptcha/api/v1/mcaptcha/fn.get_random.html | 6 +- mcaptcha/api/v1/mcaptcha/fn.services.html | 6 +- mcaptcha/api/v1/mcaptcha/index.html | 10 +- .../mcaptcha/levels/fn.get_levels_util.html | 6 +- .../api/v1/mcaptcha/levels/fn.services.html | 6 +- mcaptcha/api/v1/mcaptcha/levels/index.html | 12 +- .../api/v1/mcaptcha/levels/routes/index.html | 8 +- .../mcaptcha/levels/routes/struct.Levels.html | 163 +++++++------- .../v1/mcaptcha/levels/struct.AddLevels.html | 167 +++++++------- .../v1/mcaptcha/levels/struct.I32Levels.html | 179 ++++++++------- .../api/v1/mcaptcha/levels/struct.Levels.html | 175 ++++++++------- .../mcaptcha/levels/struct.UpdateLevels.html | 169 ++++++++------- .../v1/mcaptcha/levels/struct.add_levels.html | 154 ++++++------- .../v1/mcaptcha/levels/struct.get_levels.html | 154 ++++++------- .../mcaptcha/levels/struct.update_levels.html | 154 ++++++------- .../meta/enum.BuildDetailsBuilderError.html | 184 ++++++++-------- .../api/v1/meta/enum.HealthBuilderError.html | 184 ++++++++-------- mcaptcha/api/v1/meta/fn.services.html | 6 +- mcaptcha/api/v1/meta/index.html | 28 +-- mcaptcha/api/v1/meta/routes/index.html | 8 +- mcaptcha/api/v1/meta/routes/struct.Meta.html | 161 +++++++------- mcaptcha/api/v1/meta/struct.BuildDetails.html | 179 ++++++++------- .../v1/meta/struct.BuildDetailsBuilder.html | 177 ++++++++------- mcaptcha/api/v1/meta/struct.Health.html | 179 ++++++++------- .../api/v1/meta/struct.HealthBuilder.html | 177 ++++++++------- .../api/v1/meta/struct.build_details.html | 156 +++++++------- mcaptcha/api/v1/meta/struct.health.html | 156 +++++++------- mcaptcha/api/v1/notifications/add/index.html | 10 +- .../add/struct.AddNotification.html | 167 +++++++------- .../add/struct.add_notification.html | 156 +++++++------- .../api/v1/notifications/fn.services.html | 6 +- mcaptcha/api/v1/notifications/get/index.html | 12 +- .../get/runner/fn.get_notification.html | 6 +- .../v1/notifications/get/runner/index.html | 8 +- .../get/struct.Notification.html | 171 ++++++++------- .../get/struct.NotificationResp.html | 173 ++++++++------- .../get/struct.get_notification.html | 156 +++++++------- mcaptcha/api/v1/notifications/index.html | 10 +- .../api/v1/notifications/mark_read/index.html | 10 +- .../mark_read/struct.MarkReadReq.html | 163 +++++++------- .../mark_read/struct.NotificationResp.html | 171 ++++++++------- .../mark_read/struct.mark_read.html | 156 +++++++------- .../api/v1/notifications/routes/index.html | 8 +- .../routes/struct.Notifications.html | 163 +++++++------- mcaptcha/api/v1/pow/fn.services.html | 6 +- .../v1/pow/get_config/fn.init_mcaptcha.html | 8 +- mcaptcha/api/v1/pow/get_config/index.html | 14 +- .../get_config/struct.GetConfigPayload.html | 177 ++++++++------- .../v1/pow/get_config/struct.get_config.html | 156 +++++++------- mcaptcha/api/v1/pow/index.html | 16 +- mcaptcha/api/v1/pow/routes/index.html | 8 +- mcaptcha/api/v1/pow/routes/struct.PoW.html | 165 +++++++------- mcaptcha/api/v1/pow/verify_pow/index.html | 12 +- .../verify_pow/struct.ValidationToken.html | 177 ++++++++------- .../v1/pow/verify_pow/struct.verify_pow.html | 156 +++++++------- mcaptcha/api/v1/pow/verify_token/index.html | 10 +- .../struct.CaptchaValidateResp.html | 177 ++++++++------- .../struct.validate_captcha_token.html | 156 +++++++------- mcaptcha/api/v1/routes/constant.ROUTES.html | 6 +- mcaptcha/api/v1/routes/index.html | 10 +- mcaptcha/api/v1/routes/struct.Routes.html | 157 +++++++------- mcaptcha/constant.CACHE_AGE.html | 6 +- mcaptcha/constant.COMPILED_DATE.html | 6 +- mcaptcha/constant.DOCS.html | 6 +- mcaptcha/constant.GIT_COMMIT_HASH.html | 6 +- mcaptcha/constant.OPEN_API_DOC.html | 6 +- mcaptcha/constant.PAGES.html | 6 +- mcaptcha/constant.PKG_DESCRIPTION.html | 6 +- mcaptcha/constant.PKG_HOMEPAGE.html | 6 +- mcaptcha/constant.PKG_NAME.html | 6 +- mcaptcha/constant.V1_API_ROUTES.html | 6 +- mcaptcha/constant.VERSION.html | 6 +- mcaptcha/constant.WIDGET_ROUTES.html | 6 +- mcaptcha/data/enum.SystemGroup.html | 158 +++++++------- mcaptcha/data/index.html | 18 +- mcaptcha/data/struct.Data.html | 165 +++++++------- mcaptcha/data/type.Mailer.html | 8 +- mcaptcha/date/constant.DAY.html | 6 +- mcaptcha/date/constant.HOUR.html | 6 +- mcaptcha/date/constant.MINUTE.html | 6 +- mcaptcha/date/constant.WEEK.html | 6 +- mcaptcha/date/index.html | 10 +- mcaptcha/date/struct.Date.html | 175 ++++++++------- mcaptcha/demo/constant.DEMO_PASSWORD.html | 8 +- mcaptcha/demo/constant.DEMO_USER.html | 8 +- mcaptcha/demo/fn.delete_demo_user.html | 6 +- mcaptcha/demo/fn.register_demo_user.html | 8 +- mcaptcha/demo/fn.run.html | 6 +- mcaptcha/demo/index.html | 16 +- mcaptcha/docs/constant.DOCS.html | 6 +- mcaptcha/docs/fn.handle_embedded_file.html | 6 +- mcaptcha/docs/fn.services.html | 6 +- mcaptcha/docs/index.html | 14 +- mcaptcha/docs/routes/index.html | 8 +- mcaptcha/docs/routes/struct.Docs.html | 163 +++++++------- mcaptcha/docs/struct.Asset.html | 158 +++++++------- mcaptcha/docs/struct.dist.html | 154 ++++++------- mcaptcha/docs/struct.index.html | 154 ++++++------- mcaptcha/docs/struct.spec.html | 154 ++++++------- mcaptcha/email/index.html | 10 +- .../email/verification/constant.PAGE.html | 6 +- .../email/verification/fn.verification.html | 6 +- mcaptcha/email/verification/index.html | 12 +- .../email/verification/struct.IndexPage.html | 175 ++++++++------- mcaptcha/errors/enum.PageError.html | 186 ++++++++-------- mcaptcha/errors/enum.ServiceError.html | 204 +++++++++--------- mcaptcha/errors/index.html | 12 +- mcaptcha/errors/struct.ErrorToResponse.html | 163 +++++++------- mcaptcha/errors/struct.SmtpErrorWrapper.html | 174 +++++++-------- mcaptcha/errors/type.PageResult.html | 6 +- mcaptcha/errors/type.ServiceResult.html | 6 +- mcaptcha/fn.get_identity_service.html | 6 +- mcaptcha/fn.get_json_err.html | 6 +- mcaptcha/fn.main.html | 6 +- mcaptcha/index.html | 28 +-- mcaptcha/macro.define_resource.html | 16 +- mcaptcha/middleware/auth/index.html | 8 +- .../middleware/auth/struct.CheckLogin.html | 166 +++++++------- .../auth/struct.CheckLoginMiddleware.html | 175 ++++++++------- mcaptcha/middleware/index.html | 8 +- mcaptcha/pages/auth/fn.services.html | 6 +- mcaptcha/pages/auth/index.html | 10 +- mcaptcha/pages/auth/login/constant.PAGE.html | 6 +- mcaptcha/pages/auth/login/index.html | 10 +- mcaptcha/pages/auth/login/struct.INDEX.html | 175 ++++++++------- .../pages/auth/login/struct.IndexPage.html | 172 +++++++-------- mcaptcha/pages/auth/login/struct.login.html | 154 ++++++------- .../pages/auth/register/constant.PAGE.html | 6 +- mcaptcha/pages/auth/register/index.html | 10 +- .../pages/auth/register/struct.INDEX.html | 175 ++++++++------- .../pages/auth/register/struct.IndexPage.html | 172 +++++++-------- mcaptcha/pages/auth/register/struct.join.html | 154 ++++++------- mcaptcha/pages/auth/routes/index.html | 8 +- mcaptcha/pages/auth/routes/struct.Auth.html | 161 +++++++------- mcaptcha/pages/auth/sudo/constant.PAGE.html | 6 +- mcaptcha/pages/auth/sudo/index.html | 10 +- mcaptcha/pages/auth/sudo/struct.SudoPage.html | 177 ++++++++------- mcaptcha/pages/constant.NAME.html | 6 +- .../pages/errors/constant.ERROR_ROUTE.html | 6 +- mcaptcha/pages/errors/constant.PAGE.html | 6 +- mcaptcha/pages/errors/fn.services.html | 6 +- mcaptcha/pages/errors/index.html | 14 +- mcaptcha/pages/errors/routes/index.html | 8 +- .../pages/errors/routes/struct.Errors.html | 161 +++++++------- mcaptcha/pages/errors/struct.ErrorPage.html | 177 ++++++++------- .../struct.INTERNAL_SERVER_ERROR_BODY.html | 175 ++++++++------- .../errors/struct.UNKNOWN_ERROR_BODY.html | 175 ++++++++------- mcaptcha/pages/errors/struct.error.html | 154 ++++++------- mcaptcha/pages/fn.services.html | 6 +- mcaptcha/pages/index.html | 12 +- mcaptcha/pages/panel/constant.PAGE.html | 6 +- mcaptcha/pages/panel/fn.services.html | 6 +- mcaptcha/pages/panel/index.html | 14 +- .../panel/notifications/constant.PAGE.html | 6 +- mcaptcha/pages/panel/notifications/index.html | 10 +- .../panel/notifications/struct.IndexPage.html | 165 +++++++------- .../notifications/struct.Notification.html | 167 +++++++------- .../notifications/struct.notifications.html | 154 ++++++------- mcaptcha/pages/panel/routes/index.html | 8 +- mcaptcha/pages/panel/routes/struct.Panel.html | 161 +++++++------- .../pages/panel/settings/constant.PAGE.html | 6 +- .../pages/panel/settings/fn.services.html | 6 +- mcaptcha/pages/panel/settings/index.html | 14 +- .../pages/panel/settings/routes/index.html | 8 +- .../settings/routes/struct.Settings.html | 163 +++++++------- .../panel/settings/struct.IndexPage.html | 179 ++++++++------- .../panel/settings/struct.delete_account.html | 154 ++++++------- .../pages/panel/settings/struct.settings.html | 154 ++++++------- .../panel/settings/struct.update_secret.html | 154 ++++++------- .../panel/sitekey/add/constant.PAGE.html | 6 +- mcaptcha/pages/panel/sitekey/add/index.html | 10 +- .../pages/panel/sitekey/add/struct.INDEX.html | 175 ++++++++------- .../panel/sitekey/add/struct.IndexPage.html | 183 ++++++++-------- .../panel/sitekey/add/struct.add_sitekey.html | 154 ++++++------- .../pages/panel/sitekey/delete/index.html | 8 +- .../sitekey/delete/struct.delete_sitekey.html | 154 ++++++------- .../panel/sitekey/edit/constant.PAGE.html | 6 +- mcaptcha/pages/panel/sitekey/edit/index.html | 12 +- .../panel/sitekey/edit/struct.IndexPage.html | 181 ++++++++-------- .../panel/sitekey/edit/struct.Level.html | 173 ++++++++------- .../sitekey/edit/struct.McaptchaConfig.html | 175 ++++++++------- .../sitekey/edit/struct.edit_sitekey.html | 156 +++++++------- mcaptcha/pages/panel/sitekey/fn.services.html | 6 +- mcaptcha/pages/panel/sitekey/index.html | 10 +- .../panel/sitekey/list/constant.PAGE.html | 6 +- .../sitekey/list/fn.get_list_sitekeys.html | 8 +- mcaptcha/pages/panel/sitekey/list/index.html | 18 +- .../panel/sitekey/list/struct.IndexPage.html | 175 ++++++++------- .../sitekey/list/struct.list_sitekeys.html | 156 +++++++------- .../panel/sitekey/list/type.SiteKeys.html | 6 +- .../pages/panel/sitekey/routes/index.html | 8 +- .../panel/sitekey/routes/struct.Sitekey.html | 167 +++++++------- .../panel/sitekey/view/constant.PAGE.html | 6 +- mcaptcha/pages/panel/sitekey/view/index.html | 12 +- .../panel/sitekey/view/struct.IndexPage.html | 181 ++++++++-------- .../panel/sitekey/view/struct.Level.html | 173 ++++++++------- .../sitekey/view/struct.McaptchaConfig.html | 175 ++++++++------- .../sitekey/view/struct.view_sitekey.html | 156 +++++++------- mcaptcha/pages/panel/struct.IndexPage.html | 175 ++++++++------- mcaptcha/pages/panel/struct.panel.html | 154 ++++++------- mcaptcha/pages/routes/constant.ROUTES.html | 6 +- mcaptcha/pages/routes/index.html | 10 +- mcaptcha/pages/routes/struct.Routes.html | 171 ++++++++------- mcaptcha/pages/sitemap/index.html | 8 +- mcaptcha/pages/sitemap/struct.INDEX.html | 175 ++++++++------- mcaptcha/pages/sitemap/struct.IndexPage.html | 179 ++++++++------- mcaptcha/pages/sitemap/struct.sitemap.html | 154 ++++++------- mcaptcha/routes/enum.Methods.html | 160 +++++++------- mcaptcha/routes/index.html | 8 +- mcaptcha/settings/fn.check_url.html | 6 +- mcaptcha/settings/fn.set_database_url.html | 6 +- .../settings/fn.set_from_database_url.html | 6 +- mcaptcha/settings/index.html | 10 +- mcaptcha/settings/struct.Captcha.html | 177 ++++++++------- mcaptcha/settings/struct.Database.html | 177 ++++++++------- mcaptcha/settings/struct.DatabaseBuilder.html | 185 ++++++++-------- mcaptcha/settings/struct.Redis.html | 177 ++++++++------- mcaptcha/settings/struct.Server.html | 185 ++++++++-------- mcaptcha/settings/struct.Settings.html | 187 ++++++++-------- mcaptcha/settings/struct.Smtp.html | 185 ++++++++-------- mcaptcha/static_assets/filemap/index.html | 8 +- .../static_assets/filemap/struct.FileMap.html | 157 +++++++------- mcaptcha/static_assets/fn.services.html | 6 +- mcaptcha/static_assets/index.html | 12 +- .../static_files/assets/index.html | 10 +- .../static_files/assets/struct.BAR_CHART.html | 163 +++++++------- .../assets/struct.CREDIT_CARD.html | 163 +++++++------- .../static_files/assets/struct.DOCS_ICON.html | 163 +++++++------- .../static_files/assets/struct.GITHUB.html | 163 +++++++------- .../assets/struct.HELP_CIRCLE.html | 163 +++++++------- .../static_files/assets/struct.HOME.html | 163 +++++++------- .../static_files/assets/struct.KEY.html | 163 +++++++------- .../assets/struct.MCAPTCHA_TRANS_ICON.html | 163 +++++++------- .../static_files/assets/struct.MESSAGE.html | 163 +++++++------- .../assets/struct.SETTINGS_ICON.html | 163 +++++++------- .../static_files/assets/type.Img.html | 6 +- .../static_files/fn.handle_assets.html | 6 +- .../static_files/fn.handle_favicons.html | 6 +- .../static_assets/static_files/index.html | 12 +- .../static_files/struct.Asset.html | 158 +++++++------- .../static_files/struct.Favicons.html | 158 +++++++------- .../static_files/struct.favicons.html | 154 ++++++------- .../static_files/struct.static_files.html | 154 ++++++------- mcaptcha/stats/fetch/index.html | 10 +- .../runners/fn.fetch_config_fetched.html | 8 +- .../stats/fetch/runners/fn.fetch_confirm.html | 8 +- .../stats/fetch/runners/fn.fetch_solve.html | 8 +- mcaptcha/stats/fetch/runners/index.html | 14 +- mcaptcha/stats/fetch/struct.Stats.html | 177 ++++++++------- mcaptcha/stats/fetch/struct.StatsPayload.html | 177 ++++++++------- .../fetch/struct.StatsUnixTimestamp.html | 183 ++++++++-------- mcaptcha/stats/index.html | 8 +- mcaptcha/stats/record/fn.record_confirm.html | 8 +- mcaptcha/stats/record/fn.record_fetch.html | 8 +- mcaptcha/stats/record/fn.record_solve.html | 8 +- mcaptcha/stats/record/index.html | 14 +- mcaptcha/struct.BAR_CHART.html | 163 +++++++------- mcaptcha/struct.CREDIT_CARD.html | 163 +++++++------- mcaptcha/struct.CSS.html | 163 +++++++------- mcaptcha/struct.CheckLogin.html | 166 +++++++------- mcaptcha/struct.DOCS_ICON.html | 163 +++++++------- mcaptcha/struct.Data.html | 165 +++++++------- mcaptcha/struct.FILES.html | 163 +++++++------- mcaptcha/struct.GITHUB.html | 163 +++++++------- mcaptcha/struct.HELP_CIRCLE.html | 163 +++++++------- mcaptcha/struct.HOME.html | 163 +++++++------- mcaptcha/struct.JS.html | 163 +++++++------- mcaptcha/struct.KEY.html | 163 +++++++------- mcaptcha/struct.MCAPTCHA_TRANS_ICON.html | 163 +++++++------- mcaptcha/struct.MESSAGE.html | 163 +++++++------- mcaptcha/struct.MOBILE_CSS.html | 163 +++++++------- mcaptcha/struct.SETTINGS.html | 163 +++++++------- mcaptcha/struct.SETTINGS_ICON.html | 163 +++++++------- mcaptcha/struct.SOURCE_FILES_OF_INSTANCE.html | 175 ++++++++------- mcaptcha/struct.Settings.html | 187 ++++++++-------- mcaptcha/struct.VERIFICATIN_WIDGET_CSS.html | 163 +++++++------- mcaptcha/struct.VERIFICATIN_WIDGET_JS.html | 163 +++++++------- mcaptcha/type.AppData.html | 6 +- mcaptcha/widget/constant.PAGE.html | 6 +- mcaptcha/widget/constant.WIDGET_ROUTES.html | 6 +- mcaptcha/widget/fn.services.html | 8 +- mcaptcha/widget/index.html | 18 +- mcaptcha/widget/routes/index.html | 8 +- mcaptcha/widget/routes/struct.Widget.html | 159 +++++++------- mcaptcha/widget/struct.INDEX_PAGE.html | 175 ++++++++------- mcaptcha/widget/struct.IndexPage.html | 170 +++++++-------- mcaptcha/widget/struct.show_widget.html | 156 +++++++------- mcaptcha_browser/all.html | 8 +- .../fn.__wasm_bindgen_generated_gen_pow.html | 8 +- mcaptcha_browser/fn.gen_pow.html | 8 +- mcaptcha_browser/index.html | 14 +- mcaptcha_browser/struct.Work.html | 39 ++-- normalize.css | 4 +- rustdoc.css | 2 +- search-index.js | 6 +- search.js | 2 +- settings.html | 8 +- src/mcaptcha/api/mod.rs.html | 8 +- src/mcaptcha/api/v1/account/delete.rs.html | 8 +- src/mcaptcha/api/v1/account/email.rs.html | 8 +- src/mcaptcha/api/v1/account/mod.rs.html | 8 +- src/mcaptcha/api/v1/account/password.rs.html | 8 +- src/mcaptcha/api/v1/account/secret.rs.html | 8 +- src/mcaptcha/api/v1/account/username.rs.html | 8 +- src/mcaptcha/api/v1/auth.rs.html | 8 +- src/mcaptcha/api/v1/mcaptcha/captcha.rs.html | 8 +- src/mcaptcha/api/v1/mcaptcha/duration.rs.html | 8 +- src/mcaptcha/api/v1/mcaptcha/levels.rs.html | 30 ++- src/mcaptcha/api/v1/mcaptcha/mod.rs.html | 8 +- src/mcaptcha/api/v1/meta.rs.html | 8 +- src/mcaptcha/api/v1/mod.rs.html | 8 +- src/mcaptcha/api/v1/notifications/add.rs.html | 8 +- src/mcaptcha/api/v1/notifications/get.rs.html | 8 +- .../api/v1/notifications/mark_read.rs.html | 8 +- src/mcaptcha/api/v1/notifications/mod.rs.html | 8 +- src/mcaptcha/api/v1/pow/get_config.rs.html | 8 +- src/mcaptcha/api/v1/pow/mod.rs.html | 8 +- src/mcaptcha/api/v1/pow/verify_pow.rs.html | 8 +- src/mcaptcha/api/v1/pow/verify_token.rs.html | 8 +- src/mcaptcha/api/v1/routes.rs.html | 8 +- src/mcaptcha/data.rs.html | 8 +- src/mcaptcha/date.rs.html | 8 +- src/mcaptcha/demo.rs.html | 8 +- src/mcaptcha/docs.rs.html | 8 +- src/mcaptcha/email/mod.rs.html | 8 +- src/mcaptcha/email/verification.rs.html | 8 +- src/mcaptcha/errors.rs.html | 8 +- src/mcaptcha/main.rs.html | 8 +- src/mcaptcha/middleware/auth.rs.html | 8 +- src/mcaptcha/middleware/mod.rs.html | 8 +- src/mcaptcha/pages/auth/login.rs.html | 8 +- src/mcaptcha/pages/auth/mod.rs.html | 8 +- src/mcaptcha/pages/auth/register.rs.html | 8 +- src/mcaptcha/pages/auth/sudo.rs.html | 8 +- src/mcaptcha/pages/errors.rs.html | 8 +- src/mcaptcha/pages/mod.rs.html | 8 +- src/mcaptcha/pages/panel/mod.rs.html | 8 +- .../pages/panel/notifications.rs.html | 8 +- src/mcaptcha/pages/panel/settings.rs.html | 8 +- src/mcaptcha/pages/panel/sitekey/add.rs.html | 8 +- .../pages/panel/sitekey/delete.rs.html | 8 +- src/mcaptcha/pages/panel/sitekey/edit.rs.html | 8 +- src/mcaptcha/pages/panel/sitekey/list.rs.html | 8 +- src/mcaptcha/pages/panel/sitekey/mod.rs.html | 8 +- src/mcaptcha/pages/panel/sitekey/view.rs.html | 8 +- src/mcaptcha/pages/routes.rs.html | 8 +- src/mcaptcha/pages/sitemap.rs.html | 8 +- src/mcaptcha/routes.rs.html | 8 +- src/mcaptcha/settings.rs.html | 8 +- src/mcaptcha/static_assets/filemap.rs.html | 8 +- src/mcaptcha/static_assets/mod.rs.html | 8 +- .../static_assets/static_files.rs.html | 8 +- src/mcaptcha/stats/fetch.rs.html | 8 +- src/mcaptcha/stats/mod.rs.html | 8 +- src/mcaptcha/stats/record.rs.html | 8 +- src/mcaptcha/widget/mod.rs.html | 8 +- src/mcaptcha_browser/lib.rs.html | 8 +- src/tests_migrate/settings.rs.html | 8 +- src/tests_migrate/tests-migrate.rs.html | 8 +- tests_migrate/all.html | 8 +- tests_migrate/fn.build.html | 6 +- tests_migrate/fn.cache_bust.html | 6 +- tests_migrate/fn.main.html | 6 +- tests_migrate/index.html | 12 +- tests_migrate/settings/fn.check_url.html | 6 +- .../settings/fn.set_database_url.html | 6 +- .../settings/fn.set_from_database_url.html | 6 +- tests_migrate/settings/index.html | 10 +- tests_migrate/settings/struct.Captcha.html | 177 ++++++++------- tests_migrate/settings/struct.Database.html | 177 ++++++++------- .../settings/struct.DatabaseBuilder.html | 185 ++++++++-------- tests_migrate/settings/struct.Redis.html | 177 ++++++++------- tests_migrate/settings/struct.Server.html | 185 ++++++++-------- tests_migrate/settings/struct.Settings.html | 187 ++++++++-------- tests_migrate/settings/struct.Smtp.html | 185 ++++++++-------- tests_migrate/struct.SETTINGS.html | 163 +++++++------- tests_migrate/struct.Settings.html | 187 ++++++++-------- 479 files changed, 16888 insertions(+), 17008 deletions(-) create mode 100644 SourceCodePro-It.ttf.woff2 create mode 100644 SourceCodePro-Regular.ttf.woff2 create mode 100644 SourceCodePro-Semibold.ttf.woff2 create mode 100644 SourceSerif4-Bold.ttf.woff2 create mode 100644 SourceSerif4-It.ttf.woff2 create mode 100644 SourceSerif4-Regular.ttf.woff2 diff --git a/COPYRIGHT.txt b/COPYRIGHT.txt index 16d79032..c2629a83 100644 --- a/COPYRIGHT.txt +++ b/COPYRIGHT.txt @@ -2,7 +2,8 @@ These documentation pages include resources by third parties. This copyright file applies only to those resources. The following third party resources are included, and carry their own copyright notices and license terms: -* Fira Sans (FiraSans-Regular.woff, FiraSans-Medium.woff): +* Fira Sans (FiraSans-Regular.woff2, FiraSans-Medium.woff2, + FiraSans-Regular.woff, FiraSans-Medium.woff): Copyright (c) 2014, Mozilla Foundation https://mozilla.org/ with Reserved Font Name Fira Sans. @@ -23,8 +24,10 @@ included, and carry their own copyright notices and license terms: Copyright (c) Nicolas Gallagher and Jonathan Neal. Licensed under the MIT license (see LICENSE-MIT.txt). -* Source Code Pro (SourceCodePro-Regular.ttf.woff, - SourceCodePro-Semibold.ttf.woff, SourceCodePro-It.ttf.woff): +* Source Code Pro (SourceCodePro-Regular.ttf.woff2, + SourceCodePro-Semibold.ttf.woff2, SourceCodePro-It.ttf.woff2, + SourceCodePro-Regular.ttf.woff, SourceCodePro-Semibold.ttf.woff, + SourceCodePro-It.ttf.woff): Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark @@ -33,8 +36,9 @@ included, and carry their own copyright notices and license terms: Licensed under the SIL Open Font License, Version 1.1. See SourceCodePro-LICENSE.txt. -* Source Serif 4 (SourceSerif4-Regular.ttf.woff, SourceSerif4-Bold.ttf.woff, - SourceSerif4-It.ttf.woff): +* Source Serif 4 (SourceSerif4-Regular.ttf.woff2, SourceSerif4-Bold.ttf.woff2, + SourceSerif4-It.ttf.woff2, SourceSerif4-Regular.ttf.woff, + SourceSerif4-Bold.ttf.woff, SourceSerif4-It.ttf.woff): Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe in the United diff --git a/FiraSans-LICENSE.txt b/FiraSans-LICENSE.txt index d444ea92..ff9afab0 100644 --- a/FiraSans-LICENSE.txt +++ b/FiraSans-LICENSE.txt @@ -1,5 +1,5 @@ Digitized data copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A. -with Reserved Font Name < Fira >, +with Reserved Font Name < Fira >, This Font Software is licensed under the SIL Open Font License, Version 1.1. This license is copied below, and is also available with a FAQ at: @@ -19,7 +19,7 @@ with others. The OFL allows the licensed fonts to be used, studied, modified and redistributed freely as long as they are not sold by themselves. The -fonts, including any derivative works, can be bundled, embedded, +fonts, including any derivative works, can be bundled, embedded, redistributed and/or sold with any software provided that any reserved names are not used by derivative works. The fonts and derivatives, however, cannot be released under any other type of license. The diff --git a/SourceCodePro-It.ttf.woff2 b/SourceCodePro-It.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..462c34efcd9d6b70b42359ca1a1d9476efe43eeb GIT binary patch literal 44896 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 V7)~)yDZnpu49h_gZvJhn{{a>V-DCg& literal 0 HcmV?d00001 diff --git a/SourceCodePro-Regular.ttf.woff2 b/SourceCodePro-Regular.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..10b558e0b69a74b8329766fffbd5f64356c7230d GIT binary patch literal 52228 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 z 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 D0=ucW literal 0 HcmV?d00001 diff --git a/SourceSerif4-Bold.ttf.woff2 b/SourceSerif4-Bold.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..db57d21455c94e80aa7cca25cac803a08e1b01ec GIT binary patch literal 81320 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 N>ZPvCW|kqQ1ONsnDE9yW literal 0 HcmV?d00001 diff --git a/SourceSerif4-It.ttf.woff2 b/SourceSerif4-It.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..1cbc021a3aa22e1469542d531e9115fb78d497ec GIT binary patch literal 59860 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 literal 0 HcmV?d00001 diff --git a/SourceSerif4-Regular.ttf.woff2 b/SourceSerif4-Regular.ttf.woff2 new file mode 100644 index 0000000000000000000000000000000000000000..2db73fe2b49e8cfcaaf1d5311a610e730b8ed502 GIT binary patch literal 76180 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 literal 0 HcmV?d00001 diff --git a/ayu.css b/ayu.css index 94ffc1cb..4a52bc33 100644 --- a/ayu.css +++ b/ayu.css @@ -1 +1 @@ - body{background-color:#0f1419;color:#c5c5c5;}h1,h2,h3,h4{color:white;}h1.fqn{border-bottom-color:#5c6773;}h1.fqn a{color:#fff;}h2,h3,h4{border-bottom-color:#5c6773;}h4{border:none;}.in-band{background-color:#0f1419;}.invisible{background:rgba(0,0,0,0);}code{color:#ffb454;}h3>code,h4>code,h5>code{color:#e6e1cf;}pre>code{color:#e6e1cf;}span code{color:#e6e1cf;}.docblock a>code{color:#39AFD7 !important;}.docblock code,.docblock-short code{background-color:#191f26;}pre,.rustdoc.source .example-wrap{color:#e6e1cf;background-color:#191f26;}.sidebar{background-color:#14191f;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);}*{scrollbar-color:#5c6773 transparent;}.sidebar{scrollbar-color:#5c6773 transparent;}::-webkit-scrollbar-track{background-color:transparent;}::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar::-webkit-scrollbar-track{background-color:transparent;}.sidebar::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar .current{background-color:transparent;color:#ffb44c;}.source .sidebar{background-color:#0f1419;}.sidebar .location{border-color:#000;background-color:#0f1419;color:#fff;}.sidebar-elems .location{color:#ff7733;}.sidebar-elems .location a{color:#fff;}.sidebar .version{border-bottom-color:#424c57;}.sidebar-title{border-top-color:#5c6773;border-bottom-color:#5c6773;}.block a:hover{background:transparent;color:#ffb44c;}.line-numbers span{color:#5c6773;}.line-numbers .line-highlighted{color:#708090;background-color:rgba(255,236,164,0.06);padding-right:4px;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#5c6773;}.docblock table,.docblock table td,.docblock table th{border-color:#5c6773;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#c5c5c5;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#000 !important;background-color:#c6afb3;}.search-results a{color:#0096cf;}.search-results a span.desc{color:#c5c5c5;}.content .item-info::before{color:#ccc;}.content span.foreigntype,.content a.foreigntype{color:#ef57ff;}.content span.union,.content a.union{color:#98a01c;}.content span.constant,.content a.constant,.content span.static,.content a.static{color:#6380a0;}.content span.primitive,.content a.primitive{color:#32889b;}.content span.traitalias,.content a.traitalias{color:#57d399;}.content span.keyword,.content a.keyword{color:#de5249;}.content span.externcrate,.content span.mod,.content a.mod{color:#acccf9;}.content span.struct,.content a.struct{color:#ffa0a5;}.content span.enum,.content a.enum{color:#99e0c9;}.content span.trait,.content a.trait{color:#39AFD7;}.content span.type,.content a.type{color:#cfbcf5;}.content span.fn,.content a.fn,.content span.method,.content a.method,.content span.tymethod,.content a.tymethod,.content .fnname{color:#fdd687;}.content span.attr,.content a.attr,.content span.derive,.content a.derive,.content span.macro,.content a.macro{color:#a37acc;}pre.rust .comment{color:#788797;}pre.rust .doccomment{color:#a1ac88;}nav:not(.sidebar){border-bottom-color:#424c57;}nav.main .current{border-top-color:#5c6773;border-bottom-color:#5c6773;}nav.main .separator{border:1px solid #5c6773;}a{color:#c5c5c5;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#39AFD7;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#c5c5c5;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;border-color:#424c57;}.search-input{color:#ffffff;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;transition:box-shadow 150ms ease-in-out;}#crate-search+.search-input:focus{box-shadow:0 0 0 1px #148099,0 0 0 2px transparent;}.search-input:disabled{background-color:#3e3e3e;}.module-item .stab,.import-item .stab{color:#000;}.stab.unstable,.stab.deprecated,.stab.portability{color:#c5c5c5;background:#314559 !important;border-style:none !important;border-radius:4px;padding:3px 6px 3px 6px;}.stab.portability>code{color:#e6e1cf;background:none;}#help>div{background:#14191f;box-shadow:0px 6px 20px 0px black;border:none;border-radius:4px;}#help>div>span{border-bottom-color:#5c6773;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#788797;}.line-numbers :target{background-color:transparent;}pre.rust .number,pre.rust .string{color:#b8cc52;}pre.rust .kw,pre.rust .kw-2,pre.rust .prelude-ty,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .op,pre.rust .lifetime{color:#ff7733;}pre.rust .macro,pre.rust .macro-nonterminal{color:#a37acc;}pre.rust .question-mark{color:#ff9011;}pre.rust .self{color:#36a3d9;font-style:italic;}pre.rust .attribute{color:#e6e1cf;}pre.rust .attribute .ident,pre.rust .attribute .op{color:#e6e1cf;}.example-wrap>pre.line-number{color:#5c67736e;border:none;}a.test-arrow{font-size:100%;color:#788797;border-radius:4px;background-color:rgba(57,175,215,0.09);}a.test-arrow:hover{background-color:rgba(57,175,215,0.368);color:#c5c5c5;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background:rgba(255,236,164,0.06);border-right:3px solid rgba(255,180,76,0.85);}pre.compile_fail{border-left:2px solid rgba(255,0,0,.4);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.4);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#39AFD7;}.tooltip::after{background-color:#314559;color:#c5c5c5;border:1px solid #5c6773;}.tooltip::before{border-color:transparent #314559 transparent transparent;}.notable-traits-tooltiptext{background-color:#314559;border-color:#5c6773;}.notable-traits-tooltiptext .notable{border-bottom-color:#5c6773;}#titles>button.selected{background-color:#141920 !important;border-bottom:1px solid #ffb44c !important;border-top:none;}#titles>button:not(.selected){background-color:transparent !important;border:none;}#titles>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}#titles>button>div.count{color:#888;}.search-input:focus{}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{}.content span.struct,.content a.struct,.block a.current.struct{}#titles>button:hover,#titles>button.selected{}.content span.type,.content a.type,.block a.current.type{}.content span.union,.content a.union,.block a.current.union{}pre.rust .lifetime{}.stab.unstable{}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){}.content span.enum,.content a.enum,.block a.current.enum{}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{}.content span.keyword,.content a.keyword,.block a.current.keyword{}pre.rust .comment{}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{}pre.rust .kw{}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{}pre.rust .doccomment{}.stab.deprecated{}.content a.attr,.content a.derive,.content a.macro{}.stab.portability{}.content span.primitive,.content a.primitive,.block a.current.primitive{}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{}pre.rust .kw-2,pre.rust .prelude-ty{}.content span.trait,.content a.trait,.block a.current.trait{}.search-results a:focus span{}a.result-trait:focus{}a.result-traitalias:focus{}a.result-mod:focus,a.result-externcrate:focus{}a.result-mod:focus{}a.result-externcrate:focus{}a.result-enum:focus{}a.result-struct:focus{}a.result-union:focus{}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{}a.result-type:focus{}a.result-foreigntype:focus{}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{}a.result-constant:focus,a.result-static:focus{}a.result-primitive:focus{}a.result-keyword:focus{}@media (max-width:700px){.sidebar-menu{background-color:#14191f;border-bottom-color:#5c6773;border-right-color:#5c6773;}.sidebar-elems{background-color:#14191f;border-right-color:#5c6773;}#sidebar-filler{background-color:#14191f;border-bottom-color:#5c6773;}}kbd{color:#c5c5c5;background-color:#314559;border-color:#5c6773;border-bottom-color:#5c6773;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#5c6773;background-color:#0f1419;color:#fff;}#theme-picker>img,#settings-menu>img{filter:invert(100);}#copy-path{color:#fff;}#copy-path>img{filter:invert(70%);}#copy-path:hover>img{filter:invert(100%);}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#e0e0e0;}#theme-choices{border-color:#5c6773;background-color:#0f1419;}#theme-choices>button:not(:first-child){border-top-color:#5c6773;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:rgba(110,110,110,0.33);}@media (max-width:700px){#theme-picker{background:#0f1419;}}#all-types{background-color:#14191f;}#all-types:hover{background-color:rgba(70,70,70,0.33);}.search-results .result-name span.alias{color:#c5c5c5;}.search-results .result-name span.grey{color:#999;}#sidebar-toggle{background-color:#14191f;}#sidebar-toggle:hover{background-color:rgba(70,70,70,0.33);}#source-sidebar{background-color:#14191f;}#source-sidebar>.title{color:#fff;border-bottom-color:#5c6773;}div.files>a:hover,div.name:hover{background-color:#14191f;color:#ffb44c;}div.files>.selected{background-color:#14191f;color:#ffb44c;}.setting-line>.title{border-bottom-color:#5c6773;}input:checked+.slider{background-color:#ffb454 !important;} \ No newline at end of file + body{background-color:#0f1419;color:#c5c5c5;}h1,h2,h3,h4{color:white;}h1.fqn{border-bottom-color:#5c6773;}h1.fqn a{color:#fff;}h2,h3,h4{border-bottom-color:#5c6773;}h4{border:none;}.in-band{background-color:#0f1419;}.invisible{background:rgba(0,0,0,0);}.docblock code{color:#ffb454;}h3>code,h4>code,h5>code{color:#e6e1cf;}pre>code{color:#e6e1cf;}span code{color:#e6e1cf;}.docblock a>code{color:#39AFD7 !important;}.docblock code,.docblock-short code{background-color:#191f26;}pre,.rustdoc.source .example-wrap{color:#e6e1cf;background-color:#191f26;}.sidebar{background-color:#14191f;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff);}*{scrollbar-color:#5c6773 transparent;}.sidebar{scrollbar-color:#5c6773 transparent;}::-webkit-scrollbar-track{background-color:transparent;}::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar::-webkit-scrollbar-track{background-color:transparent;}.sidebar::-webkit-scrollbar-thumb{background-color:#5c6773;}.sidebar .current{background-color:transparent;color:#ffb44c;}.source .sidebar{background-color:#0f1419;}.sidebar .location{border-color:#000;background-color:#0f1419;color:#fff;}.sidebar-elems .location{color:#ff7733;}.sidebar-elems .location a{color:#fff;}.sidebar .version{border-bottom-color:#424c57;}.sidebar-title{border-top-color:#5c6773;border-bottom-color:#5c6773;}.block a:hover{background:transparent;color:#ffb44c;}.line-numbers span{color:#5c6773;}.line-numbers .line-highlighted{color:#708090;background-color:rgba(255,236,164,0.06);padding-right:4px;border-right:1px solid #ffb44c;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#5c6773;}.docblock table td,.docblock table th{border-color:#5c6773;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#c5c5c5;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#000 !important;background-color:#c6afb3;}.search-results a{color:#0096cf;}.search-results a div.desc{color:#c5c5c5;}.content .item-info::before{color:#ccc;}.content span.foreigntype,.content a.foreigntype{color:#ef57ff;}.content span.union,.content a.union{color:#98a01c;}.content span.constant,.content a.constant,.content span.static,.content a.static{color:#6380a0;}.content span.primitive,.content a.primitive{color:#32889b;}.content span.traitalias,.content a.traitalias{color:#57d399;}.content span.keyword,.content a.keyword{color:#de5249;}.content span.externcrate,.content span.mod,.content a.mod{color:#acccf9;}.content span.struct,.content a.struct{color:#ffa0a5;}.content span.enum,.content a.enum{color:#99e0c9;}.content span.trait,.content a.trait{color:#39AFD7;}.content span.type,.content a.type{color:#cfbcf5;}.content span.fn,.content a.fn,.content span.method,.content a.method,.content span.tymethod,.content a.tymethod,.content .fnname{color:#fdd687;}.content span.attr,.content a.attr,.content span.derive,.content a.derive,.content span.macro,.content a.macro{color:#a37acc;}pre.rust .comment{color:#788797;}pre.rust .doccomment{color:#a1ac88;}nav:not(.sidebar){border-bottom-color:#424c57;}nav.main .current{border-top-color:#5c6773;border-bottom-color:#5c6773;}nav.main .separator{border:1px solid #5c6773;}a{color:#c5c5c5;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#39AFD7;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#c5c5c5;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;border-color:#424c57;}.search-input{color:#ffffff;background-color:#141920;box-shadow:0 0 0 1px #424c57,0 0 0 2px transparent;transition:box-shadow 150ms ease-in-out;}#crate-search+.search-input:focus{box-shadow:0 0 0 1px #148099,0 0 0 2px transparent;}.search-input:disabled{background-color:#3e3e3e;}.module-item .stab,.import-item .stab{color:#000;}.stab.unstable,.stab.deprecated,.stab.portability{color:#c5c5c5;background:#314559 !important;border-style:none !important;border-radius:4px;padding:3px 6px 3px 6px;}.stab.portability>code{color:#e6e1cf;background:none;}#help>div{background:#14191f;box-shadow:0px 6px 20px 0px black;border:none;border-radius:4px;}#help>div>span{border-bottom-color:#5c6773;}.since{color:grey;}.result-name .primitive>i,.result-name .keyword>i{color:#788797;}.line-numbers :target{background-color:transparent;}pre.rust .number,pre.rust .string{color:#b8cc52;}pre.rust .kw,pre.rust .kw-2,pre.rust .prelude-ty,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .op,pre.rust .lifetime{color:#ff7733;}pre.rust .macro,pre.rust .macro-nonterminal{color:#a37acc;}pre.rust .question-mark{color:#ff9011;}pre.rust .self{color:#36a3d9;font-style:italic;}pre.rust .attribute{color:#e6e1cf;}pre.rust .attribute .ident,pre.rust .attribute .op{color:#e6e1cf;}.example-wrap>pre.line-number{color:#5c67736e;border:none;}a.test-arrow{font-size:100%;color:#788797;border-radius:4px;background-color:rgba(57,175,215,0.09);}a.test-arrow:hover{background-color:rgba(57,175,215,0.368);color:#c5c5c5;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background:rgba(255,236,164,0.06);}:target{border-right:3px solid rgba(255,180,76,0.85);}pre.compile_fail{border-left:2px solid rgba(255,0,0,.4);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.4);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#39AFD7;}.tooltip::after{background-color:#314559;color:#c5c5c5;border:1px solid #5c6773;}.tooltip::before{border-color:transparent #314559 transparent transparent;}.notable-traits-tooltiptext{background-color:#314559;border-color:#5c6773;}.notable-traits-tooltiptext .notable{border-bottom-color:#5c6773;}#titles>button.selected{background-color:#141920 !important;border-bottom:1px solid #ffb44c !important;border-top:none;}#titles>button:not(.selected){background-color:transparent !important;border:none;}#titles>button:hover{border-bottom:1px solid rgba(242,151,24,0.3);}#titles>button>div.count{color:#888;}.search-input:focus{}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{}.content span.struct,.content a.struct,.block a.current.struct{}#titles>button:hover,#titles>button.selected{}.content span.type,.content a.type,.block a.current.type{}.content span.union,.content a.union,.block a.current.union{}pre.rust .lifetime{}.stab.unstable{}h2,h3:not(.impl):not(.method):not(.type):not(.tymethod),h4:not(.method):not(.type):not(.tymethod){}.content span.enum,.content a.enum,.block a.current.enum{}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{}.content span.keyword,.content a.keyword,.block a.current.keyword{}pre.rust .comment{}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{}pre.rust .kw{}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{}pre.rust .doccomment{}.stab.deprecated{}.content a.attr,.content a.derive,.content a.macro{}.stab.portability{}.content span.primitive,.content a.primitive,.block a.current.primitive{}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{}pre.rust .kw-2,pre.rust .prelude-ty{}.content span.trait,.content a.trait,.block a.current.trait{}.search-results a:focus span{}a.result-trait:focus{}a.result-traitalias:focus{}a.result-mod:focus,a.result-externcrate:focus{}a.result-mod:focus{}a.result-externcrate:focus{}a.result-enum:focus{}a.result-struct:focus{}a.result-union:focus{}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{}a.result-type:focus{}a.result-foreigntype:focus{}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{}a.result-constant:focus,a.result-static:focus{}a.result-primitive:focus{}a.result-keyword:focus{}@media (max-width:700px){.sidebar-menu{background-color:#14191f;border-bottom-color:#5c6773;border-right-color:#5c6773;}.sidebar-elems{background-color:#14191f;border-right-color:#5c6773;}#sidebar-filler{background-color:#14191f;border-bottom-color:#5c6773;}}kbd{color:#c5c5c5;background-color:#314559;border-color:#5c6773;border-bottom-color:#5c6773;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#5c6773;background-color:#0f1419;color:#fff;}#theme-picker>img,#settings-menu>img{filter:invert(100);}#copy-path{color:#fff;}#copy-path>img{filter:invert(70%);}#copy-path:hover>img{filter:invert(100%);}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#e0e0e0;}#theme-choices{border-color:#5c6773;background-color:#0f1419;}#theme-choices>button:not(:first-child){border-top-color:#5c6773;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:rgba(110,110,110,0.33);}@media (max-width:700px){#theme-picker{background:#0f1419;}}#all-types{background-color:#14191f;}#all-types:hover{background-color:rgba(70,70,70,0.33);}.search-results .result-name span.alias{color:#c5c5c5;}.search-results .result-name span.grey{color:#999;}#sidebar-toggle{background-color:#14191f;}#sidebar-toggle:hover{background-color:rgba(70,70,70,0.33);}#source-sidebar{background-color:#14191f;}#source-sidebar>.title{color:#fff;border-bottom-color:#5c6773;}div.files>a:hover,div.name:hover{background-color:#14191f;color:#ffb44c;}div.files>.selected{background-color:#14191f;color:#ffb44c;}.setting-line>.title{border-bottom-color:#5c6773;}input:checked+.slider{background-color:#ffb454 !important;} \ No newline at end of file diff --git a/dark.css b/dark.css index 227deb91..fc1f54ff 100644 --- a/dark.css +++ b/dark.css @@ -1 +1 @@ -body{background-color:#353535;color:#ddd;}h1,h2,h3,h4{color:#ddd;}h1.fqn{border-bottom-color:#d2d2d2;}h2,h3,h4{border-bottom-color:#d2d2d2;}.in-band{background-color:#353535;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#2A2A2A;}pre,.rustdoc.source .example-wrap{background-color:#2A2A2A;}.sidebar{background-color:#505050;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff)}*{scrollbar-color:rgb(64,65,67) #717171;}.sidebar{scrollbar-color:rgba(32,34,37,.6) transparent;}::-webkit-scrollbar-track{background-color:#717171;}::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar::-webkit-scrollbar-track{background-color:#717171;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar .current{background-color:#333;}.source .sidebar{background-color:#353535;}.sidebar .location{border-color:#fff;background:#575757;color:#DDD;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#444;}.line-numbers span{color:#3B91E2;}.line-numbers .line-highlighted{background-color:#0a042f !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#DDD;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#ddd;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#eee !important;background-color:#616161;}.search-results a:focus span{color:#eee !important;}a.result-trait:focus{background-color:#013191;}a.result-traitalias:focus{background-color:#013191;}a.result-mod:focus,a.result-externcrate:focus{background-color:#afc6e4;}a.result-mod:focus{background-color:#803a1b;}a.result-externcrate:focus{background-color:#396bac;}a.result-enum:focus{background-color:#5b4e68;}a.result-struct:focus{background-color:#194e9f;}a.result-union:focus{background-color:#b7bd49;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#4950ed;}a.result-type:focus{background-color:#38902c;}a.result-foreigntype:focus{background-color:#b200d6;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#217d1c;}a.result-constant:focus,a.result-static:focus{background-color:#0063cc;}a.result-primitive:focus{background-color:#00708a;}a.result-keyword:focus{background-color:#884719;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#82b089;}.content span.struct,.content a.struct,.block a.current.struct{color:#2dbfb8;}.content span.type,.content a.type,.block a.current.type{color:#ff7f00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#dd7de8;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#09bd00;}.content span.union,.content a.union,.block a.current.union{color:#a6ae37;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#82a5c9;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#43aec7;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#bda000;}.content span.trait,.content a.trait,.block a.current.trait{color:#b78cf2;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#b397da;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#2BAB63;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8d8d8b;}pre.rust .doccomment{color:#8ca375;}nav:not(.sidebar){border-bottom-color:#4e4e4e;}nav.main .current{border-top-color:#eee;border-bottom-color:#eee;}nav.main .separator{border-color:#eee;}a{color:#ddd;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#D2991D;}a.test-arrow{color:#dedede;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#111;background-color:#f0f0f0;border-color:#000;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input{color:#111;background-color:#f0f0f0;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input:focus{border-color:#008dfd;}.search-input:disabled{background-color:#c5c4c4;}#crate-search+.search-input:focus{box-shadow:0 0 8px 4px #078dd8;}.module-item .stab,.import-item .stab{color:#ddd;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;color:#2f2f2f;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;color:#2f2f2f;}.stab.portability>code{background:none;}#help>div{background:#4d4d4d;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}#help dt{border-color:#bfbfbf;background:rgba(0,0,0,0);}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:#ddd;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#ab8ac1;}pre.rust .kw-2,pre.rust .prelude-ty{color:#769acb;}pre.rust .number,pre.rust .string{color:#83a300;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#ee6868;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#d97f26;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#4a4949;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background-color:#494a3d;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.8);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.8);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.8);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.8);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;border-color:#000;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#111;border-color:#777;}.notable-traits-tooltiptext .notable{border-bottom-color:#d2d2d2;}#titles>button:not(.selected){background-color:#252525;border-top-color:#252525;}#titles>button:hover,#titles>button.selected{border-top-color:#0089ff;background-color:#353535;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#505050;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#505050;border-right-color:#000;}#sidebar-filler{background-color:#505050;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#e0e0e0;background:#f0f0f0;color:#000;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#ffb900;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(65%);}#theme-choices{border-color:#e0e0e0;background-color:#353535;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#4e4e4e;}@media (max-width:700px){#theme-picker{background:#f0f0f0;}}#all-types{background-color:#505050;}#all-types:hover{background-color:#606060;}.search-results .result-name span.alias{color:#fff;}.search-results .result-name span.grey{color:#ccc;}#sidebar-toggle{background-color:#565656;}#sidebar-toggle:hover{background-color:#676767;}#source-sidebar{background-color:#565656;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#444;}div.files>.selected{background-color:#333;}.setting-line>.title{border-bottom-color:#ddd;} \ No newline at end of file +body{background-color:#353535;color:#ddd;}h1,h2,h3,h4{color:#ddd;}h1.fqn{border-bottom-color:#d2d2d2;}h2,h3,h4{border-bottom-color:#d2d2d2;}.in-band{background-color:#353535;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#2A2A2A;}pre,.rustdoc.source .example-wrap{background-color:#2A2A2A;}.sidebar{background-color:#505050;}.logo-container.rust-logo>img{filter:drop-shadow(1px 0 0px #fff) drop-shadow(0 1px 0 #fff) drop-shadow(-1px 0 0 #fff) drop-shadow(0 -1px 0 #fff)}*{scrollbar-color:rgb(64,65,67) #717171;}.sidebar{scrollbar-color:rgba(32,34,37,.6) transparent;}::-webkit-scrollbar-track{background-color:#717171;}::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar::-webkit-scrollbar-track{background-color:#717171;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(32,34,37,.6);}.sidebar .current{background-color:#333;}.source .sidebar{background-color:#353535;}.sidebar .location{border-color:#fff;background:#575757;color:#DDD;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#444;}.line-numbers span{color:#3B91E2;}.line-numbers .line-highlighted{background-color:#0a042f !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#DDD;}.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#ddd;}.search-results a:hover{background-color:#777;}.search-results a:focus{color:#eee !important;background-color:#616161;}.search-results a:focus span{color:#eee !important;}a.result-trait:focus{background-color:#013191;}a.result-traitalias:focus{background-color:#013191;}a.result-mod:focus,a.result-externcrate:focus{background-color:#afc6e4;}a.result-mod:focus{background-color:#803a1b;}a.result-externcrate:focus{background-color:#396bac;}a.result-enum:focus{background-color:#5b4e68;}a.result-struct:focus{background-color:#194e9f;}a.result-union:focus{background-color:#b7bd49;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#4950ed;}a.result-type:focus{background-color:#38902c;}a.result-foreigntype:focus{background-color:#b200d6;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#217d1c;}a.result-constant:focus,a.result-static:focus{background-color:#0063cc;}a.result-primitive:focus{background-color:#00708a;}a.result-keyword:focus{background-color:#884719;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#82b089;}.content span.struct,.content a.struct,.block a.current.struct{color:#2dbfb8;}.content span.type,.content a.type,.block a.current.type{color:#ff7f00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#dd7de8;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#09bd00;}.content span.union,.content a.union,.block a.current.union{color:#a6ae37;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#82a5c9;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#43aec7;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#bda000;}.content span.trait,.content a.trait,.block a.current.trait{color:#b78cf2;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#b397da;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#2BAB63;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8d8d8b;}pre.rust .doccomment{color:#8ca375;}nav:not(.sidebar){border-bottom-color:#4e4e4e;}nav.main .current{border-top-color:#eee;border-bottom-color:#eee;}nav.main .separator{border-color:#eee;}a{color:#ddd;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#D2991D;}a.test-arrow{color:#dedede;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#111;background-color:#f0f0f0;border-color:#000;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input{color:#111;background-color:#f0f0f0;box-shadow:0 0 0 1px #000,0 0 0 2px transparent;}.search-input:focus{border-color:#008dfd;}.search-input:disabled{background-color:#c5c4c4;}#crate-search+.search-input:focus{box-shadow:0 0 8px 4px #078dd8;}.module-item .stab,.import-item .stab{color:#ddd;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;color:#2f2f2f;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;color:#2f2f2f;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;color:#2f2f2f;}.stab.portability>code{background:none;}#help>div{background:#4d4d4d;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}#help dt{border-color:#bfbfbf;background:rgba(0,0,0,0);}.since{color:grey;}.result-name .primitive>i,.result-name .keyword>i{color:#ddd;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#ab8ac1;}pre.rust .kw-2,pre.rust .prelude-ty{color:#769acb;}pre.rust .number,pre.rust .string{color:#83a300;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#ee6868;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#d97f26;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#4a4949;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background-color:#494a3d;}:target{border-right:3px solid #bb7410;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.8);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.8);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.8);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.8);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;border-color:#000;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#111;border-color:#777;}.notable-traits-tooltiptext .notable{border-bottom-color:#d2d2d2;}#titles>button:not(.selected){background-color:#252525;border-top-color:#252525;}#titles>button:hover,#titles>button.selected{border-top-color:#0089ff;background-color:#353535;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#505050;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#505050;border-right-color:#000;}#sidebar-filler{background-color:#505050;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#e0e0e0;background:#f0f0f0;color:#000;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#ffb900;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(65%);}#theme-choices{border-color:#e0e0e0;background-color:#353535;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#4e4e4e;}@media (max-width:700px){#theme-picker{background:#f0f0f0;}}#all-types{background-color:#505050;}#all-types:hover{background-color:#606060;}.search-results .result-name span.alias{color:#fff;}.search-results .result-name span.grey{color:#ccc;}#sidebar-toggle{background-color:#565656;}#sidebar-toggle:hover{background-color:#676767;}#source-sidebar{background-color:#565656;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#444;}div.files>.selected{background-color:#333;}.setting-line>.title{border-bottom-color:#ddd;} \ No newline at end of file diff --git a/implementors/core/clone/trait.Clone.js b/implementors/core/clone/trait.Clone.js index dd76721e..6323c363 100644 --- a/implementors/core/clone/trait.Clone.js +++ b/implementors/core/clone/trait.Clone.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Clone for Email","synthetic":false,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Clone for ChangePasswordReqest","synthetic":false,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Clone for Secret","synthetic":false,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Clone for Username","synthetic":false,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Clone for AccountCheckPayload","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Clone for AccountCheckResp","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Clone for Register","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Clone for Login","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Clone for Password","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Clone for MCaptchaID","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Clone for MCaptchaDetails","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Clone for DeleteCaptcha","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Clone for StatsPayload","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Clone for Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Clone for I32Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Clone for BuildDetails","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Clone for BuildDetailsBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Clone for Health","synthetic":false,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Clone for HealthBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Clone for GetConfigPayload","synthetic":false,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Clone for ValidationToken","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Clone for CaptchaValidateResp","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Clone for Date","synthetic":false,"types":["mcaptcha::date::Date"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K: Clone, V: Clone> Clone for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> Clone for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Clone for McaptchaConfig","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Clone for Level","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Clone for McaptchaConfig","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Clone for Level","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Clone for Server","synthetic":false,"types":["mcaptcha::settings::Server"]},{"text":"impl Clone for Captcha","synthetic":false,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Clone for Smtp","synthetic":false,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Clone for DatabaseBuilder","synthetic":false,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Clone for Database","synthetic":false,"types":["mcaptcha::settings::Database"]},{"text":"impl Clone for Redis","synthetic":false,"types":["mcaptcha::settings::Redis"]},{"text":"impl Clone for Settings","synthetic":false,"types":["mcaptcha::settings::Settings"]},{"text":"impl Clone for StatsUnixTimestamp","synthetic":false,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Clone for Stats","synthetic":false,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Clone for StatsPayload","synthetic":false,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; -implementors["tests_migrate"] = [{"text":"impl Clone for Server","synthetic":false,"types":["tests_migrate::settings::Server"]},{"text":"impl Clone for Captcha","synthetic":false,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Clone for Smtp","synthetic":false,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Clone for DatabaseBuilder","synthetic":false,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Clone for Database","synthetic":false,"types":["tests_migrate::settings::Database"]},{"text":"impl Clone for Redis","synthetic":false,"types":["tests_migrate::settings::Redis"]},{"text":"impl Clone for Settings","synthetic":false,"types":["tests_migrate::settings::Settings"]}]; +implementors["mcaptcha"] = [{"text":"impl Clone for Email","synthetic":false,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Clone for ChangePasswordReqest","synthetic":false,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Clone for Secret","synthetic":false,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Clone for Username","synthetic":false,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Clone for AccountCheckPayload","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Clone for AccountCheckResp","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Clone for Register","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Clone for Login","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Clone for Password","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Clone for MCaptchaID","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Clone for MCaptchaDetails","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Clone for DeleteCaptcha","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Clone for StatsPayload","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Clone for Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Clone for I32Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Clone for BuildDetails","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Clone for BuildDetailsBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Clone for Health","synthetic":false,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Clone for HealthBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Clone for GetConfigPayload","synthetic":false,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Clone for ValidationToken","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Clone for CaptchaValidateResp","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Clone for Date","synthetic":false,"types":["mcaptcha::date::Date"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K: Clone, V: Clone> Clone for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> Clone for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> Clone for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Clone for McaptchaConfig","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Clone for Level","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Clone for McaptchaConfig","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Clone for Level","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Clone for Server","synthetic":false,"types":["mcaptcha::settings::Server"]},{"text":"impl Clone for Captcha","synthetic":false,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Clone for Smtp","synthetic":false,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Clone for DatabaseBuilder","synthetic":false,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Clone for Database","synthetic":false,"types":["mcaptcha::settings::Database"]},{"text":"impl Clone for Redis","synthetic":false,"types":["mcaptcha::settings::Redis"]},{"text":"impl Clone for Settings","synthetic":false,"types":["mcaptcha::settings::Settings"]},{"text":"impl Clone for StatsUnixTimestamp","synthetic":false,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Clone for Stats","synthetic":false,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Clone for StatsPayload","synthetic":false,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Clone for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; +implementors["tests_migrate"] = [{"text":"impl Clone for Server","synthetic":false,"types":["tests_migrate::settings::Server"]},{"text":"impl Clone for Captcha","synthetic":false,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Clone for Smtp","synthetic":false,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Clone for DatabaseBuilder","synthetic":false,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Clone for Database","synthetic":false,"types":["tests_migrate::settings::Database"]},{"text":"impl Clone for Redis","synthetic":false,"types":["tests_migrate::settings::Redis"]},{"text":"impl Clone for Settings","synthetic":false,"types":["tests_migrate::settings::Settings"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/cmp/trait.PartialEq.js b/implementors/core/cmp/trait.PartialEq.js index 09b567cb..6c1c55b6 100644 --- a/implementors/core/cmp/trait.PartialEq.js +++ b/implementors/core/cmp/trait.PartialEq.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl PartialEq<SmtpErrorWrapper> for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl PartialEq<ServiceError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl PartialEq<PageError> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; +implementors["mcaptcha"] = [{"text":"impl PartialEq<SmtpErrorWrapper> for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl PartialEq<ServiceError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl PartialEq<PageError> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/convert/trait.From.js b/implementors/core/convert/trait.From.js index 940e2e99..f22b98ef 100644 --- a/implementors/core/convert/trait.From.js +++ b/implementors/core/convert/trait.From.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl From<ChangePasswordReqest> for UpdatePassword","synthetic":false,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl From<UninitializedFieldError> for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl From<String> for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl From<UninitializedFieldError> for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl From<String> for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl From<Notification> for NotificationResp","synthetic":false,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl From<CredsError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<ValidationErrors> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<ParseError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<CaptchaError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<RecvError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<MailboxError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl From<ServiceError> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl From<Notification> for Notification","synthetic":false,"types":["mcaptcha::pages::panel::notifications::Notification"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl From<PoW<String>> for Work","synthetic":false,"types":["mcaptcha_browser::Work"]}]; +implementors["mcaptcha"] = [{"text":"impl From<ChangePasswordReqest> for UpdatePassword","synthetic":false,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl From<UninitializedFieldError> for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl From<String> for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl From<UninitializedFieldError> for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl From<String> for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl From<Notification> for NotificationResp","synthetic":false,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl From<CredsError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<ValidationErrors> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<ParseError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<CaptchaError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<RecvError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<MailboxError> for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl From<Error> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl From<ServiceError> for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl From<Notification> for Notification","synthetic":false,"types":["mcaptcha::pages::panel::notifications::Notification"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl From<PoW<String>> for Work","synthetic":false,"types":["mcaptcha_browser::Work"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/default/trait.Default.js b/implementors/core/default/trait.Default.js index 9a5bfbe6..693d6ae4 100644 --- a/implementors/core/default/trait.Default.js +++ b/implementors/core/default/trait.Default.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Default for BuildDetailsBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Default for HealthBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a> Default for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]}]; +implementors["mcaptcha"] = [{"text":"impl Default for BuildDetailsBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Default for HealthBuilder","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a> Default for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Default for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.Debug.js b/implementors/core/fmt/trait.Debug.js index ce99423c..784105a7 100644 --- a/implementors/core/fmt/trait.Debug.js +++ b/implementors/core/fmt/trait.Debug.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Debug for Email","synthetic":false,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Debug for ChangePasswordReqest","synthetic":false,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Debug for Secret","synthetic":false,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Debug for Username","synthetic":false,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Debug for AccountCheckPayload","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Debug for AccountCheckResp","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Debug for Register","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Debug for Login","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Debug for Password","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Debug for MCaptchaID","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Debug for MCaptchaDetails","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Debug for DeleteCaptcha","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Debug for StatsPayload","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Debug for Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Debug for I32Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Debug for BuildDetails","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Debug for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Debug for Health","synthetic":false,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Debug for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Debug for GetConfigPayload","synthetic":false,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Debug for ValidationToken","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Debug for CaptchaValidateResp","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Debug for Date","synthetic":false,"types":["mcaptcha::date::Date"]},{"text":"impl Debug for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Debug for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Debug for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl Debug for Server","synthetic":false,"types":["mcaptcha::settings::Server"]},{"text":"impl Debug for Captcha","synthetic":false,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Debug for Smtp","synthetic":false,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Debug for DatabaseBuilder","synthetic":false,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Debug for Database","synthetic":false,"types":["mcaptcha::settings::Database"]},{"text":"impl Debug for Redis","synthetic":false,"types":["mcaptcha::settings::Redis"]},{"text":"impl Debug for Settings","synthetic":false,"types":["mcaptcha::settings::Settings"]},{"text":"impl Debug for StatsUnixTimestamp","synthetic":false,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Debug for Stats","synthetic":false,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Debug for StatsPayload","synthetic":false,"types":["mcaptcha::stats::fetch::StatsPayload"]}]; -implementors["tests_migrate"] = [{"text":"impl Debug for Server","synthetic":false,"types":["tests_migrate::settings::Server"]},{"text":"impl Debug for Captcha","synthetic":false,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Debug for Smtp","synthetic":false,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Debug for DatabaseBuilder","synthetic":false,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Debug for Database","synthetic":false,"types":["tests_migrate::settings::Database"]},{"text":"impl Debug for Redis","synthetic":false,"types":["tests_migrate::settings::Redis"]},{"text":"impl Debug for Settings","synthetic":false,"types":["tests_migrate::settings::Settings"]}]; +implementors["mcaptcha"] = [{"text":"impl Debug for Email","synthetic":false,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Debug for ChangePasswordReqest","synthetic":false,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Debug for Secret","synthetic":false,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Debug for Username","synthetic":false,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Debug for AccountCheckPayload","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Debug for AccountCheckResp","synthetic":false,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Debug for Register","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Debug for Login","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Debug for Password","synthetic":false,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Debug for MCaptchaID","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Debug for MCaptchaDetails","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Debug for DeleteCaptcha","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Debug for StatsPayload","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Debug for Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Debug for I32Levels","synthetic":false,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Debug for BuildDetails","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Debug for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Debug for Health","synthetic":false,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Debug for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Debug for GetConfigPayload","synthetic":false,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Debug for ValidationToken","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Debug for CaptchaValidateResp","synthetic":false,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Debug for Date","synthetic":false,"types":["mcaptcha::date::Date"]},{"text":"impl Debug for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Debug for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Debug for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]},{"text":"impl Debug for Server","synthetic":false,"types":["mcaptcha::settings::Server"]},{"text":"impl Debug for Captcha","synthetic":false,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Debug for Smtp","synthetic":false,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Debug for DatabaseBuilder","synthetic":false,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Debug for Database","synthetic":false,"types":["mcaptcha::settings::Database"]},{"text":"impl Debug for Redis","synthetic":false,"types":["mcaptcha::settings::Redis"]},{"text":"impl Debug for Settings","synthetic":false,"types":["mcaptcha::settings::Settings"]},{"text":"impl Debug for StatsUnixTimestamp","synthetic":false,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Debug for Stats","synthetic":false,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Debug for StatsPayload","synthetic":false,"types":["mcaptcha::stats::fetch::StatsPayload"]}]; +implementors["tests_migrate"] = [{"text":"impl Debug for Server","synthetic":false,"types":["tests_migrate::settings::Server"]},{"text":"impl Debug for Captcha","synthetic":false,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Debug for Smtp","synthetic":false,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Debug for DatabaseBuilder","synthetic":false,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Debug for Database","synthetic":false,"types":["tests_migrate::settings::Database"]},{"text":"impl Debug for Redis","synthetic":false,"types":["tests_migrate::settings::Redis"]},{"text":"impl Debug for Settings","synthetic":false,"types":["tests_migrate::settings::Settings"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/fmt/trait.Display.js b/implementors/core/fmt/trait.Display.js index b32cb055..80886d7f 100644 --- a/implementors/core/fmt/trait.Display.js +++ b/implementors/core/fmt/trait.Display.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Display for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Display for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Display for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Display for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Display for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; +implementors["mcaptcha"] = [{"text":"impl Display for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Display for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Display for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Display for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Display for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Freeze.js b/implementors/core/marker/trait.Freeze.js index 427f3871..563ed3a7 100644 --- a/implementors/core/marker/trait.Freeze.js +++ b/implementors/core/marker/trait.Freeze.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Freeze for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Freeze for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Freeze for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Freeze for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Freeze for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Freeze for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Freeze for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Freeze for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Freeze for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Freeze for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Freeze for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Freeze for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Freeze for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Freeze for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Freeze for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Freeze for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Freeze for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Freeze for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Freeze for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Freeze for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Freeze for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Freeze for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Freeze for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Freeze for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Freeze for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Freeze for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Freeze for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Freeze for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Freeze for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Freeze for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Freeze for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Freeze for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Freeze for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Freeze for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Freeze for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Freeze for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Freeze for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Freeze for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Freeze for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Freeze for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Freeze for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Freeze for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Freeze for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Freeze for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Freeze for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Freeze for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Freeze for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Freeze for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Freeze for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Freeze for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Freeze for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Freeze for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Freeze for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Freeze for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Freeze for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Freeze for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Freeze for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Freeze for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Freeze for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Freeze for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Freeze for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Freeze for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Freeze for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Freeze for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Freeze for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Freeze for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Freeze for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Freeze for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Freeze for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Freeze for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Freeze for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Freeze for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Freeze for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Freeze for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Freeze for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Freeze for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Freeze for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Freeze for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Freeze for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Freeze for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Freeze for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Freeze for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Freeze for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Freeze for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Freeze for CheckLoginMiddleware<S> where
    S: Freeze, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Freeze for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Freeze for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Freeze for SudoPage<'a, K, V>","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Freeze for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Freeze for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Freeze for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Freeze for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Freeze for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Freeze for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Freeze for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Freeze for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Freeze for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Freeze for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Freeze for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Freeze for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Freeze for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Freeze for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Freeze for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Freeze for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Freeze for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Freeze for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Freeze for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Freeze for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Freeze for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Freeze for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Freeze for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Freeze for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Freeze for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Freeze for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Freeze for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Freeze for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Freeze for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Freeze for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Freeze for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Freeze for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Freeze for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Freeze for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Freeze for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Freeze for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Freeze for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Freeze for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Freeze for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Freeze for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Freeze for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Freeze for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Freeze for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Freeze for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Freeze for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Freeze for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Freeze for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Freeze for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Freeze for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Freeze for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Freeze for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Freeze for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Freeze for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Freeze for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Freeze for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Freeze for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Freeze for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Freeze for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Freeze for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Freeze for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Freeze for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha"] = [{"text":"impl Freeze for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Freeze for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Freeze for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Freeze for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Freeze for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Freeze for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Freeze for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Freeze for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Freeze for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Freeze for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Freeze for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Freeze for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Freeze for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Freeze for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Freeze for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Freeze for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Freeze for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Freeze for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Freeze for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Freeze for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Freeze for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Freeze for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Freeze for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Freeze for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Freeze for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Freeze for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Freeze for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Freeze for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Freeze for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Freeze for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Freeze for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Freeze for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Freeze for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Freeze for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Freeze for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Freeze for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Freeze for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Freeze for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Freeze for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Freeze for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Freeze for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Freeze for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Freeze for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Freeze for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Freeze for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Freeze for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Freeze for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Freeze for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Freeze for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Freeze for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Freeze for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Freeze for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Freeze for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Freeze for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Freeze for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Freeze for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Freeze for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Freeze for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Freeze for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Freeze for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Freeze for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Freeze for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Freeze for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Freeze for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Freeze for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Freeze for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Freeze for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Freeze for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Freeze for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Freeze for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Freeze for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Freeze for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Freeze for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Freeze for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Freeze for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Freeze for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Freeze for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Freeze for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Freeze for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Freeze for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Freeze for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Freeze for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Freeze for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Freeze for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Freeze for CheckLoginMiddleware<S> where
    S: Freeze, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Freeze for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Freeze for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Freeze for SudoPage<'a, K, V>","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Freeze for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Freeze for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Freeze for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Freeze for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Freeze for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Freeze for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Freeze for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Freeze for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Freeze for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Freeze for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Freeze for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Freeze for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Freeze for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Freeze for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Freeze for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Freeze for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Freeze for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Freeze for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Freeze for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Freeze for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Freeze for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Freeze for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Freeze for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Freeze for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Freeze for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Freeze for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Freeze for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Freeze for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Freeze for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Freeze for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Freeze for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Freeze for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Freeze for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Freeze for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Freeze for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Freeze for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Freeze for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Freeze for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Freeze for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Freeze for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Freeze for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Freeze for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Freeze for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Freeze for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Freeze for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Freeze for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Freeze for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Freeze for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Freeze for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Freeze for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Freeze for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Freeze for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Freeze for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Freeze for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Freeze for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Freeze for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Freeze for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Freeze for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Freeze for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Freeze for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Freeze for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Freeze for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Freeze for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Freeze for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; implementors["mcaptcha_browser"] = [{"text":"impl Freeze for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl Freeze for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Freeze for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Freeze for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Freeze for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Freeze for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Freeze for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Freeze for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["tests_migrate"] = [{"text":"impl Freeze for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Freeze for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Freeze for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Freeze for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Freeze for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Freeze for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Freeze for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Freeze for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Send.js b/implementors/core/marker/trait.Send.js index 7e5de501..34d2bd38 100644 --- a/implementors/core/marker/trait.Send.js +++ b/implementors/core/marker/trait.Send.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Send for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Send for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Send for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Send for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Send for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Send for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Send for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Send for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Send for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Send for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Send for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Send for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Send for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Send for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Send for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Send for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Send for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Send for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Send for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Send for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Send for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Send for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Send for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Send for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Send for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Send for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Send for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Send for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Send for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Send for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Send for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Send for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Send for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Send for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Send for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Send for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Send for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Send for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Send for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Send for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Send for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Send for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Send for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Send for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Send for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Send for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Send for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Send for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Send for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Send for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Send for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Send for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Send for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Send for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Send for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Send for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Send for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Send for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Send for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Send for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Send for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Send for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Send for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Send for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Send for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Send for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Send for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Send for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Send for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Send for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Send for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Send for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Send for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Send for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Send for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Send for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Send for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Send for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Send for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Send for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Send for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Send for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Send for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Send for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Send for CheckLoginMiddleware<S> where
    S: Send, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Send for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Send for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Send for SudoPage<'a, K, V> where
    K: Send,
    V: Send, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Send for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Send for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Send for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Send for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Send for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Send for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Send for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Send for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Send for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Send for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Send for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Send for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Send for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Send for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Send for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Send for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Send for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Send for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Send for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Send for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Send for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Send for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Send for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Send for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Send for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Send for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Send for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Send for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Send for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Send for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Send for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Send for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Send for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Send for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Send for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Send for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Send for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Send for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Send for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Send for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Send for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Send for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Send for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Send for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Send for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Send for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Send for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Send for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Send for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Send for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Send for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Send for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Send for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Send for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Send for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Send for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Send for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Send for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Send for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Send for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Send for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Send for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Send for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl Send for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl Send for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Send for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Send for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Send for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Send for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Send for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Send for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Send for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl Send for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Send for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Send for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Send for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Send for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Send for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Send for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Send for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Send for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Send for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Send for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Send for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Send for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Send for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Send for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Send for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Send for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Send for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Send for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Send for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Send for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Send for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Send for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Send for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Send for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Send for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Send for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Send for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Send for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Send for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Send for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Send for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Send for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Send for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Send for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Send for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Send for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Send for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Send for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Send for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Send for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Send for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Send for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Send for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Send for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Send for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Send for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Send for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Send for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Send for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Send for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Send for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Send for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Send for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Send for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Send for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Send for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Send for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Send for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Send for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Send for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Send for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Send for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Send for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Send for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Send for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Send for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Send for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Send for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Send for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Send for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Send for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Send for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Send for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Send for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Send for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Send for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Send for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Send for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Send for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Send for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Send for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Send for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Send for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Send for CheckLoginMiddleware<S> where
    S: Send, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Send for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Send for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Send for SudoPage<'a, K, V> where
    K: Send,
    V: Send, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Send for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Send for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Send for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Send for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Send for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Send for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Send for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Send for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Send for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Send for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Send for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Send for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Send for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Send for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Send for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Send for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Send for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Send for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Send for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Send for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Send for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Send for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Send for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Send for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Send for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Send for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Send for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Send for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Send for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Send for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Send for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Send for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Send for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Send for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Send for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Send for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Send for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Send for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Send for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Send for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Send for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Send for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Send for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Send for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Send for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Send for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Send for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Send for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Send for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Send for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Send for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Send for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Send for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Send for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Send for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Send for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Send for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Send for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Send for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Send for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Send for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Send for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Send for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Send for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Send for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Send for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl Send for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; +implementors["tests_migrate"] = [{"text":"impl Send for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Send for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Send for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Send for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Send for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Send for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Send for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Send for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.StructuralPartialEq.js b/implementors/core/marker/trait.StructuralPartialEq.js index e17f0b9b..587de9a6 100644 --- a/implementors/core/marker/trait.StructuralPartialEq.js +++ b/implementors/core/marker/trait.StructuralPartialEq.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl StructuralPartialEq for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl StructuralPartialEq for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; +implementors["mcaptcha"] = [{"text":"impl StructuralPartialEq for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl StructuralPartialEq for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Sync.js b/implementors/core/marker/trait.Sync.js index 645f6c23..bde23107 100644 --- a/implementors/core/marker/trait.Sync.js +++ b/implementors/core/marker/trait.Sync.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Sync for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Sync for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Sync for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Sync for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Sync for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Sync for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Sync for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Sync for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Sync for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Sync for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Sync for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Sync for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Sync for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Sync for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Sync for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Sync for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Sync for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Sync for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Sync for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Sync for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Sync for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Sync for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Sync for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Sync for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Sync for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Sync for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Sync for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Sync for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Sync for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Sync for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Sync for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Sync for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Sync for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Sync for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Sync for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Sync for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Sync for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Sync for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Sync for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Sync for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Sync for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Sync for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Sync for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Sync for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Sync for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Sync for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Sync for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Sync for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Sync for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Sync for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Sync for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Sync for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Sync for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Sync for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Sync for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Sync for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Sync for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Sync for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Sync for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Sync for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Sync for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Sync for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Sync for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Sync for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Sync for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Sync for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Sync for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Sync for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Sync for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Sync for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Sync for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Sync for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Sync for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Sync for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Sync for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Sync for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Sync for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Sync for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Sync for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Sync for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Sync for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Sync for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Sync for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Sync for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Sync for CheckLoginMiddleware<S> where
    S: Sync, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Sync for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Sync for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Sync for SudoPage<'a, K, V> where
    K: Sync,
    V: Sync, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Sync for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Sync for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Sync for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Sync for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Sync for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Sync for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Sync for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Sync for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Sync for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Sync for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Sync for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Sync for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Sync for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Sync for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Sync for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Sync for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Sync for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Sync for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Sync for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Sync for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Sync for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Sync for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Sync for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Sync for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Sync for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Sync for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Sync for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Sync for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Sync for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Sync for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Sync for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Sync for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Sync for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Sync for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Sync for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Sync for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Sync for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Sync for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Sync for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Sync for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Sync for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Sync for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Sync for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Sync for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Sync for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Sync for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Sync for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Sync for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Sync for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Sync for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Sync for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Sync for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Sync for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Sync for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Sync for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Sync for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Sync for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Sync for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Sync for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Sync for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Sync for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Sync for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Sync for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl Sync for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl Sync for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Sync for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Sync for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Sync for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Sync for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Sync for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Sync for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Sync for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl Sync for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Sync for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Sync for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Sync for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Sync for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Sync for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Sync for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Sync for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Sync for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Sync for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Sync for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Sync for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Sync for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Sync for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Sync for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Sync for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Sync for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Sync for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Sync for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Sync for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Sync for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Sync for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Sync for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Sync for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Sync for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Sync for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Sync for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Sync for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Sync for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Sync for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Sync for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Sync for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Sync for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Sync for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Sync for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Sync for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Sync for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Sync for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Sync for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Sync for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Sync for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Sync for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Sync for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Sync for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Sync for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Sync for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Sync for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Sync for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Sync for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Sync for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Sync for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Sync for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Sync for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Sync for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Sync for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Sync for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Sync for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Sync for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Sync for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Sync for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Sync for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Sync for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Sync for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Sync for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Sync for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Sync for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Sync for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Sync for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Sync for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Sync for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Sync for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Sync for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Sync for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Sync for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Sync for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Sync for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Sync for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Sync for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Sync for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Sync for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Sync for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Sync for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Sync for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Sync for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Sync for CheckLoginMiddleware<S> where
    S: Sync, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Sync for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Sync for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Sync for SudoPage<'a, K, V> where
    K: Sync,
    V: Sync, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Sync for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Sync for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Sync for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Sync for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Sync for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Sync for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Sync for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Sync for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Sync for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Sync for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Sync for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Sync for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Sync for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Sync for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Sync for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Sync for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Sync for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Sync for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Sync for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Sync for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Sync for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Sync for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Sync for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Sync for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Sync for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Sync for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Sync for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Sync for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Sync for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Sync for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Sync for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Sync for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Sync for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Sync for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Sync for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Sync for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Sync for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Sync for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Sync for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Sync for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Sync for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Sync for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Sync for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Sync for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Sync for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Sync for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Sync for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Sync for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Sync for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Sync for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Sync for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Sync for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Sync for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Sync for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Sync for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Sync for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Sync for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Sync for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Sync for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Sync for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Sync for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Sync for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Sync for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Sync for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Sync for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Sync for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl Sync for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; +implementors["tests_migrate"] = [{"text":"impl Sync for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Sync for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Sync for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Sync for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Sync for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Sync for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Sync for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Sync for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/marker/trait.Unpin.js b/implementors/core/marker/trait.Unpin.js index b51cc40e..92c7afa5 100644 --- a/implementors/core/marker/trait.Unpin.js +++ b/implementors/core/marker/trait.Unpin.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Unpin for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Unpin for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Unpin for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Unpin for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Unpin for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Unpin for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Unpin for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Unpin for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Unpin for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Unpin for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Unpin for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Unpin for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Unpin for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Unpin for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Unpin for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Unpin for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Unpin for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Unpin for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Unpin for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Unpin for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Unpin for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Unpin for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Unpin for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Unpin for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Unpin for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Unpin for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Unpin for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Unpin for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Unpin for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Unpin for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Unpin for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Unpin for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Unpin for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Unpin for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Unpin for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Unpin for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Unpin for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Unpin for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Unpin for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Unpin for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Unpin for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Unpin for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Unpin for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Unpin for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Unpin for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Unpin for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Unpin for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Unpin for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Unpin for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Unpin for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Unpin for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Unpin for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Unpin for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Unpin for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Unpin for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Unpin for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Unpin for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Unpin for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Unpin for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Unpin for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Unpin for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Unpin for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Unpin for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Unpin for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Unpin for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Unpin for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Unpin for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Unpin for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Unpin for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Unpin for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Unpin for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Unpin for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Unpin for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Unpin for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Unpin for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Unpin for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Unpin for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Unpin for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Unpin for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Unpin for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Unpin for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Unpin for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Unpin for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Unpin for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Unpin for CheckLoginMiddleware<S> where
    S: Unpin, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Unpin for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Unpin for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Unpin for SudoPage<'a, K, V> where
    K: Unpin,
    V: Unpin, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Unpin for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Unpin for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Unpin for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Unpin for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Unpin for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Unpin for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Unpin for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Unpin for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Unpin for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Unpin for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Unpin for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Unpin for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Unpin for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Unpin for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Unpin for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Unpin for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Unpin for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Unpin for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Unpin for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Unpin for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Unpin for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Unpin for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Unpin for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Unpin for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Unpin for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Unpin for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Unpin for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Unpin for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Unpin for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Unpin for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Unpin for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Unpin for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Unpin for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Unpin for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Unpin for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Unpin for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Unpin for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Unpin for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Unpin for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Unpin for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Unpin for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Unpin for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Unpin for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Unpin for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Unpin for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Unpin for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Unpin for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Unpin for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Unpin for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Unpin for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Unpin for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Unpin for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Unpin for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Unpin for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Unpin for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Unpin for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Unpin for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Unpin for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Unpin for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Unpin for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Unpin for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl Unpin for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl Unpin for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Unpin for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Unpin for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Unpin for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Unpin for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Unpin for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Unpin for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl Unpin for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl Unpin for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl Unpin for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl Unpin for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl Unpin for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl Unpin for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl Unpin for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl Unpin for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl Unpin for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl Unpin for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl Unpin for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl Unpin for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl Unpin for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl Unpin for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl Unpin for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl Unpin for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl Unpin for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl Unpin for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl Unpin for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl Unpin for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl Unpin for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl Unpin for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl Unpin for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl Unpin for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl Unpin for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl Unpin for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl Unpin for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl Unpin for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl Unpin for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl Unpin for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl Unpin for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl Unpin for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl Unpin for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl Unpin for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl Unpin for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl Unpin for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl Unpin for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl Unpin for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl Unpin for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl Unpin for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl Unpin for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl Unpin for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl Unpin for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl Unpin for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl Unpin for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl Unpin for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl Unpin for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl Unpin for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl Unpin for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Unpin for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl Unpin for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl Unpin for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl Unpin for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Unpin for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl Unpin for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl Unpin for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl Unpin for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl Unpin for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl Unpin for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl Unpin for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl Unpin for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl Unpin for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl Unpin for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl Unpin for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl Unpin for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl Unpin for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl Unpin for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl Unpin for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl Unpin for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl Unpin for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl Unpin for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl Unpin for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl Unpin for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl Unpin for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl Unpin for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl Unpin for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl Unpin for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl Unpin for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl Unpin for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Unpin for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Unpin for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Unpin for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl Unpin for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl Unpin for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> Unpin for CheckLoginMiddleware<S> where
    S: Unpin, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Unpin for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Unpin for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> Unpin for SudoPage<'a, K, V> where
    K: Unpin,
    V: Unpin, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl Unpin for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl Unpin for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> Unpin for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Unpin for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Unpin for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Unpin for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl Unpin for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl Unpin for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl Unpin for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl Unpin for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl Unpin for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> Unpin for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Unpin for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl Unpin for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl Unpin for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl Unpin for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Unpin for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Unpin for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl Unpin for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl Unpin for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Unpin for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl Unpin for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl Unpin for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Unpin for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl Unpin for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Unpin for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Unpin for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl Unpin for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl Unpin for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl Unpin for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl Unpin for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl Unpin for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl Unpin for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl Unpin for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl Unpin for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl Unpin for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Unpin for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Unpin for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Unpin for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Unpin for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Unpin for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Unpin for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Unpin for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Unpin for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Unpin for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Unpin for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl Unpin for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl Unpin for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl Unpin for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl Unpin for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl Unpin for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl Unpin for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl Unpin for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl Unpin for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl Unpin for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Unpin for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl Unpin for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl Unpin for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl Unpin for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl Unpin for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl Unpin for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Unpin for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Unpin for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Unpin for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl Unpin for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; +implementors["tests_migrate"] = [{"text":"impl Unpin for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl Unpin for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl Unpin for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl Unpin for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl Unpin for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl Unpin for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl Unpin for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl Unpin for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/core/ops/deref/trait.Deref.js b/implementors/core/ops/deref/trait.Deref.js index 5a4be7f1..fd7a949e 100644 --- a/implementors/core/ops/deref/trait.Deref.js +++ b/implementors/core/ops/deref/trait.Deref.js @@ -1,4 +1,4 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Deref for INTERNAL_SERVER_ERROR_BODY","synthetic":false,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Deref for UNKNOWN_ERROR_BODY","synthetic":false,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Deref for KEY","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Deref for GITHUB","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Deref for HOME","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Deref for SETTINGS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Deref for CREDIT_CARD","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Deref for HELP_CIRCLE","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Deref for MESSAGE","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Deref for DOCS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Deref for MCAPTCHA_TRANS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Deref for BAR_CHART","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Deref for INDEX_PAGE","synthetic":false,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Deref for SETTINGS","synthetic":false,"types":["mcaptcha::SETTINGS"]},{"text":"impl Deref for FILES","synthetic":false,"types":["mcaptcha::FILES"]},{"text":"impl Deref for JS","synthetic":false,"types":["mcaptcha::JS"]},{"text":"impl Deref for CSS","synthetic":false,"types":["mcaptcha::CSS"]},{"text":"impl Deref for MOBILE_CSS","synthetic":false,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Deref for VERIFICATIN_WIDGET_JS","synthetic":false,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Deref for VERIFICATIN_WIDGET_CSS","synthetic":false,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Deref for SOURCE_FILES_OF_INSTANCE","synthetic":false,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["tests_migrate"] = [{"text":"impl Deref for SETTINGS","synthetic":false,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl Deref for INTERNAL_SERVER_ERROR_BODY","synthetic":false,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl Deref for UNKNOWN_ERROR_BODY","synthetic":false,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl Deref for INDEX","synthetic":false,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl Deref for KEY","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl Deref for GITHUB","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl Deref for HOME","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl Deref for SETTINGS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl Deref for CREDIT_CARD","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl Deref for HELP_CIRCLE","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl Deref for MESSAGE","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl Deref for DOCS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl Deref for MCAPTCHA_TRANS_ICON","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl Deref for BAR_CHART","synthetic":false,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl Deref for INDEX_PAGE","synthetic":false,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl Deref for SETTINGS","synthetic":false,"types":["mcaptcha::SETTINGS"]},{"text":"impl Deref for FILES","synthetic":false,"types":["mcaptcha::FILES"]},{"text":"impl Deref for JS","synthetic":false,"types":["mcaptcha::JS"]},{"text":"impl Deref for CSS","synthetic":false,"types":["mcaptcha::CSS"]},{"text":"impl Deref for MOBILE_CSS","synthetic":false,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl Deref for VERIFICATIN_WIDGET_JS","synthetic":false,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl Deref for VERIFICATIN_WIDGET_CSS","synthetic":false,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl Deref for SOURCE_FILES_OF_INSTANCE","synthetic":false,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["tests_migrate"] = [{"text":"impl Deref for SETTINGS","synthetic":false,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/sailfish/private/trait.Sealed.js b/implementors/sailfish/private/trait.Sealed.js index 2951087c..7642f224 100644 --- a/implementors/sailfish/private/trait.Sealed.js +++ b/implementors/sailfish/private/trait.Sealed.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K, V> Sealed for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> Sealed for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; +implementors["mcaptcha"] = [{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K, V> Sealed for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> Sealed for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> Sealed for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl Sealed for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/sailfish/trait.TemplateOnce.js b/implementors/sailfish/trait.TemplateOnce.js index c354eefe..93811c03 100644 --- a/implementors/sailfish/trait.TemplateOnce.js +++ b/implementors/sailfish/trait.TemplateOnce.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K, V> TemplateOnce for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> TemplateOnce for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; +implementors["mcaptcha"] = [{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl<'a, K, V> TemplateOnce for SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render, ","synthetic":false,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl<'a> TemplateOnce for ErrorPage<'a>","synthetic":false,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl<'a> TemplateOnce for IndexPage<'a>","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl TemplateOnce for IndexPage","synthetic":false,"types":["mcaptcha::widget::IndexPage"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/error/trait.Error.js b/implementors/std/error/trait.Error.js index 8c854532..a6207f5e 100644 --- a/implementors/std/error/trait.Error.js +++ b/implementors/std/error/trait.Error.js @@ -1,3 +1,3 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl Error for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Error for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Error for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Error for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Error for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; +implementors["mcaptcha"] = [{"text":"impl Error for BuildDetailsBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl Error for HealthBuilderError","synthetic":false,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl Error for SmtpErrorWrapper","synthetic":false,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl Error for ServiceError","synthetic":false,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl Error for PageError","synthetic":false,"types":["mcaptcha::errors::PageError"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/panic/trait.RefUnwindSafe.js b/implementors/std/panic/trait.RefUnwindSafe.js index a28df098..f908d57c 100644 --- a/implementors/std/panic/trait.RefUnwindSafe.js +++ b/implementors/std/panic/trait.RefUnwindSafe.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl RefUnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl RefUnwindSafe for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl RefUnwindSafe for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl RefUnwindSafe for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl RefUnwindSafe for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl RefUnwindSafe for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl RefUnwindSafe for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl RefUnwindSafe for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl RefUnwindSafe for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl RefUnwindSafe for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl RefUnwindSafe for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl RefUnwindSafe for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl RefUnwindSafe for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl RefUnwindSafe for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl RefUnwindSafe for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl RefUnwindSafe for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl RefUnwindSafe for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl RefUnwindSafe for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl RefUnwindSafe for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl RefUnwindSafe for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl RefUnwindSafe for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl RefUnwindSafe for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl RefUnwindSafe for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl RefUnwindSafe for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl RefUnwindSafe for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl RefUnwindSafe for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl RefUnwindSafe for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl RefUnwindSafe for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl RefUnwindSafe for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl RefUnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl RefUnwindSafe for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl RefUnwindSafe for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl RefUnwindSafe for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl RefUnwindSafe for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl RefUnwindSafe for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl RefUnwindSafe for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl RefUnwindSafe for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl RefUnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl RefUnwindSafe for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl RefUnwindSafe for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl RefUnwindSafe for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl RefUnwindSafe for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl RefUnwindSafe for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl RefUnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl RefUnwindSafe for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl RefUnwindSafe for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl RefUnwindSafe for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl RefUnwindSafe for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl RefUnwindSafe for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl RefUnwindSafe for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl RefUnwindSafe for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl RefUnwindSafe for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl RefUnwindSafe for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl RefUnwindSafe for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl RefUnwindSafe for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl RefUnwindSafe for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl RefUnwindSafe for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl RefUnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl RefUnwindSafe for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl RefUnwindSafe for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl RefUnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl RefUnwindSafe for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl RefUnwindSafe for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl RefUnwindSafe for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl RefUnwindSafe for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl RefUnwindSafe for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl RefUnwindSafe for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl RefUnwindSafe for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl RefUnwindSafe for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl RefUnwindSafe for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl RefUnwindSafe for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl !RefUnwindSafe for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl !RefUnwindSafe for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl RefUnwindSafe for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl RefUnwindSafe for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl RefUnwindSafe for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl RefUnwindSafe for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl RefUnwindSafe for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl RefUnwindSafe for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl !RefUnwindSafe for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl !RefUnwindSafe for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl RefUnwindSafe for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl !RefUnwindSafe for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl RefUnwindSafe for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> RefUnwindSafe for CheckLoginMiddleware<S> where
    S: RefUnwindSafe, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl RefUnwindSafe for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl RefUnwindSafe for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> RefUnwindSafe for SudoPage<'a, K, V> where
    K: RefUnwindSafe,
    V: RefUnwindSafe, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl RefUnwindSafe for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl RefUnwindSafe for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> RefUnwindSafe for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl RefUnwindSafe for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl RefUnwindSafe for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl RefUnwindSafe for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl RefUnwindSafe for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl RefUnwindSafe for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl RefUnwindSafe for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl RefUnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl RefUnwindSafe for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl RefUnwindSafe for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl RefUnwindSafe for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl RefUnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl RefUnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl RefUnwindSafe for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl RefUnwindSafe for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl RefUnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl RefUnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl RefUnwindSafe for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl RefUnwindSafe for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl RefUnwindSafe for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl RefUnwindSafe for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl RefUnwindSafe for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl RefUnwindSafe for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl RefUnwindSafe for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl RefUnwindSafe for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl RefUnwindSafe for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl RefUnwindSafe for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl RefUnwindSafe for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl RefUnwindSafe for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl RefUnwindSafe for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl RefUnwindSafe for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl RefUnwindSafe for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl RefUnwindSafe for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl RefUnwindSafe for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl RefUnwindSafe for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl RefUnwindSafe for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl RefUnwindSafe for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl RefUnwindSafe for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl RefUnwindSafe for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl RefUnwindSafe for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl RefUnwindSafe for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl RefUnwindSafe for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl RefUnwindSafe for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl RefUnwindSafe for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl RefUnwindSafe for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl RefUnwindSafe for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl RefUnwindSafe for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl RefUnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl RefUnwindSafe for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl RefUnwindSafe for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl RefUnwindSafe for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl RefUnwindSafe for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl RefUnwindSafe for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl RefUnwindSafe for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl RefUnwindSafe for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl RefUnwindSafe for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl RefUnwindSafe for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl RefUnwindSafe for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl RefUnwindSafe for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl RefUnwindSafe for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl RefUnwindSafe for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl RefUnwindSafe for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl RefUnwindSafe for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl RefUnwindSafe for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl RefUnwindSafe for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl RefUnwindSafe for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl RefUnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl RefUnwindSafe for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl RefUnwindSafe for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl RefUnwindSafe for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl RefUnwindSafe for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl RefUnwindSafe for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl RefUnwindSafe for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl RefUnwindSafe for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl RefUnwindSafe for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl RefUnwindSafe for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl RefUnwindSafe for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl RefUnwindSafe for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl RefUnwindSafe for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl RefUnwindSafe for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl RefUnwindSafe for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl RefUnwindSafe for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl RefUnwindSafe for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl RefUnwindSafe for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl RefUnwindSafe for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl RefUnwindSafe for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl RefUnwindSafe for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl RefUnwindSafe for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl RefUnwindSafe for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl RefUnwindSafe for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl RefUnwindSafe for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl RefUnwindSafe for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl RefUnwindSafe for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl RefUnwindSafe for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl RefUnwindSafe for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl RefUnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl RefUnwindSafe for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl RefUnwindSafe for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl RefUnwindSafe for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl RefUnwindSafe for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl RefUnwindSafe for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl RefUnwindSafe for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl RefUnwindSafe for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl RefUnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl RefUnwindSafe for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl RefUnwindSafe for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl RefUnwindSafe for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl RefUnwindSafe for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl RefUnwindSafe for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl RefUnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl RefUnwindSafe for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl RefUnwindSafe for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl RefUnwindSafe for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl RefUnwindSafe for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl RefUnwindSafe for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl RefUnwindSafe for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl RefUnwindSafe for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl RefUnwindSafe for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl RefUnwindSafe for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl RefUnwindSafe for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl RefUnwindSafe for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl RefUnwindSafe for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl RefUnwindSafe for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl RefUnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl RefUnwindSafe for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl RefUnwindSafe for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl RefUnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl RefUnwindSafe for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl RefUnwindSafe for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl RefUnwindSafe for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl RefUnwindSafe for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl RefUnwindSafe for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl RefUnwindSafe for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl RefUnwindSafe for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl RefUnwindSafe for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl RefUnwindSafe for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl RefUnwindSafe for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl !RefUnwindSafe for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl !RefUnwindSafe for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl RefUnwindSafe for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl RefUnwindSafe for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl RefUnwindSafe for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl RefUnwindSafe for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl RefUnwindSafe for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl RefUnwindSafe for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl !RefUnwindSafe for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl !RefUnwindSafe for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl RefUnwindSafe for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl !RefUnwindSafe for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl RefUnwindSafe for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> RefUnwindSafe for CheckLoginMiddleware<S> where
    S: RefUnwindSafe, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl RefUnwindSafe for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl RefUnwindSafe for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> RefUnwindSafe for SudoPage<'a, K, V> where
    K: RefUnwindSafe,
    V: RefUnwindSafe, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl RefUnwindSafe for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl RefUnwindSafe for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> RefUnwindSafe for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl RefUnwindSafe for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl RefUnwindSafe for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl RefUnwindSafe for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl RefUnwindSafe for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl RefUnwindSafe for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl RefUnwindSafe for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl RefUnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl RefUnwindSafe for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> RefUnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl RefUnwindSafe for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl RefUnwindSafe for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl RefUnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl RefUnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl RefUnwindSafe for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl RefUnwindSafe for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl RefUnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl RefUnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl RefUnwindSafe for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl RefUnwindSafe for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl RefUnwindSafe for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl RefUnwindSafe for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl RefUnwindSafe for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl RefUnwindSafe for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl RefUnwindSafe for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl RefUnwindSafe for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl RefUnwindSafe for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl RefUnwindSafe for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl RefUnwindSafe for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl RefUnwindSafe for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl RefUnwindSafe for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl RefUnwindSafe for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl RefUnwindSafe for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl RefUnwindSafe for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl RefUnwindSafe for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl RefUnwindSafe for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl RefUnwindSafe for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl RefUnwindSafe for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl RefUnwindSafe for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl RefUnwindSafe for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl RefUnwindSafe for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl RefUnwindSafe for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl RefUnwindSafe for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl RefUnwindSafe for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl RefUnwindSafe for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl RefUnwindSafe for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl RefUnwindSafe for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl RefUnwindSafe for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl RefUnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl RefUnwindSafe for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl RefUnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl RefUnwindSafe for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl RefUnwindSafe for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl RefUnwindSafe for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl RefUnwindSafe for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl RefUnwindSafe for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl RefUnwindSafe for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl RefUnwindSafe for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl RefUnwindSafe for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl RefUnwindSafe for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl RefUnwindSafe for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl RefUnwindSafe for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; +implementors["tests_migrate"] = [{"text":"impl RefUnwindSafe for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl RefUnwindSafe for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl RefUnwindSafe for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl RefUnwindSafe for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl RefUnwindSafe for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl RefUnwindSafe for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl RefUnwindSafe for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl RefUnwindSafe for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/implementors/std/panic/trait.UnwindSafe.js b/implementors/std/panic/trait.UnwindSafe.js index 9a2a1d24..7539131c 100644 --- a/implementors/std/panic/trait.UnwindSafe.js +++ b/implementors/std/panic/trait.UnwindSafe.js @@ -1,5 +1,5 @@ (function() {var implementors = {}; -implementors["mcaptcha"] = [{"text":"impl UnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl UnwindSafe for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl UnwindSafe for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl UnwindSafe for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl UnwindSafe for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl UnwindSafe for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl UnwindSafe for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl UnwindSafe for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl UnwindSafe for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl UnwindSafe for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl UnwindSafe for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl UnwindSafe for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl UnwindSafe for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl UnwindSafe for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl UnwindSafe for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl UnwindSafe for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl UnwindSafe for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl UnwindSafe for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl UnwindSafe for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl UnwindSafe for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl UnwindSafe for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl UnwindSafe for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl UnwindSafe for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl UnwindSafe for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl UnwindSafe for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl UnwindSafe for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl UnwindSafe for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl UnwindSafe for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl UnwindSafe for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl UnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl UnwindSafe for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl UnwindSafe for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl UnwindSafe for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl UnwindSafe for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl UnwindSafe for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl UnwindSafe for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl UnwindSafe for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl UnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl UnwindSafe for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl UnwindSafe for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl UnwindSafe for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl UnwindSafe for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl UnwindSafe for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl UnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl UnwindSafe for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl UnwindSafe for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl UnwindSafe for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl UnwindSafe for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl UnwindSafe for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl UnwindSafe for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl UnwindSafe for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl UnwindSafe for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl UnwindSafe for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl UnwindSafe for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl UnwindSafe for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl UnwindSafe for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl UnwindSafe for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl UnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl UnwindSafe for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl UnwindSafe for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl UnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl UnwindSafe for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl UnwindSafe for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl UnwindSafe for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl UnwindSafe for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl UnwindSafe for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl UnwindSafe for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl UnwindSafe for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl UnwindSafe for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl UnwindSafe for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl UnwindSafe for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl !UnwindSafe for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl !UnwindSafe for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl UnwindSafe for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl UnwindSafe for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl UnwindSafe for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl UnwindSafe for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl UnwindSafe for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl UnwindSafe for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl !UnwindSafe for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl !UnwindSafe for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl UnwindSafe for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl !UnwindSafe for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl UnwindSafe for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> UnwindSafe for CheckLoginMiddleware<S> where
    S: UnwindSafe, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl UnwindSafe for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl UnwindSafe for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> UnwindSafe for SudoPage<'a, K, V> where
    K: UnwindSafe,
    V: UnwindSafe, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl UnwindSafe for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl UnwindSafe for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> UnwindSafe for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl UnwindSafe for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl UnwindSafe for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl UnwindSafe for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl UnwindSafe for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl UnwindSafe for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl UnwindSafe for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl UnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl UnwindSafe for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl UnwindSafe for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl UnwindSafe for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl UnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl UnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl UnwindSafe for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl UnwindSafe for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl UnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl UnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl UnwindSafe for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl UnwindSafe for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl UnwindSafe for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl UnwindSafe for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl UnwindSafe for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl UnwindSafe for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl UnwindSafe for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl UnwindSafe for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl UnwindSafe for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl UnwindSafe for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl UnwindSafe for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl UnwindSafe for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl UnwindSafe for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl UnwindSafe for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl UnwindSafe for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl UnwindSafe for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl UnwindSafe for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl UnwindSafe for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl UnwindSafe for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl UnwindSafe for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl UnwindSafe for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl UnwindSafe for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl UnwindSafe for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl UnwindSafe for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl UnwindSafe for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl UnwindSafe for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl UnwindSafe for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl UnwindSafe for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl UnwindSafe for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl UnwindSafe for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl UnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl UnwindSafe for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl UnwindSafe for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl UnwindSafe for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl UnwindSafe for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl UnwindSafe for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl UnwindSafe for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl UnwindSafe for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl UnwindSafe for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl UnwindSafe for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl UnwindSafe for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl UnwindSafe for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; -implementors["mcaptcha_browser"] = [{"text":"impl UnwindSafe for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; -implementors["tests_migrate"] = [{"text":"impl UnwindSafe for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl UnwindSafe for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl UnwindSafe for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl UnwindSafe for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl UnwindSafe for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl UnwindSafe for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl UnwindSafe for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; +implementors["mcaptcha"] = [{"text":"impl UnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::api::v1::account::delete::delete_account"]},{"text":"impl UnwindSafe for Email","synthetic":true,"types":["mcaptcha::api::v1::account::email::Email"]},{"text":"impl UnwindSafe for email_exists","synthetic":true,"types":["mcaptcha::api::v1::account::email::email_exists"]},{"text":"impl UnwindSafe for set_email","synthetic":true,"types":["mcaptcha::api::v1::account::email::set_email"]},{"text":"impl UnwindSafe for ChangePasswordReqest","synthetic":true,"types":["mcaptcha::api::v1::account::password::ChangePasswordReqest"]},{"text":"impl UnwindSafe for UpdatePassword","synthetic":true,"types":["mcaptcha::api::v1::account::password::UpdatePassword"]},{"text":"impl UnwindSafe for update_user_password","synthetic":true,"types":["mcaptcha::api::v1::account::password::update_user_password"]},{"text":"impl UnwindSafe for Secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::Secret"]},{"text":"impl UnwindSafe for get_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::get_secret"]},{"text":"impl UnwindSafe for update_user_secret","synthetic":true,"types":["mcaptcha::api::v1::account::secret::update_user_secret"]},{"text":"impl UnwindSafe for username_exists","synthetic":true,"types":["mcaptcha::api::v1::account::username::username_exists"]},{"text":"impl UnwindSafe for Username","synthetic":true,"types":["mcaptcha::api::v1::account::username::Username"]},{"text":"impl UnwindSafe for set_username","synthetic":true,"types":["mcaptcha::api::v1::account::username::set_username"]},{"text":"impl UnwindSafe for Account","synthetic":true,"types":["mcaptcha::api::v1::account::routes::Account"]},{"text":"impl UnwindSafe for AccountCheckPayload","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckPayload"]},{"text":"impl UnwindSafe for AccountCheckResp","synthetic":true,"types":["mcaptcha::api::v1::account::AccountCheckResp"]},{"text":"impl UnwindSafe for Auth","synthetic":true,"types":["mcaptcha::api::v1::auth::routes::Auth"]},{"text":"impl UnwindSafe for Register","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Register"]},{"text":"impl UnwindSafe for Login","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Login"]},{"text":"impl UnwindSafe for Password","synthetic":true,"types":["mcaptcha::api::v1::auth::runners::Password"]},{"text":"impl UnwindSafe for register","synthetic":true,"types":["mcaptcha::api::v1::auth::register"]},{"text":"impl UnwindSafe for login","synthetic":true,"types":["mcaptcha::api::v1::auth::login"]},{"text":"impl UnwindSafe for signout","synthetic":true,"types":["mcaptcha::api::v1::auth::signout"]},{"text":"impl UnwindSafe for MCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha"]},{"text":"impl UnwindSafe for MCaptchaID","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID"]},{"text":"impl UnwindSafe for MCaptchaDetails","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails"]},{"text":"impl UnwindSafe for update_token","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::update_token"]},{"text":"impl UnwindSafe for DeleteCaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha"]},{"text":"impl UnwindSafe for delete_mcaptcha","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha"]},{"text":"impl UnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::StatsPayload"]},{"text":"impl UnwindSafe for get_stats","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::captcha::get_stats"]},{"text":"impl UnwindSafe for Duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::routes::Duration"]},{"text":"impl UnwindSafe for UpdateDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::UpdateDuration"]},{"text":"impl UnwindSafe for update_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::update_duration"]},{"text":"impl UnwindSafe for GetDurationResp","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDurationResp"]},{"text":"impl UnwindSafe for GetDuration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::GetDuration"]},{"text":"impl UnwindSafe for get_duration","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::duration::get_duration"]},{"text":"impl UnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::routes::Levels"]},{"text":"impl UnwindSafe for AddLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::AddLevels"]},{"text":"impl UnwindSafe for add_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::add_levels"]},{"text":"impl UnwindSafe for UpdateLevels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::UpdateLevels"]},{"text":"impl UnwindSafe for update_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::update_levels"]},{"text":"impl UnwindSafe for get_levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::get_levels"]},{"text":"impl UnwindSafe for Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::Levels"]},{"text":"impl UnwindSafe for I32Levels","synthetic":true,"types":["mcaptcha::api::v1::mcaptcha::levels::I32Levels"]},{"text":"impl UnwindSafe for Meta","synthetic":true,"types":["mcaptcha::api::v1::meta::routes::Meta"]},{"text":"impl UnwindSafe for BuildDetails","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetails"]},{"text":"impl UnwindSafe for BuildDetailsBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilder"]},{"text":"impl UnwindSafe for BuildDetailsBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::BuildDetailsBuilderError"]},{"text":"impl UnwindSafe for build_details","synthetic":true,"types":["mcaptcha::api::v1::meta::build_details"]},{"text":"impl UnwindSafe for Health","synthetic":true,"types":["mcaptcha::api::v1::meta::Health"]},{"text":"impl UnwindSafe for HealthBuilder","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilder"]},{"text":"impl UnwindSafe for HealthBuilderError","synthetic":true,"types":["mcaptcha::api::v1::meta::HealthBuilderError"]},{"text":"impl UnwindSafe for health","synthetic":true,"types":["mcaptcha::api::v1::meta::health"]},{"text":"impl UnwindSafe for AddNotification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::AddNotification"]},{"text":"impl UnwindSafe for add_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::add::add_notification"]},{"text":"impl UnwindSafe for Notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::Notification"]},{"text":"impl UnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::NotificationResp"]},{"text":"impl UnwindSafe for get_notification","synthetic":true,"types":["mcaptcha::api::v1::notifications::get::get_notification"]},{"text":"impl UnwindSafe for MarkReadReq","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::MarkReadReq"]},{"text":"impl UnwindSafe for NotificationResp","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::NotificationResp"]},{"text":"impl UnwindSafe for mark_read","synthetic":true,"types":["mcaptcha::api::v1::notifications::mark_read::mark_read"]},{"text":"impl UnwindSafe for Notifications","synthetic":true,"types":["mcaptcha::api::v1::notifications::routes::Notifications"]},{"text":"impl UnwindSafe for GetConfigPayload","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::GetConfigPayload"]},{"text":"impl UnwindSafe for get_config","synthetic":true,"types":["mcaptcha::api::v1::pow::get_config::get_config"]},{"text":"impl UnwindSafe for ValidationToken","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::ValidationToken"]},{"text":"impl UnwindSafe for verify_pow","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_pow::verify_pow"]},{"text":"impl UnwindSafe for CaptchaValidateResp","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp"]},{"text":"impl UnwindSafe for validate_captcha_token","synthetic":true,"types":["mcaptcha::api::v1::pow::verify_token::validate_captcha_token"]},{"text":"impl UnwindSafe for PoW","synthetic":true,"types":["mcaptcha::api::v1::pow::routes::PoW"]},{"text":"impl UnwindSafe for Routes","synthetic":true,"types":["mcaptcha::api::v1::routes::Routes"]},{"text":"impl !UnwindSafe for SystemGroup","synthetic":true,"types":["mcaptcha::data::SystemGroup"]},{"text":"impl !UnwindSafe for Data","synthetic":true,"types":["mcaptcha::data::Data"]},{"text":"impl UnwindSafe for Date","synthetic":true,"types":["mcaptcha::date::Date"]},{"text":"impl UnwindSafe for Docs","synthetic":true,"types":["mcaptcha::docs::routes::Docs"]},{"text":"impl UnwindSafe for Asset","synthetic":true,"types":["mcaptcha::docs::Asset"]},{"text":"impl UnwindSafe for dist","synthetic":true,"types":["mcaptcha::docs::dist"]},{"text":"impl UnwindSafe for spec","synthetic":true,"types":["mcaptcha::docs::spec"]},{"text":"impl UnwindSafe for index","synthetic":true,"types":["mcaptcha::docs::index"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::email::verification::IndexPage"]},{"text":"impl !UnwindSafe for SmtpErrorWrapper","synthetic":true,"types":["mcaptcha::errors::SmtpErrorWrapper"]},{"text":"impl !UnwindSafe for ServiceError","synthetic":true,"types":["mcaptcha::errors::ServiceError"]},{"text":"impl UnwindSafe for ErrorToResponse","synthetic":true,"types":["mcaptcha::errors::ErrorToResponse"]},{"text":"impl !UnwindSafe for PageError","synthetic":true,"types":["mcaptcha::errors::PageError"]},{"text":"impl UnwindSafe for CheckLogin","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLogin"]},{"text":"impl<S> UnwindSafe for CheckLoginMiddleware<S> where
    S: UnwindSafe, ","synthetic":true,"types":["mcaptcha::middleware::auth::CheckLoginMiddleware"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::login::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::login::INDEX"]},{"text":"impl UnwindSafe for login","synthetic":true,"types":["mcaptcha::pages::auth::login::login"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::auth::register::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::auth::register::INDEX"]},{"text":"impl UnwindSafe for join","synthetic":true,"types":["mcaptcha::pages::auth::register::join"]},{"text":"impl<'a, K, V> UnwindSafe for SudoPage<'a, K, V> where
    K: UnwindSafe,
    V: UnwindSafe, ","synthetic":true,"types":["mcaptcha::pages::auth::sudo::SudoPage"]},{"text":"impl UnwindSafe for Auth","synthetic":true,"types":["mcaptcha::pages::auth::routes::Auth"]},{"text":"impl UnwindSafe for Errors","synthetic":true,"types":["mcaptcha::pages::errors::routes::Errors"]},{"text":"impl<'a> UnwindSafe for ErrorPage<'a>","synthetic":true,"types":["mcaptcha::pages::errors::ErrorPage"]},{"text":"impl UnwindSafe for INTERNAL_SERVER_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY"]},{"text":"impl UnwindSafe for UNKNOWN_ERROR_BODY","synthetic":true,"types":["mcaptcha::pages::errors::UNKNOWN_ERROR_BODY"]},{"text":"impl UnwindSafe for error","synthetic":true,"types":["mcaptcha::pages::errors::error"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::notifications::IndexPage"]},{"text":"impl UnwindSafe for Notification","synthetic":true,"types":["mcaptcha::pages::panel::notifications::Notification"]},{"text":"impl UnwindSafe for notifications","synthetic":true,"types":["mcaptcha::pages::panel::notifications::notifications"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::routes::Settings"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::settings::IndexPage"]},{"text":"impl UnwindSafe for settings","synthetic":true,"types":["mcaptcha::pages::panel::settings::settings"]},{"text":"impl UnwindSafe for delete_account","synthetic":true,"types":["mcaptcha::pages::panel::settings::delete_account"]},{"text":"impl UnwindSafe for update_secret","synthetic":true,"types":["mcaptcha::pages::panel::settings::update_secret"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::INDEX"]},{"text":"impl<'a> UnwindSafe for IndexPage<'a>","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::IndexPage"]},{"text":"impl UnwindSafe for add_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::add::add_sitekey"]},{"text":"impl UnwindSafe for delete_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::delete::delete_sitekey"]},{"text":"impl UnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::McaptchaConfig"]},{"text":"impl UnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::Level"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::IndexPage"]},{"text":"impl UnwindSafe for edit_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::edit::edit_sitekey"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::IndexPage"]},{"text":"impl UnwindSafe for list_sitekeys","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::list::list_sitekeys"]},{"text":"impl UnwindSafe for McaptchaConfig","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::McaptchaConfig"]},{"text":"impl UnwindSafe for Level","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::Level"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::IndexPage"]},{"text":"impl UnwindSafe for view_sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::view::view_sitekey"]},{"text":"impl UnwindSafe for Sitekey","synthetic":true,"types":["mcaptcha::pages::panel::sitekey::routes::Sitekey"]},{"text":"impl UnwindSafe for Panel","synthetic":true,"types":["mcaptcha::pages::panel::routes::Panel"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::panel::IndexPage"]},{"text":"impl UnwindSafe for panel","synthetic":true,"types":["mcaptcha::pages::panel::panel"]},{"text":"impl UnwindSafe for Routes","synthetic":true,"types":["mcaptcha::pages::routes::Routes"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::pages::sitemap::IndexPage"]},{"text":"impl UnwindSafe for INDEX","synthetic":true,"types":["mcaptcha::pages::sitemap::INDEX"]},{"text":"impl UnwindSafe for sitemap","synthetic":true,"types":["mcaptcha::pages::sitemap::sitemap"]},{"text":"impl UnwindSafe for Methods","synthetic":true,"types":["mcaptcha::routes::Methods"]},{"text":"impl UnwindSafe for Server","synthetic":true,"types":["mcaptcha::settings::Server"]},{"text":"impl UnwindSafe for Captcha","synthetic":true,"types":["mcaptcha::settings::Captcha"]},{"text":"impl UnwindSafe for Smtp","synthetic":true,"types":["mcaptcha::settings::Smtp"]},{"text":"impl UnwindSafe for DatabaseBuilder","synthetic":true,"types":["mcaptcha::settings::DatabaseBuilder"]},{"text":"impl UnwindSafe for Database","synthetic":true,"types":["mcaptcha::settings::Database"]},{"text":"impl UnwindSafe for Redis","synthetic":true,"types":["mcaptcha::settings::Redis"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["mcaptcha::settings::Settings"]},{"text":"impl UnwindSafe for FileMap","synthetic":true,"types":["mcaptcha::static_assets::filemap::FileMap"]},{"text":"impl UnwindSafe for KEY","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::KEY"]},{"text":"impl UnwindSafe for GITHUB","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::GITHUB"]},{"text":"impl UnwindSafe for HOME","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HOME"]},{"text":"impl UnwindSafe for SETTINGS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::SETTINGS_ICON"]},{"text":"impl UnwindSafe for CREDIT_CARD","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::CREDIT_CARD"]},{"text":"impl UnwindSafe for HELP_CIRCLE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::HELP_CIRCLE"]},{"text":"impl UnwindSafe for MESSAGE","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MESSAGE"]},{"text":"impl UnwindSafe for DOCS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::DOCS_ICON"]},{"text":"impl UnwindSafe for MCAPTCHA_TRANS_ICON","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON"]},{"text":"impl UnwindSafe for BAR_CHART","synthetic":true,"types":["mcaptcha::static_assets::static_files::assets::BAR_CHART"]},{"text":"impl UnwindSafe for Asset","synthetic":true,"types":["mcaptcha::static_assets::static_files::Asset"]},{"text":"impl UnwindSafe for static_files","synthetic":true,"types":["mcaptcha::static_assets::static_files::static_files"]},{"text":"impl UnwindSafe for Favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::Favicons"]},{"text":"impl UnwindSafe for favicons","synthetic":true,"types":["mcaptcha::static_assets::static_files::favicons"]},{"text":"impl UnwindSafe for StatsUnixTimestamp","synthetic":true,"types":["mcaptcha::stats::fetch::StatsUnixTimestamp"]},{"text":"impl UnwindSafe for Stats","synthetic":true,"types":["mcaptcha::stats::fetch::Stats"]},{"text":"impl UnwindSafe for StatsPayload","synthetic":true,"types":["mcaptcha::stats::fetch::StatsPayload"]},{"text":"impl UnwindSafe for Widget","synthetic":true,"types":["mcaptcha::widget::routes::Widget"]},{"text":"impl UnwindSafe for IndexPage","synthetic":true,"types":["mcaptcha::widget::IndexPage"]},{"text":"impl UnwindSafe for INDEX_PAGE","synthetic":true,"types":["mcaptcha::widget::INDEX_PAGE"]},{"text":"impl UnwindSafe for show_widget","synthetic":true,"types":["mcaptcha::widget::show_widget"]},{"text":"impl UnwindSafe for SETTINGS","synthetic":true,"types":["mcaptcha::SETTINGS"]},{"text":"impl UnwindSafe for FILES","synthetic":true,"types":["mcaptcha::FILES"]},{"text":"impl UnwindSafe for JS","synthetic":true,"types":["mcaptcha::JS"]},{"text":"impl UnwindSafe for CSS","synthetic":true,"types":["mcaptcha::CSS"]},{"text":"impl UnwindSafe for MOBILE_CSS","synthetic":true,"types":["mcaptcha::MOBILE_CSS"]},{"text":"impl UnwindSafe for VERIFICATIN_WIDGET_JS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_JS"]},{"text":"impl UnwindSafe for VERIFICATIN_WIDGET_CSS","synthetic":true,"types":["mcaptcha::VERIFICATIN_WIDGET_CSS"]},{"text":"impl UnwindSafe for SOURCE_FILES_OF_INSTANCE","synthetic":true,"types":["mcaptcha::SOURCE_FILES_OF_INSTANCE"]}]; +implementors["mcaptcha_browser"] = [{"text":"impl UnwindSafe for Work","synthetic":true,"types":["mcaptcha_browser::Work"]}]; +implementors["tests_migrate"] = [{"text":"impl UnwindSafe for Server","synthetic":true,"types":["tests_migrate::settings::Server"]},{"text":"impl UnwindSafe for Captcha","synthetic":true,"types":["tests_migrate::settings::Captcha"]},{"text":"impl UnwindSafe for Smtp","synthetic":true,"types":["tests_migrate::settings::Smtp"]},{"text":"impl UnwindSafe for DatabaseBuilder","synthetic":true,"types":["tests_migrate::settings::DatabaseBuilder"]},{"text":"impl UnwindSafe for Database","synthetic":true,"types":["tests_migrate::settings::Database"]},{"text":"impl UnwindSafe for Redis","synthetic":true,"types":["tests_migrate::settings::Redis"]},{"text":"impl UnwindSafe for Settings","synthetic":true,"types":["tests_migrate::settings::Settings"]},{"text":"impl UnwindSafe for SETTINGS","synthetic":true,"types":["tests_migrate::SETTINGS"]}]; if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/light.css b/light.css index a5aa6d03..fbbba652 100644 --- a/light.css +++ b/light.css @@ -1 +1 @@ - body{background-color:white;color:black;}h1,h2,h3,h4{color:black;}h1.fqn{border-bottom-color:#D5D5D5;}h2,h3,h4{border-bottom-color:#DDDDDD;}.in-band{background-color:white;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#F5F5F5;}pre,.rustdoc.source .example-wrap{background-color:#F5F5F5;}.sidebar{background-color:#F1F1F1;}*{scrollbar-color:rgba(36,37,39,0.6) #e6e6e6;}.sidebar{scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;}.logo-container.rust-logo>img{}::-webkit-scrollbar-track{background-color:#ecebeb;}::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar::-webkit-scrollbar-track{background-color:#dcdcdc;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar .current{background-color:#fff;}.source .sidebar{background-color:#fff;}.sidebar .location{border-color:#000;background-color:#fff;color:#333;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#F5F5F5;}.line-numbers span{color:#c67e2d;}.line-numbers .line-highlighted{background-color:#f6fdb0 !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#ddd;}.docblock table,.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#4E4C4C;}.search-results a:hover{background-color:#ddd;}.search-results a:focus{color:#000 !important;background-color:#ccc;}.search-results a:focus span{color:#000 !important;}a.result-trait:focus{background-color:#c7b6ff;}a.result-traitalias:focus{background-color:#c7b6ff;}a.result-mod:focus,a.result-externcrate:focus{background-color:#afc6e4;}a.result-enum:focus{background-color:#b4d1b9;}a.result-struct:focus{background-color:#e7b1a0;}a.result-union:focus{background-color:#b7bd49;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#c6afb3;}a.result-type:focus{background-color:#ffc891;}a.result-foreigntype:focus{background-color:#f5c4ff;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#8ce488;}a.result-constant:focus,a.result-static:focus{background-color:#c3e0ff;}a.result-primitive:focus{background-color:#9aecff;}a.result-keyword:focus{background-color:#f99650;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#508157;}.content span.struct,.content a.struct,.block a.current.struct{color:#ad448e;}.content span.type,.content a.type,.block a.current.type{color:#ba5d00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#cd00e2;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#068000;}.content span.union,.content a.union,.block a.current.union{color:#767b27;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#546e8a;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#2c8093;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#4d76ae;}.content span.trait,.content a.trait,.block a.current.trait{color:#7c5af3;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#6841f1;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#9a6e31;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}pre.rust .comment{color:#8E908C;}pre.rust .doccomment{color:#4D4D4C;}nav:not(.sidebar){border-bottom-color:#e0e0e0;}nav.main .current{border-top-color:#000;border-bottom-color:#000;}nav.main .separator{border:1px solid #000;}a{color:#000;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#3873AD;}a.test-arrow{color:#f5f5f5;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#555;background-color:white;border-color:#e0e0e0;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input{color:#555;background-color:white;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input:focus{border-color:#66afe9;}.search-input:disabled{background-color:#e6e6e6;}#crate-search+.search-input:focus{box-shadow:0 0 8px #078dd8;}.module-item .stab,.import-item .stab{color:#000;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;}.stab.portability>code{background:none;}#help>div{background:#e9e9e9;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}.since{color:grey;}tr.result span.primitive::after,tr.result span.keyword::after{color:black;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#8959A8;}pre.rust .kw-2,pre.rust .prelude-ty{color:#4271AE;}pre.rust .number,pre.rust .string{color:#718C00;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#C82829;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#B76514;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#c7c7c7;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background:#FDFFD3;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.5);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.5);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#eee;border-color:#999;}.notable-traits-tooltiptext .notable{border-bottom-color:#DDDDDD;}#titles>button:not(.selected){background-color:#e6e6e6;border-top-color:#e6e6e6;}#titles>button:hover,#titles>button.selected{background-color:#ffffff;border-top-color:#0089ff;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#F1F1F1;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#F1F1F1;border-right-color:#000;}#sidebar-filler{background-color:#F1F1F1;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#e0e0e0;background-color:#fff;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#717171;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(35%);}#theme-choices{border-color:#ccc;background-color:#fff;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#eee;}@media (max-width:700px){#theme-picker{background:#fff;}}#all-types{background-color:#fff;}#all-types:hover{background-color:#f9f9f9;}.search-results .result-name span.alias{color:#000;}.search-results .result-name span.grey{color:#999;}#sidebar-toggle{background-color:#F1F1F1;}#sidebar-toggle:hover{background-color:#E0E0E0;}#source-sidebar{background-color:#F1F1F1;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#E0E0E0;}div.files>.selected{background-color:#fff;}.setting-line>.title{border-bottom-color:#D5D5D5;} \ No newline at end of file + body{background-color:white;color:black;}h1,h2,h3,h4{color:black;}h1.fqn{border-bottom-color:#D5D5D5;}h2,h3,h4{border-bottom-color:#DDDDDD;}.in-band{background-color:white;}.invisible{background:rgba(0,0,0,0);}.docblock code,.docblock-short code{background-color:#F5F5F5;}pre,.rustdoc.source .example-wrap{background-color:#F5F5F5;}.sidebar{background-color:#F1F1F1;}*{scrollbar-color:rgba(36,37,39,0.6) #e6e6e6;}.sidebar{scrollbar-color:rgba(36,37,39,0.6) #d9d9d9;}.logo-container.rust-logo>img{}::-webkit-scrollbar-track{background-color:#ecebeb;}::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar::-webkit-scrollbar-track{background-color:#dcdcdc;}.sidebar::-webkit-scrollbar-thumb{background-color:rgba(36,37,39,0.6);}.sidebar .current{background-color:#fff;}.source .sidebar{background-color:#fff;}.sidebar .location{border-color:#000;background-color:#fff;color:#333;}.sidebar .version{border-bottom-color:#DDD;}.sidebar-title{border-top-color:#777;border-bottom-color:#777;}.block a:hover{background:#F5F5F5;}.line-numbers span{color:#c67e2d;}.line-numbers .line-highlighted{background-color:#f6fdb0 !important;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom-color:#ddd;}.docblock table td,.docblock table th{border-color:#ddd;}.content .method .where,.content .fn .where,.content .where.fmt-newline{color:#4E4C4C;}.search-results a:hover{background-color:#ddd;}.search-results a:focus{color:#000 !important;background-color:#ccc;}.search-results a:focus span{color:#000 !important;}a.result-trait:focus{background-color:#c7b6ff;}a.result-traitalias:focus{background-color:#c7b6ff;}a.result-mod:focus,a.result-externcrate:focus{background-color:#afc6e4;}a.result-enum:focus{background-color:#b4d1b9;}a.result-struct:focus{background-color:#e7b1a0;}a.result-union:focus{background-color:#b7bd49;}a.result-fn:focus,a.result-method:focus,a.result-tymethod:focus{background-color:#c6afb3;}a.result-type:focus{background-color:#ffc891;}a.result-foreigntype:focus{background-color:#f5c4ff;}a.result-attr:focus,a.result-derive:focus,a.result-macro:focus{background-color:#8ce488;}a.result-constant:focus,a.result-static:focus{background-color:#c3e0ff;}a.result-primitive:focus{background-color:#9aecff;}a.result-keyword:focus{background-color:#f99650;}.content .item-info::before{color:#ccc;}.content span.enum,.content a.enum,.block a.current.enum{color:#508157;}.content span.struct,.content a.struct,.block a.current.struct{color:#ad448e;}.content span.type,.content a.type,.block a.current.type{color:#ba5d00;}.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype{color:#cd00e2;}.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro{color:#068000;}.content span.union,.content a.union,.block a.current.union{color:#767b27;}.content span.constant,.content a.constant,.block a.current.constant,.content span.static,.content a.static,.block a.current.static{color:#546e8a;}.content span.primitive,.content a.primitive,.block a.current.primitive{color:#2c8093;}.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod{color:#4d76ae;}.content span.trait,.content a.trait,.block a.current.trait{color:#7c5af3;}.content span.traitalias,.content a.traitalias,.block a.current.traitalias{color:#6841f1;}.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,.content .fnname{color:#9a6e31;}.content span.keyword,.content a.keyword,.block a.current.keyword{color:#de5249;}nav:not(.sidebar){border-bottom-color:#e0e0e0;}nav.main .current{border-top-color:#000;border-bottom-color:#000;}nav.main .separator{border:1px solid #000;}a{color:#000;}.docblock:not(.type-decl) a:not(.srclink):not(.test-arrow),.docblock-short a:not(.srclink):not(.test-arrow),.item-info a,#help a{color:#3873AD;}a.test-arrow{color:#f5f5f5;}details.rustdoc-toggle>summary.hideme>span,details.rustdoc-toggle>summary::before,details.undocumented>summary::before{color:#999;}#crate-search{color:#555;background-color:white;border-color:#e0e0e0;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input{color:#555;background-color:white;box-shadow:0 0 0 1px #e0e0e0,0 0 0 2px transparent;}.search-input:focus{border-color:#66afe9;}.search-input:disabled{background-color:#e6e6e6;}#crate-search+.search-input:focus{box-shadow:0 0 8px #078dd8;}.module-item .stab,.import-item .stab{color:#000;}.stab.unstable{background:#FFF5D6;border-color:#FFC600;}.stab.deprecated{background:#ffc4c4;border-color:#db7b7b;}.stab.portability{background:#F3DFFF;border-color:#b07bdb;}.stab.portability>code{background:none;}#help>div{background:#e9e9e9;border-color:#bfbfbf;}#help>div>span{border-bottom-color:#bfbfbf;}.since{color:grey;}.result-name .primitive>i,.result-name .keyword>i{color:black;}.line-numbers :target{background-color:transparent;}pre.rust .kw{color:#8959A8;}pre.rust .kw-2,pre.rust .prelude-ty{color:#4271AE;}pre.rust .number,pre.rust .string{color:#718C00;}pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,pre.rust .attribute .ident{color:#C82829;}pre.rust .comment{color:#8E908C;}pre.rust .doccomment{color:#4D4D4C;}pre.rust .macro,pre.rust .macro-nonterminal{color:#3E999F;}pre.rust .lifetime{color:#B76514;}pre.rust .question-mark{color:#ff9011;}.example-wrap>pre.line-number{border-color:#c7c7c7;}a.test-arrow{background-color:rgba(78,139,202,0.2);}a.test-arrow:hover{background-color:#4e8bca;}.toggle-label,.code-attribute{color:#999;}:target,:target>*{background:#FDFFD3;}:target{border-right:3px solid #ffb44c;}pre.compile_fail{border-left:2px solid rgba(255,0,0,.5);}pre.compile_fail:hover,.information:hover+pre.compile_fail{border-left:2px solid #f00;}pre.should_panic{border-left:2px solid rgba(255,0,0,.5);}pre.should_panic:hover,.information:hover+pre.should_panic{border-left:2px solid #f00;}pre.ignore{border-left:2px solid rgba(255,142,0,.6);}pre.ignore:hover,.information:hover+pre.ignore{border-left:2px solid #ff9200;}.tooltip.compile_fail{color:rgba(255,0,0,.5);}.information>.compile_fail:hover{color:#f00;}.tooltip.should_panic{color:rgba(255,0,0,.5);}.information>.should_panic:hover{color:#f00;}.tooltip.ignore{color:rgba(255,142,0,.6);}.information>.ignore:hover{color:#ff9200;}.search-failed a{color:#0089ff;}.tooltip::after{background-color:#000;color:#fff;}.tooltip::before{border-color:transparent black transparent transparent;}.notable-traits-tooltiptext{background-color:#eee;border-color:#999;}.notable-traits-tooltiptext .notable{border-bottom-color:#DDDDDD;}#titles>button:not(.selected){background-color:#e6e6e6;border-top-color:#e6e6e6;}#titles>button:hover,#titles>button.selected{background-color:#ffffff;border-top-color:#0089ff;}#titles>button>div.count{color:#888;}@media (max-width:700px){.sidebar-menu{background-color:#F1F1F1;border-bottom-color:#e0e0e0;border-right-color:#e0e0e0;}.sidebar-elems{background-color:#F1F1F1;border-right-color:#000;}#sidebar-filler{background-color:#F1F1F1;border-bottom-color:#e0e0e0;}}kbd{color:#000;background-color:#fafbfc;border-color:#d1d5da;border-bottom-color:#c6cbd1;box-shadow-color:#c6cbd1;}#theme-picker,#settings-menu,#help-button{border-color:#e0e0e0;background-color:#fff;}#theme-picker:hover,#theme-picker:focus,#settings-menu:hover,#settings-menu:focus,#help-button:hover,#help-button:focus{border-color:#717171;}#copy-path{color:#999;}#copy-path>img{filter:invert(50%);}#copy-path:hover>img{filter:invert(35%);}#theme-choices{border-color:#ccc;background-color:#fff;}#theme-choices>button:not(:first-child){border-top-color:#e0e0e0;}#theme-choices>button:hover,#theme-choices>button:focus{background-color:#eee;}@media (max-width:700px){#theme-picker{background:#fff;}}#all-types{background-color:#fff;}#all-types:hover{background-color:#f9f9f9;}.search-results .result-name span.alias{color:#000;}.search-results .result-name span.grey{color:#999;}#sidebar-toggle{background-color:#F1F1F1;}#sidebar-toggle:hover{background-color:#E0E0E0;}#source-sidebar{background-color:#F1F1F1;}#source-sidebar>.title{border-bottom-color:#ccc;}div.files>a:hover,div.name:hover{background-color:#E0E0E0;}div.files>.selected{background-color:#fff;}.setting-line>.title{border-bottom-color:#D5D5D5;} \ No newline at end of file diff --git a/main.js b/main.js index a4d3fe44..f3655397 100644 --- a/main.js +++ b/main.js @@ -1,4 +1,4 @@ -if(!String.prototype.startsWith){String.prototype.startsWith=function(searchString,position){position=position||0;return this.indexOf(searchString,position)===position}}if(!String.prototype.endsWith){String.prototype.endsWith=function(suffix,length){var l=length||this.length;return this.indexOf(suffix,l-suffix.length)!==-1}}if(!DOMTokenList.prototype.add){DOMTokenList.prototype.add=function(className){if(className&&!hasClass(this,className)){if(this.className&&this.className.length>0){this.className+=" "+className}else{this.className=className}}}}if(!DOMTokenList.prototype.remove){DOMTokenList.prototype.remove=function(className){if(className&&this.className){this.className=(" "+this.className+" ").replace(" "+className+" "," ").trim()}}}(function(){var rustdocVars=document.getElementById("rustdoc-vars");if(rustdocVars){window.rootPath=rustdocVars.attributes["data-root-path"].value;window.currentCrate=rustdocVars.attributes["data-current-crate"].value;window.searchJS=rustdocVars.attributes["data-search-js"].value;window.searchIndexJS=rustdocVars.attributes["data-search-index-js"].value}var sidebarVars=document.getElementById("sidebar-vars");if(sidebarVars){window.sidebarCurrent={name:sidebarVars.attributes["data-name"].value,ty:sidebarVars.attributes["data-ty"].value,relpath:sidebarVars.attributes["data-relpath"].value,}}}());function getVirtualKey(ev){if("key"in ev&&typeof ev.key!="undefined"){return ev.key}var c=ev.charCode||ev.keyCode;if(c==27){return"Escape"}return String.fromCharCode(c)}var THEME_PICKER_ELEMENT_ID="theme-picker";var THEMES_ELEMENT_ID="theme-choices";function getThemesElement(){return document.getElementById(THEMES_ELEMENT_ID)}function getThemePickerElement(){return document.getElementById(THEME_PICKER_ELEMENT_ID)}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function showThemeButtonState(){var themePicker=getThemePickerElement();var themeChoices=getThemesElement();themeChoices.style.display="block";themePicker.style.borderBottomRightRadius="0";themePicker.style.borderBottomLeftRadius="0"}function hideThemeButtonState(){var themePicker=getThemePickerElement();var themeChoices=getThemesElement();themeChoices.style.display="none";themePicker.style.borderBottomRightRadius="3px";themePicker.style.borderBottomLeftRadius="3px"}(function(){var themeChoices=getThemesElement();var themePicker=getThemePickerElement();var availableThemes=["ayu","dark","light"];function switchThemeButtonState(){if(themeChoices.style.display==="block"){hideThemeButtonState()}else{showThemeButtonState()}}function handleThemeButtonsBlur(e){var active=document.activeElement;var related=e.relatedTarget;if(active.id!==THEME_PICKER_ELEMENT_ID&&(!active.parentNode||active.parentNode.id!==THEMES_ELEMENT_ID)&&(!related||(related.id!==THEME_PICKER_ELEMENT_ID&&(!related.parentNode||related.parentNode.id!==THEMES_ELEMENT_ID)))){hideThemeButtonState()}}themePicker.onclick=switchThemeButtonState;themePicker.onblur=handleThemeButtonsBlur;availableThemes.forEach(function(item){var but=document.createElement("button");but.textContent=item;but.onclick=function(){switchTheme(window.currentTheme,window.mainTheme,item,true);useSystemTheme(false)};but.onblur=handleThemeButtonsBlur;themeChoices.appendChild(but)})}());(function(){"use strict";window.searchState={loadingText:"Loading search results...",input:document.getElementsByClassName("search-input")[0],outputElement:function(){return document.getElementById("search")},title:document.title,titleBeforeSearch:document.title,timeout:null,currentTab:0,focusedByTab:[null,null,null],clearInputTimeout:function(){if(searchState.timeout!==null){clearTimeout(searchState.timeout);searchState.timeout=null}},focus:function(){searchState.input.focus()},defocus:function(){searchState.input.blur()},showResults:function(search){if(search===null||typeof search==='undefined'){search=searchState.outputElement()}addClass(main,"hidden");removeClass(search,"hidden");searchState.mouseMovedAfterSearch=false;document.title=searchState.title},hideResults:function(search){if(search===null||typeof search==='undefined'){search=searchState.outputElement()}addClass(search,"hidden");removeClass(main,"hidden");document.title=searchState.titleBeforeSearch;if(searchState.browserSupportsHistoryApi()){history.replaceState("",window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}},getQueryStringParams:function(){var params={};window.location.search.substring(1).split("&").map(function(s){var pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params},putBackSearch:function(search_input){var search=searchState.outputElement();if(search_input.value!==""&&hasClass(search,"hidden")){searchState.showResults(search);if(searchState.browserSupportsHistoryApi()){var extra="?search="+encodeURIComponent(search_input.value);history.replaceState(search_input.value,"",getNakedUrl()+extra+window.location.hash)}document.title=searchState.title}},browserSupportsHistoryApi:function(){return window.history&&typeof window.history.pushState==="function"},setup:function(){var search_input=searchState.input;if(!searchState.input){return}function loadScript(url){var script=document.createElement('script');script.src=url;document.head.append(script)}var searchLoaded=false;function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(window.searchJS);loadScript(window.searchIndexJS)}}search_input.addEventListener("focus",function(){searchState.putBackSearch(this);search_input.origPlaceholder=searchState.input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});search_input.addEventListener("blur",function(){search_input.placeholder=searchState.input.origPlaceholder});search_input.removeAttribute('disabled');searchState.addCrateDropdown(window.ALL_CRATES);var params=searchState.getQueryStringParams();if(params.search!==undefined){var search=searchState.outputElement();search.innerHTML="

"+searchState.loadingText+"

";searchState.showResults(search);loadSearch()}},addCrateDropdown:function(crates){var elem=document.getElementById("crate-search");if(!elem){return}var savedCrate=getSettingValue("saved-filter-crate");for(var i=0,len=crates.length;i0){return tmp}}return null}function showSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){addClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];if(sidebar){addClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(!filler){var div=document.createElement("div");div.id="sidebar-filler";sidebar.appendChild(div)}}}function hideSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){removeClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(filler){filler.remove()}document.getElementsByTagName("body")[0].style.marginTop=""}var toggleAllDocsId="toggle-all-docs";var main=document.getElementById("main");var savedHash="";function handleHashes(ev){var elem;var search=searchState.outputElement();if(ev!==null&&search&&!hasClass(search,"hidden")&&ev.newURL){searchState.hideResults(search);var hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(searchState.browserSupportsHistoryApi()){history.replaceState(hash,"",getNakedUrl()+window.location.search+"#"+hash)}elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}if(savedHash!==window.location.hash){savedHash=window.location.hash;if(savedHash.length===0){return}expandSection(savedHash.slice(1))}}function onHashChange(ev){hideSidebar();handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function getHelpElement(build){if(build){buildHelperPopup()}return document.getElementById("help")}function displayHelp(display,ev,help){if(display){help=help?help:getHelpElement(true);if(hasClass(help,"hidden")){ev.preventDefault();removeClass(help,"hidden");addClass(document.body,"blur")}}else{help=help?help:getHelpElement(false);if(help&&!hasClass(help,"hidden")){ev.preventDefault();addClass(help,"hidden");removeClass(document.body,"blur")}}}function handleEscape(ev){var help=getHelpElement(false);var search=searchState.outputElement();if(help&&!hasClass(help,"hidden")){displayHelp(false,ev,help)}else if(search&&!hasClass(search,"hidden")){searchState.clearInputTimeout();ev.preventDefault();searchState.hideResults(search)}searchState.defocus();hideThemeButtonState()}var disableShortcuts=getSettingValue("disable-shortcuts")==="true";function handleShortcut(ev){if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":displayHelp(false,ev);ev.preventDefault();searchState.focus();break;case"+":case"-":ev.preventDefault();toggleAllDocs();break;case"?":displayHelp(true,ev);break;case"t":case"T":displayHelp(false,ev);ev.preventDefault();var themePicker=getThemePickerElement();themePicker.click();themePicker.focus();break;default:if(getThemePickerElement().parentNode.contains(ev.target)){handleThemeKeyDown(ev)}}}}function handleThemeKeyDown(ev){var active=document.activeElement;var themes=getThemesElement();switch(getVirtualKey(ev)){case"ArrowUp":ev.preventDefault();if(active.previousElementSibling&&ev.target.id!==THEME_PICKER_ELEMENT_ID){active.previousElementSibling.focus()}else{showThemeButtonState();themes.lastElementChild.focus()}break;case"ArrowDown":ev.preventDefault();if(active.nextElementSibling&&ev.target.id!==THEME_PICKER_ELEMENT_ID){active.nextElementSibling.focus()}else{showThemeButtonState();themes.firstElementChild.focus()}break;case"Enter":case"Return":case"Space":if(ev.target.id===THEME_PICKER_ELEMENT_ID&&themes.style.display==="none"){ev.preventDefault();showThemeButtonState();themes.firstElementChild.focus()}break;case"Home":ev.preventDefault();themes.firstElementChild.focus();break;case"End":ev.preventDefault();themes.lastElementChild.focus();break}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);(function(){var x=document.getElementsByClassName("version-selector");if(x.length>0){x[0].onchange=function(){var i,match,url=document.location.href,stripped="",len=window.rootPath.match(/\.\.\//g).length+1;for(i=0;i"+""+"
"+code.outerHTML+"
";list.appendChild(display)}}};if(window.pending_implementors){window.register_implementors(window.pending_implementors)}function labelForToggleButton(sectionIsCollapsed){if(sectionIsCollapsed){return"+"}return"\u2212"}function toggleAllDocs(){var innerToggle=document.getElementById(toggleAllDocsId);if(!innerToggle){return}var sectionIsCollapsed=false;if(hasClass(innerToggle,"will-expand")){removeClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("rustdoc-toggle"),function(e){if(!hasClass(e,"type-contents-toggle")){e.open=true}});innerToggle.title="collapse all docs"}else{addClass(innerToggle,"will-expand");onEachLazy(document.getElementsByClassName("rustdoc-toggle"),function(e){if(e.parentNode.id!=="main"||(!hasClass(e,"implementors-toggle")&&!hasClass(e,"type-contents-toggle"))){e.open=false}});sectionIsCollapsed=true;innerToggle.title="expand all docs"}innerToggle.children[0].innerText=labelForToggleButton(sectionIsCollapsed)}function insertAfter(newNode,referenceNode){referenceNode.parentNode.insertBefore(newNode,referenceNode.nextSibling)}(function(){var toggles=document.getElementById(toggleAllDocsId);if(toggles){toggles.onclick=toggleAllDocs}var hideMethodDocs=getSettingValue("auto-hide-method-docs")==="true";var hideImplementors=getSettingValue("auto-collapse-implementors")!=="false";var hideImplementations=getSettingValue("auto-hide-trait-implementations")!=="false";var hideLargeItemContents=getSettingValue("auto-hide-large-items")!=="false";function openImplementors(id){var list=document.getElementById(id);if(list!==null){onEachLazy(list.getElementsByClassName("implementors-toggle"),function(e){e.open=true})}}if(!hideImplementations){openImplementors("trait-implementations-list");openImplementors("blanket-implementations-list")}if(!hideImplementors){openImplementors("implementors-list")}onEachLazy(document.getElementsByClassName("rustdoc-toggle"),function(e){if(!hideLargeItemContents&&hasClass(e,"type-contents-toggle")){e.open=true}if(hideMethodDocs&&hasClass(e,"method-toggle")){e.open=false}});var pageId=getPageId();if(pageId!==null){expandSection(pageId)}}());(function(){var lineNumbersFunc=function(){};if(getSettingValue("line-numbers")==="true"){lineNumbersFunc=function(x){var count=x.textContent.split("\n").length;var elems=[];for(var i=0;i0){this.className+=" "+className}else{this.className=className}}}}if(!DOMTokenList.prototype.remove){DOMTokenList.prototype.remove=function(className){if(className&&this.className){this.className=(" "+this.className+" ").replace(" "+className+" "," ").trim()}}}(function(){var rustdocVars=document.getElementById("rustdoc-vars");if(rustdocVars){window.rootPath=rustdocVars.attributes["data-root-path"].value;window.currentCrate=rustdocVars.attributes["data-current-crate"].value;window.searchJS=rustdocVars.attributes["data-search-js"].value;window.searchIndexJS=rustdocVars.attributes["data-search-index-js"].value}var sidebarVars=document.getElementById("sidebar-vars");if(sidebarVars){window.sidebarCurrent={name:sidebarVars.attributes["data-name"].value,ty:sidebarVars.attributes["data-ty"].value,relpath:sidebarVars.attributes["data-relpath"].value,}}}());function getVirtualKey(ev){if("key"in ev&&typeof ev.key!="undefined"){return ev.key}var c=ev.charCode||ev.keyCode;if(c==27){return"Escape"}return String.fromCharCode(c)}var THEME_PICKER_ELEMENT_ID="theme-picker";var THEMES_ELEMENT_ID="theme-choices";function getThemesElement(){return document.getElementById(THEMES_ELEMENT_ID)}function getThemePickerElement(){return document.getElementById(THEME_PICKER_ELEMENT_ID)}function getNakedUrl(){return window.location.href.split("?")[0].split("#")[0]}function showThemeButtonState(){var themePicker=getThemePickerElement();var themeChoices=getThemesElement();themeChoices.style.display="block";themePicker.style.borderBottomRightRadius="0";themePicker.style.borderBottomLeftRadius="0"}function hideThemeButtonState(){var themePicker=getThemePickerElement();var themeChoices=getThemesElement();themeChoices.style.display="none";themePicker.style.borderBottomRightRadius="3px";themePicker.style.borderBottomLeftRadius="3px"}(function(){var themeChoices=getThemesElement();var themePicker=getThemePickerElement();var availableThemes=["ayu","dark","light"];function switchThemeButtonState(){if(themeChoices.style.display==="block"){hideThemeButtonState()}else{showThemeButtonState()}}function handleThemeButtonsBlur(e){var active=document.activeElement;var related=e.relatedTarget;if(active.id!==THEME_PICKER_ELEMENT_ID&&(!active.parentNode||active.parentNode.id!==THEMES_ELEMENT_ID)&&(!related||(related.id!==THEME_PICKER_ELEMENT_ID&&(!related.parentNode||related.parentNode.id!==THEMES_ELEMENT_ID)))){hideThemeButtonState()}}themePicker.onclick=switchThemeButtonState;themePicker.onblur=handleThemeButtonsBlur;availableThemes.forEach(function(item){var but=document.createElement("button");but.textContent=item;but.onclick=function(){switchTheme(window.currentTheme,window.mainTheme,item,true);useSystemTheme(false)};but.onblur=handleThemeButtonsBlur;themeChoices.appendChild(but)})}());(function(){"use strict";window.searchState={loadingText:"Loading search results...",input:document.getElementsByClassName("search-input")[0],outputElement:function(){return document.getElementById("search")},title:document.title,titleBeforeSearch:document.title,timeout:null,currentTab:0,focusedByTab:[null,null,null],clearInputTimeout:function(){if(searchState.timeout!==null){clearTimeout(searchState.timeout);searchState.timeout=null}},focus:function(){searchState.input.focus()},defocus:function(){searchState.input.blur()},showResults:function(search){if(search===null||typeof search==='undefined'){search=searchState.outputElement()}addClass(main,"hidden");removeClass(search,"hidden");searchState.mouseMovedAfterSearch=false;document.title=searchState.title},hideResults:function(search){if(search===null||typeof search==='undefined'){search=searchState.outputElement()}addClass(search,"hidden");removeClass(main,"hidden");document.title=searchState.titleBeforeSearch;if(searchState.browserSupportsHistoryApi()){history.replaceState("",window.currentCrate+" - Rust",getNakedUrl()+window.location.hash)}},getQueryStringParams:function(){var params={};window.location.search.substring(1).split("&").map(function(s){var pair=s.split("=");params[decodeURIComponent(pair[0])]=typeof pair[1]==="undefined"?null:decodeURIComponent(pair[1])});return params},putBackSearch:function(search_input){var search=searchState.outputElement();if(search_input.value!==""&&hasClass(search,"hidden")){searchState.showResults(search);if(searchState.browserSupportsHistoryApi()){var extra="?search="+encodeURIComponent(search_input.value);history.replaceState(search_input.value,"",getNakedUrl()+extra+window.location.hash)}document.title=searchState.title}},browserSupportsHistoryApi:function(){return window.history&&typeof window.history.pushState==="function"},setup:function(){var search_input=searchState.input;if(!searchState.input){return}function loadScript(url){var script=document.createElement('script');script.src=url;document.head.append(script)}var searchLoaded=false;function loadSearch(){if(!searchLoaded){searchLoaded=true;loadScript(window.searchJS);loadScript(window.searchIndexJS)}}search_input.addEventListener("focus",function(){searchState.putBackSearch(this);search_input.origPlaceholder=searchState.input.placeholder;search_input.placeholder="Type your search here.";loadSearch()});search_input.addEventListener("blur",function(){search_input.placeholder=searchState.input.origPlaceholder});search_input.removeAttribute('disabled');searchState.addCrateDropdown(window.ALL_CRATES);var params=searchState.getQueryStringParams();if(params.search!==undefined){var search=searchState.outputElement();search.innerHTML="

"+searchState.loadingText+"

";searchState.showResults(search);loadSearch()}},addCrateDropdown:function(crates){var elem=document.getElementById("crate-search");if(!elem){return}var savedCrate=getSettingValue("saved-filter-crate");for(var i=0,len=crates.length;i0){return tmp}}return null}function showSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){addClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];if(sidebar){addClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(!filler){var div=document.createElement("div");div.id="sidebar-filler";sidebar.appendChild(div)}}}function hideSidebar(){var elems=document.getElementsByClassName("sidebar-elems")[0];if(elems){removeClass(elems,"show-it")}var sidebar=document.getElementsByClassName("sidebar")[0];removeClass(sidebar,"mobile");var filler=document.getElementById("sidebar-filler");if(filler){filler.remove()}document.getElementsByTagName("body")[0].style.marginTop=""}var toggleAllDocsId="toggle-all-docs";var main=document.getElementById("main");var savedHash="";function handleHashes(ev){var elem;var search=searchState.outputElement();if(ev!==null&&search&&!hasClass(search,"hidden")&&ev.newURL){searchState.hideResults(search);var hash=ev.newURL.slice(ev.newURL.indexOf("#")+1);if(searchState.browserSupportsHistoryApi()){history.replaceState(hash,"",getNakedUrl()+window.location.search+"#"+hash)}elem=document.getElementById(hash);if(elem){elem.scrollIntoView()}}if(savedHash!==window.location.hash){savedHash=window.location.hash;if(savedHash.length===0){return}expandSection(savedHash.slice(1))}}function onHashChange(ev){hideSidebar();handleHashes(ev)}function openParentDetails(elem){while(elem){if(elem.tagName==="DETAILS"){elem.open=true}elem=elem.parentNode}}function expandSection(id){openParentDetails(document.getElementById(id))}function getHelpElement(build){if(build){buildHelperPopup()}return document.getElementById("help")}function displayHelp(display,ev,help){if(display){help=help?help:getHelpElement(true);if(hasClass(help,"hidden")){ev.preventDefault();removeClass(help,"hidden");addClass(document.body,"blur")}}else{help=help?help:getHelpElement(false);if(help&&!hasClass(help,"hidden")){ev.preventDefault();addClass(help,"hidden");removeClass(document.body,"blur")}}}function handleEscape(ev){var help=getHelpElement(false);var search=searchState.outputElement();if(help&&!hasClass(help,"hidden")){displayHelp(false,ev,help)}else if(search&&!hasClass(search,"hidden")){searchState.clearInputTimeout();ev.preventDefault();searchState.hideResults(search)}searchState.defocus();hideThemeButtonState()}var disableShortcuts=getSettingValue("disable-shortcuts")==="true";function handleShortcut(ev){if(ev.ctrlKey||ev.altKey||ev.metaKey||disableShortcuts){return}if(document.activeElement.tagName==="INPUT"){switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break}}else{switch(getVirtualKey(ev)){case"Escape":handleEscape(ev);break;case"s":case"S":displayHelp(false,ev);ev.preventDefault();searchState.focus();break;case"+":case"-":ev.preventDefault();toggleAllDocs();break;case"?":displayHelp(true,ev);break;case"t":case"T":displayHelp(false,ev);ev.preventDefault();var themePicker=getThemePickerElement();themePicker.click();themePicker.focus();break;default:if(getThemePickerElement().parentNode.contains(ev.target)){handleThemeKeyDown(ev)}}}}function handleThemeKeyDown(ev){var active=document.activeElement;var themes=getThemesElement();switch(getVirtualKey(ev)){case"ArrowUp":ev.preventDefault();if(active.previousElementSibling&&ev.target.id!==THEME_PICKER_ELEMENT_ID){active.previousElementSibling.focus()}else{showThemeButtonState();themes.lastElementChild.focus()}break;case"ArrowDown":ev.preventDefault();if(active.nextElementSibling&&ev.target.id!==THEME_PICKER_ELEMENT_ID){active.nextElementSibling.focus()}else{showThemeButtonState();themes.firstElementChild.focus()}break;case"Enter":case"Return":case"Space":if(ev.target.id===THEME_PICKER_ELEMENT_ID&&themes.style.display==="none"){ev.preventDefault();showThemeButtonState();themes.firstElementChild.focus()}break;case"Home":ev.preventDefault();themes.firstElementChild.focus();break;case"End":ev.preventDefault();themes.lastElementChild.focus();break}}document.addEventListener("keypress",handleShortcut);document.addEventListener("keydown",handleShortcut);(function(){var x=document.getElementsByClassName("version-selector");if(x.length>0){x[0].onchange=function(){var i,match,url=document.location.href,stripped="",len=window.rootPath.match(/\.\.\//g).length+1;for(i=0;i .in-band > .trait").textContent;var baseIdName="impl-"+traitName+"-";var libs=Object.getOwnPropertyNames(imp);for(var i=0,llength=libs.length;ithe rustdoc book.";var container=document.createElement("div");var shortcuts=[["?","Show this help dialog"],["S","Focus the search field"],["T","Focus the theme picker menu"],["↑","Move up in search results"],["↓","Move down in search results"],["← / →","Switch result tab (when results focused)"],["⏎","Go to active search result"],["+","Expand all sections"],["-","Collapse all sections"],].map(function(x){return"
"+x[0].split(" ").map(function(y,index){return(index&1)===0?""+y+"":" "+y+" "}).join("")+"
"+x[1]+"
"}).join("");var div_shortcuts=document.createElement("div");addClass(div_shortcuts,"shortcuts");div_shortcuts.innerHTML="

Keyboard Shortcuts

"+shortcuts+"
";var infos=["Prefix searches with a type followed by a colon (e.g., fn:) to \ restrict the search to a given item kind.","Accepted kinds are: fn, mod, struct, \ enum, trait, type, macro, \ diff --git a/mcaptcha/all.html b/mcaptcha/all.html index f051b01f..c8359204 100644 --- a/mcaptcha/all.html +++ b/mcaptcha/all.html @@ -1,5 +1,5 @@ -List of all items in this crate - -

List of all items[−] +List of all items in this crate

List of all items[−] -

Structs

Enums

Macros

Functions

Typedefs

Constants

\ No newline at end of file +

Structs

Enums

Macros

Functions

Typedefs

Constants

+ + \ No newline at end of file diff --git a/mcaptcha/api/index.html b/mcaptcha/api/index.html index 8db7f5c7..b8ebfc1e 100644 --- a/mcaptcha/api/index.html +++ b/mcaptcha/api/index.html @@ -1,4 +1,4 @@ -mcaptcha::api - Rust - -

Module mcaptcha::api[−][src]

Modules

-
v1
\ No newline at end of file +mcaptcha::api - Rust

Module mcaptcha::api[−][src]

Modules

+
v1
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/delete/fn.services.html b/mcaptcha/api/v1/account/delete/fn.services.html index d3c7ec5c..bdafff3e 100644 --- a/mcaptcha/api/v1/account/delete/fn.services.html +++ b/mcaptcha/api/v1/account/delete/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account::delete - Rust - -

Function mcaptcha::api::v1::account::delete::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account::delete - Rust

Function mcaptcha::api::v1::account::delete::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/delete/index.html b/mcaptcha/api/v1/account/delete/index.html index 1cdbf812..2e95da1f 100644 --- a/mcaptcha/api/v1/account/delete/index.html +++ b/mcaptcha/api/v1/account/delete/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::account::delete - Rust - -

Module mcaptcha::api::v1::account::delete[−][src]

Modules

-
runners

Structs

-
delete_account

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::account::delete - Rust

Module mcaptcha::api::v1::account::delete[−][src]

Modules

+
runners

Structs

+
delete_account

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/delete/runners/fn.delete_user.html b/mcaptcha/api/v1/account/delete/runners/fn.delete_user.html index ba74ca00..023e3c90 100644 --- a/mcaptcha/api/v1/account/delete/runners/fn.delete_user.html +++ b/mcaptcha/api/v1/account/delete/runners/fn.delete_user.html @@ -1,3 +1,3 @@ -delete_user in mcaptcha::api::v1::account::delete::runners - Rust - -

Function mcaptcha::api::v1::account::delete::runners::delete_user[−][src]

pub async fn delete_user(name: &str, data: &AppData) -> Result<(), ServiceError>
\ No newline at end of file +delete_user in mcaptcha::api::v1::account::delete::runners - Rust

Function mcaptcha::api::v1::account::delete::runners::delete_user[−][src]

pub async fn delete_user(name: &str, data: &AppData) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/delete/runners/index.html b/mcaptcha/api/v1/account/delete/runners/index.html index cb9100de..0f440540 100644 --- a/mcaptcha/api/v1/account/delete/runners/index.html +++ b/mcaptcha/api/v1/account/delete/runners/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::account::delete::runners - Rust - -

Module mcaptcha::api::v1::account::delete::runners[−][src]

Functions

-
delete_user
\ No newline at end of file +mcaptcha::api::v1::account::delete::runners - Rust

Module mcaptcha::api::v1::account::delete::runners[−][src]

Functions

+
delete_user
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/delete/struct.delete_account.html b/mcaptcha/api/v1/account/delete/struct.delete_account.html index de84a3bf..8cb71232 100644 --- a/mcaptcha/api/v1/account/delete/struct.delete_account.html +++ b/mcaptcha/api/v1/account/delete/struct.delete_account.html @@ -1,106 +1,106 @@ -delete_account in mcaptcha::api::v1::account::delete - Rust - -

Struct mcaptcha::api::v1::account::delete::delete_account[−][src]

pub struct delete_account;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +delete_account in mcaptcha::api::v1::account::delete - Rust

Struct mcaptcha::api::v1::account::delete::delete_account[−][src]

pub struct delete_account;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/email/fn.services.html b/mcaptcha/api/v1/account/email/fn.services.html index 875c78a7..18c0fdb7 100644 --- a/mcaptcha/api/v1/account/email/fn.services.html +++ b/mcaptcha/api/v1/account/email/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account::email - Rust - -

Function mcaptcha::api::v1::account::email::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account::email - Rust

Function mcaptcha::api::v1::account::email::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/email/index.html b/mcaptcha/api/v1/account/email/index.html index d0627b8d..7ec33b18 100644 --- a/mcaptcha/api/v1/account/email/index.html +++ b/mcaptcha/api/v1/account/email/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::account::email - Rust - -

Module mcaptcha::api::v1::account::email[−][src]

Structs

-
Email
email_exists
set_email

update email

-

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::account::email - Rust

Module mcaptcha::api::v1::account::email[−][src]

Structs

+
Email
email_exists
set_email

update email

+

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/email/struct.Email.html b/mcaptcha/api/v1/account/email/struct.Email.html index 99536562..6bf2d037 100644 --- a/mcaptcha/api/v1/account/email/struct.Email.html +++ b/mcaptcha/api/v1/account/email/struct.Email.html @@ -1,118 +1,117 @@ -Email in mcaptcha::api::v1::account::email - Rust - -

Struct mcaptcha::api::v1::account::email::Email[−][src]

pub struct Email {
-    pub email: String,
-}

- Fields

email: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Email in mcaptcha::api::v1::account::email - Rust

Struct mcaptcha::api::v1::account::email::Email[−][src]

pub struct Email {
+    pub email: String,
+}

Fields

email: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/email/struct.email_exists.html b/mcaptcha/api/v1/account/email/struct.email_exists.html index 8f356051..4138f089 100644 --- a/mcaptcha/api/v1/account/email/struct.email_exists.html +++ b/mcaptcha/api/v1/account/email/struct.email_exists.html @@ -1,106 +1,106 @@ -email_exists in mcaptcha::api::v1::account::email - Rust - -

Struct mcaptcha::api::v1::account::email::email_exists[−][src]

pub struct email_exists;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +email_exists in mcaptcha::api::v1::account::email - Rust

Struct mcaptcha::api::v1::account::email::email_exists[−][src]

pub struct email_exists;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/email/struct.set_email.html b/mcaptcha/api/v1/account/email/struct.set_email.html index e5f05135..6f62b0c7 100644 --- a/mcaptcha/api/v1/account/email/struct.set_email.html +++ b/mcaptcha/api/v1/account/email/struct.set_email.html @@ -1,107 +1,107 @@ -set_email in mcaptcha::api::v1::account::email - Rust - -

Struct mcaptcha::api::v1::account::email::set_email[−][src]

pub struct set_email;
Expand description

update email

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +set_email in mcaptcha::api::v1::account::email - Rust

Struct mcaptcha::api::v1::account::email::set_email[−][src]

pub struct set_email;
Expand description

update email

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/fn.services.html b/mcaptcha/api/v1/account/fn.services.html index 049cb958..858b809f 100644 --- a/mcaptcha/api/v1/account/fn.services.html +++ b/mcaptcha/api/v1/account/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account - Rust - -

Function mcaptcha::api::v1::account::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account - Rust

Function mcaptcha::api::v1::account::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/index.html b/mcaptcha/api/v1/account/index.html index 89ab4eb1..9274bd3e 100644 --- a/mcaptcha/api/v1/account/index.html +++ b/mcaptcha/api/v1/account/index.html @@ -1,7 +1,7 @@ -mcaptcha::api::v1::account - Rust - -

Module mcaptcha::api::v1::account[−][src]

Re-exports

-
pub use super::auth;
pub use super::mcaptcha;

Modules

-
delete
email
password
routes
secret
username

Structs

-
AccountCheckPayload
AccountCheckResp

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::account - Rust

Module mcaptcha::api::v1::account[−][src]

Re-exports

+
pub use super::auth;
pub use super::mcaptcha;

Modules

+
delete
email
password
routes
secret
username

Structs

+
AccountCheckPayload
AccountCheckResp

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/fn.services.html b/mcaptcha/api/v1/account/password/fn.services.html index 02d03409..295dbb90 100644 --- a/mcaptcha/api/v1/account/password/fn.services.html +++ b/mcaptcha/api/v1/account/password/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account::password - Rust - -

Function mcaptcha::api::v1::account::password::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account::password - Rust

Function mcaptcha::api::v1::account::password::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/fn.update_password_runner.html b/mcaptcha/api/v1/account/password/fn.update_password_runner.html index d9934ea1..9499b4ec 100644 --- a/mcaptcha/api/v1/account/password/fn.update_password_runner.html +++ b/mcaptcha/api/v1/account/password/fn.update_password_runner.html @@ -1,3 +1,3 @@ -update_password_runner in mcaptcha::api::v1::account::password - Rust - -

Function mcaptcha::api::v1::account::password::update_password_runner[−][src]

async fn update_password_runner(
    user: &str, 
    update: UpdatePassword, 
    data: &Data
) -> Result<(), ServiceError>
\ No newline at end of file +update_password_runner in mcaptcha::api::v1::account::password - Rust

Function mcaptcha::api::v1::account::password::update_password_runner[−][src]

async fn update_password_runner(
    user: &str, 
    update: UpdatePassword, 
    data: &Data
) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/index.html b/mcaptcha/api/v1/account/password/index.html index d023bb90..f2a50978 100644 --- a/mcaptcha/api/v1/account/password/index.html +++ b/mcaptcha/api/v1/account/password/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::account::password - Rust - -

Module mcaptcha::api::v1::account::password[−][src]

Structs

-
ChangePasswordReqest
UpdatePassword
update_user_password

Functions

-
services
update_password_runner
\ No newline at end of file +mcaptcha::api::v1::account::password - Rust

Module mcaptcha::api::v1::account::password[−][src]

Structs

+
ChangePasswordReqest
UpdatePassword
update_user_password

Functions

+
services
update_password_runner
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/struct.ChangePasswordReqest.html b/mcaptcha/api/v1/account/password/struct.ChangePasswordReqest.html index 51e4c5b8..b2b143cc 100644 --- a/mcaptcha/api/v1/account/password/struct.ChangePasswordReqest.html +++ b/mcaptcha/api/v1/account/password/struct.ChangePasswordReqest.html @@ -1,121 +1,120 @@ -ChangePasswordReqest in mcaptcha::api::v1::account::password - Rust - -

Struct mcaptcha::api::v1::account::password::ChangePasswordReqest[−][src]

pub struct ChangePasswordReqest {
-    pub password: String,
-    pub new_password: String,
-    pub confirm_new_password: String,
-}

- Fields

password: Stringnew_password: Stringconfirm_new_password: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Performs the conversion.

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +ChangePasswordReqest in mcaptcha::api::v1::account::password - Rust

Struct mcaptcha::api::v1::account::password::ChangePasswordReqest[−][src]

pub struct ChangePasswordReqest {
+    pub password: String,
+    pub new_password: String,
+    pub confirm_new_password: String,
+}

Fields

password: Stringnew_password: Stringconfirm_new_password: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Performs the conversion.

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/struct.UpdatePassword.html b/mcaptcha/api/v1/account/password/struct.UpdatePassword.html index 5e8b211c..d6c34ca1 100644 --- a/mcaptcha/api/v1/account/password/struct.UpdatePassword.html +++ b/mcaptcha/api/v1/account/password/struct.UpdatePassword.html @@ -1,111 +1,110 @@ -UpdatePassword in mcaptcha::api::v1::account::password - Rust - -

Struct mcaptcha::api::v1::account::password::UpdatePassword[−][src]

pub struct UpdatePassword {
-    pub new_password: String,
-    pub confirm_new_password: String,
-}

- Fields

new_password: Stringconfirm_new_password: String

Trait Implementations

Performs the conversion.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +UpdatePassword in mcaptcha::api::v1::account::password - Rust

Struct mcaptcha::api::v1::account::password::UpdatePassword[−][src]

pub struct UpdatePassword {
+    pub new_password: String,
+    pub confirm_new_password: String,
+}

Fields

new_password: Stringconfirm_new_password: String

Trait Implementations

Performs the conversion.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/password/struct.update_user_password.html b/mcaptcha/api/v1/account/password/struct.update_user_password.html index 5f02f4bd..d22e5618 100644 --- a/mcaptcha/api/v1/account/password/struct.update_user_password.html +++ b/mcaptcha/api/v1/account/password/struct.update_user_password.html @@ -1,106 +1,106 @@ -update_user_password in mcaptcha::api::v1::account::password - Rust - -

Struct mcaptcha::api::v1::account::password::update_user_password[−][src]

pub struct update_user_password;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_user_password in mcaptcha::api::v1::account::password - Rust

Struct mcaptcha::api::v1::account::password::update_user_password[−][src]

pub struct update_user_password;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/routes/index.html b/mcaptcha/api/v1/account/routes/index.html index da10c086..f5a8cc0e 100644 --- a/mcaptcha/api/v1/account/routes/index.html +++ b/mcaptcha/api/v1/account/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::account::routes - Rust - -

Module mcaptcha::api::v1::account::routes[−][src]

Structs

-
Account
\ No newline at end of file +mcaptcha::api::v1::account::routes - Rust

Module mcaptcha::api::v1::account::routes[−][src]

Structs

+
Account
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/routes/struct.Account.html b/mcaptcha/api/v1/account/routes/struct.Account.html index 04bd552e..5fb78640 100644 --- a/mcaptcha/api/v1/account/routes/struct.Account.html +++ b/mcaptcha/api/v1/account/routes/struct.Account.html @@ -1,116 +1,115 @@ -Account in mcaptcha::api::v1::account::routes - Rust - -

Struct mcaptcha::api::v1::account::routes::Account[−][src]

pub struct Account {
-    pub delete: &'static str,
-    pub email_exists: &'static str,
-    pub get_secret: &'static str,
-    pub update_email: &'static str,
-    pub update_password: &'static str,
-    pub update_secret: &'static str,
-    pub username_exists: &'static str,
-    pub update_username: &'static str,
-}

- Fields

delete: &'static stremail_exists: &'static strget_secret: &'static strupdate_email: &'static strupdate_password: &'static strupdate_secret: &'static strusername_exists: &'static strupdate_username: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Account in mcaptcha::api::v1::account::routes - Rust

Struct mcaptcha::api::v1::account::routes::Account[−][src]

pub struct Account {
+    pub delete: &'static str,
+    pub email_exists: &'static str,
+    pub get_secret: &'static str,
+    pub update_email: &'static str,
+    pub update_password: &'static str,
+    pub update_secret: &'static str,
+    pub username_exists: &'static str,
+    pub update_username: &'static str,
+}

Fields

delete: &'static stremail_exists: &'static strget_secret: &'static strupdate_email: &'static strupdate_password: &'static strupdate_secret: &'static strusername_exists: &'static strupdate_username: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/secret/fn.services.html b/mcaptcha/api/v1/account/secret/fn.services.html index b83e4189..8564e4e5 100644 --- a/mcaptcha/api/v1/account/secret/fn.services.html +++ b/mcaptcha/api/v1/account/secret/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account::secret - Rust - -

Function mcaptcha::api::v1::account::secret::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account::secret - Rust

Function mcaptcha::api::v1::account::secret::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/secret/index.html b/mcaptcha/api/v1/account/secret/index.html index 54cb3a18..30c889a0 100644 --- a/mcaptcha/api/v1/account/secret/index.html +++ b/mcaptcha/api/v1/account/secret/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::account::secret - Rust - -

Module mcaptcha::api::v1::account::secret[−][src]

Structs

-
Secret
get_secret
update_user_secret

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::account::secret - Rust

Module mcaptcha::api::v1::account::secret[−][src]

Structs

+
Secret
get_secret
update_user_secret

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/secret/struct.Secret.html b/mcaptcha/api/v1/account/secret/struct.Secret.html index 4145af20..63c62f91 100644 --- a/mcaptcha/api/v1/account/secret/struct.Secret.html +++ b/mcaptcha/api/v1/account/secret/struct.Secret.html @@ -1,118 +1,117 @@ -Secret in mcaptcha::api::v1::account::secret - Rust - -

Struct mcaptcha::api::v1::account::secret::Secret[−][src]

pub struct Secret {
-    pub secret: String,
-}

- Fields

secret: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Secret in mcaptcha::api::v1::account::secret - Rust

Struct mcaptcha::api::v1::account::secret::Secret[−][src]

pub struct Secret {
+    pub secret: String,
+}

Fields

secret: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/secret/struct.get_secret.html b/mcaptcha/api/v1/account/secret/struct.get_secret.html index dfa31de3..41c2ab7f 100644 --- a/mcaptcha/api/v1/account/secret/struct.get_secret.html +++ b/mcaptcha/api/v1/account/secret/struct.get_secret.html @@ -1,106 +1,106 @@ -get_secret in mcaptcha::api::v1::account::secret - Rust - -

Struct mcaptcha::api::v1::account::secret::get_secret[−][src]

pub struct get_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_secret in mcaptcha::api::v1::account::secret - Rust

Struct mcaptcha::api::v1::account::secret::get_secret[−][src]

pub struct get_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/secret/struct.update_user_secret.html b/mcaptcha/api/v1/account/secret/struct.update_user_secret.html index 0ce8b29d..1559af85 100644 --- a/mcaptcha/api/v1/account/secret/struct.update_user_secret.html +++ b/mcaptcha/api/v1/account/secret/struct.update_user_secret.html @@ -1,106 +1,106 @@ -update_user_secret in mcaptcha::api::v1::account::secret - Rust - -

Struct mcaptcha::api::v1::account::secret::update_user_secret[−][src]

pub struct update_user_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_user_secret in mcaptcha::api::v1::account::secret - Rust

Struct mcaptcha::api::v1::account::secret::update_user_secret[−][src]

pub struct update_user_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/struct.AccountCheckPayload.html b/mcaptcha/api/v1/account/struct.AccountCheckPayload.html index 8cd8c7ea..593b289e 100644 --- a/mcaptcha/api/v1/account/struct.AccountCheckPayload.html +++ b/mcaptcha/api/v1/account/struct.AccountCheckPayload.html @@ -1,118 +1,117 @@ -AccountCheckPayload in mcaptcha::api::v1::account - Rust - -

Struct mcaptcha::api::v1::account::AccountCheckPayload[−][src]

pub struct AccountCheckPayload {
-    pub val: String,
-}

- Fields

val: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +AccountCheckPayload in mcaptcha::api::v1::account - Rust

Struct mcaptcha::api::v1::account::AccountCheckPayload[−][src]

pub struct AccountCheckPayload {
+    pub val: String,
+}

Fields

val: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/struct.AccountCheckResp.html b/mcaptcha/api/v1/account/struct.AccountCheckResp.html index 853af015..e11d8023 100644 --- a/mcaptcha/api/v1/account/struct.AccountCheckResp.html +++ b/mcaptcha/api/v1/account/struct.AccountCheckResp.html @@ -1,118 +1,117 @@ -AccountCheckResp in mcaptcha::api::v1::account - Rust - -

Struct mcaptcha::api::v1::account::AccountCheckResp[−][src]

pub struct AccountCheckResp {
-    pub exists: bool,
-}

- Fields

exists: bool

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +AccountCheckResp in mcaptcha::api::v1::account - Rust

Struct mcaptcha::api::v1::account::AccountCheckResp[−][src]

pub struct AccountCheckResp {
+    pub exists: bool,
+}

Fields

exists: bool

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/fn.services.html b/mcaptcha/api/v1/account/username/fn.services.html index f1f0b2a4..8cbae14c 100644 --- a/mcaptcha/api/v1/account/username/fn.services.html +++ b/mcaptcha/api/v1/account/username/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::account::username - Rust - -

Function mcaptcha::api::v1::account::username::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::account::username - Rust

Function mcaptcha::api::v1::account::username::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/index.html b/mcaptcha/api/v1/account/username/index.html index 937c8140..3a7c2d65 100644 --- a/mcaptcha/api/v1/account/username/index.html +++ b/mcaptcha/api/v1/account/username/index.html @@ -1,7 +1,7 @@ -mcaptcha::api::v1::account::username - Rust - -

Module mcaptcha::api::v1::account::username[−][src]

Modules

-
runners

Structs

-
Username
set_username

update username

-
username_exists

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::account::username - Rust

Module mcaptcha::api::v1::account::username[−][src]

Modules

+
runners

Structs

+
Username
set_username

update username

+
username_exists

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/runners/fn.username_exists.html b/mcaptcha/api/v1/account/username/runners/fn.username_exists.html index d445dfa4..6cc9c38f 100644 --- a/mcaptcha/api/v1/account/username/runners/fn.username_exists.html +++ b/mcaptcha/api/v1/account/username/runners/fn.username_exists.html @@ -1,3 +1,3 @@ -username_exists in mcaptcha::api::v1::account::username::runners - Rust - -

Function mcaptcha::api::v1::account::username::runners::username_exists[−][src]

pub async fn username_exists(
    payload: &AccountCheckPayload, 
    data: &AppData
) -> Result<AccountCheckResp, ServiceError>
\ No newline at end of file +username_exists in mcaptcha::api::v1::account::username::runners - Rust

Function mcaptcha::api::v1::account::username::runners::username_exists[−][src]

pub async fn username_exists(
    payload: &AccountCheckPayload, 
    data: &AppData
) -> Result<AccountCheckResp, ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/runners/index.html b/mcaptcha/api/v1/account/username/runners/index.html index 9f818128..64656c9c 100644 --- a/mcaptcha/api/v1/account/username/runners/index.html +++ b/mcaptcha/api/v1/account/username/runners/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::account::username::runners - Rust - -

Module mcaptcha::api::v1::account::username::runners[−][src]

Functions

-
username_exists
\ No newline at end of file +mcaptcha::api::v1::account::username::runners - Rust

Module mcaptcha::api::v1::account::username::runners[−][src]

Functions

+
username_exists
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/struct.Username.html b/mcaptcha/api/v1/account/username/struct.Username.html index 4acf8b04..1bf69b41 100644 --- a/mcaptcha/api/v1/account/username/struct.Username.html +++ b/mcaptcha/api/v1/account/username/struct.Username.html @@ -1,118 +1,117 @@ -Username in mcaptcha::api::v1::account::username - Rust - -

Struct mcaptcha::api::v1::account::username::Username[−][src]

pub struct Username {
-    pub username: String,
-}

- Fields

username: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Username in mcaptcha::api::v1::account::username - Rust

Struct mcaptcha::api::v1::account::username::Username[−][src]

pub struct Username {
+    pub username: String,
+}

Fields

username: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/struct.set_username.html b/mcaptcha/api/v1/account/username/struct.set_username.html index 2201bdaa..ec9fdf24 100644 --- a/mcaptcha/api/v1/account/username/struct.set_username.html +++ b/mcaptcha/api/v1/account/username/struct.set_username.html @@ -1,107 +1,107 @@ -set_username in mcaptcha::api::v1::account::username - Rust - -

Struct mcaptcha::api::v1::account::username::set_username[−][src]

pub struct set_username;
Expand description

update username

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +set_username in mcaptcha::api::v1::account::username - Rust

Struct mcaptcha::api::v1::account::username::set_username[−][src]

pub struct set_username;
Expand description

update username

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/account/username/struct.username_exists.html b/mcaptcha/api/v1/account/username/struct.username_exists.html index 7ffda5b6..099b34db 100644 --- a/mcaptcha/api/v1/account/username/struct.username_exists.html +++ b/mcaptcha/api/v1/account/username/struct.username_exists.html @@ -1,106 +1,106 @@ -username_exists in mcaptcha::api::v1::account::username - Rust - -

Struct mcaptcha::api::v1::account::username::username_exists[−][src]

pub struct username_exists;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +username_exists in mcaptcha::api::v1::account::username - Rust

Struct mcaptcha::api::v1::account::username::username_exists[−][src]

pub struct username_exists;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/fn.services.html b/mcaptcha/api/v1/auth/fn.services.html index b908bff5..6f730238 100644 --- a/mcaptcha/api/v1/auth/fn.services.html +++ b/mcaptcha/api/v1/auth/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::auth - Rust - -

Function mcaptcha::api::v1::auth::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::auth - Rust

Function mcaptcha::api::v1::auth::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/index.html b/mcaptcha/api/v1/auth/index.html index 61c9a6ec..0837ad6c 100644 --- a/mcaptcha/api/v1/auth/index.html +++ b/mcaptcha/api/v1/auth/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::auth - Rust - -

Module mcaptcha::api::v1::auth[−][src]

Modules

-
routes
runners

Structs

-
login
register
signout

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::auth - Rust

Module mcaptcha::api::v1::auth[−][src]

Modules

+
routes
runners

Structs

+
login
register
signout

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/routes/index.html b/mcaptcha/api/v1/auth/routes/index.html index b4dbfe23..19b36ae4 100644 --- a/mcaptcha/api/v1/auth/routes/index.html +++ b/mcaptcha/api/v1/auth/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::auth::routes - Rust - -

Module mcaptcha::api::v1::auth::routes[−][src]

Structs

-
Auth
\ No newline at end of file +mcaptcha::api::v1::auth::routes - Rust

Module mcaptcha::api::v1::auth::routes[−][src]

Structs

+
Auth
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/routes/struct.Auth.html b/mcaptcha/api/v1/auth/routes/struct.Auth.html index bb532920..bed88c44 100644 --- a/mcaptcha/api/v1/auth/routes/struct.Auth.html +++ b/mcaptcha/api/v1/auth/routes/struct.Auth.html @@ -1,111 +1,110 @@ -Auth in mcaptcha::api::v1::auth::routes - Rust - -

Struct mcaptcha::api::v1::auth::routes::Auth[−][src]

pub struct Auth {
-    pub logout: &'static str,
-    pub login: &'static str,
-    pub register: &'static str,
-}

- Fields

logout: &'static strlogin: &'static strregister: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Auth in mcaptcha::api::v1::auth::routes - Rust

Struct mcaptcha::api::v1::auth::routes::Auth[−][src]

pub struct Auth {
+    pub logout: &'static str,
+    pub login: &'static str,
+    pub register: &'static str,
+}

Fields

logout: &'static strlogin: &'static strregister: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/fn.login_runner.html b/mcaptcha/api/v1/auth/runners/fn.login_runner.html index ea8db30f..672250fc 100644 --- a/mcaptcha/api/v1/auth/runners/fn.login_runner.html +++ b/mcaptcha/api/v1/auth/runners/fn.login_runner.html @@ -1,4 +1,4 @@ -login_runner in mcaptcha::api::v1::auth::runners - Rust - -

Function mcaptcha::api::v1::auth::runners::login_runner[−][src]

pub async fn login_runner(
    payload: Login, 
    data: &AppData
) -> Result<String, ServiceError>
Expand description

returns Ok(()) when everything checks out and the user is authenticated. Erros otherwise

-
\ No newline at end of file +login_runner in mcaptcha::api::v1::auth::runners - Rust

Function mcaptcha::api::v1::auth::runners::login_runner[−][src]

pub async fn login_runner(
    payload: Login, 
    data: &AppData
) -> Result<String, ServiceError>
Expand description

returns Ok(()) when everything checks out and the user is authenticated. Erros otherwise

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/fn.register_runner.html b/mcaptcha/api/v1/auth/runners/fn.register_runner.html index 53c89e37..7da06346 100644 --- a/mcaptcha/api/v1/auth/runners/fn.register_runner.html +++ b/mcaptcha/api/v1/auth/runners/fn.register_runner.html @@ -1,3 +1,3 @@ -register_runner in mcaptcha::api::v1::auth::runners - Rust - -

Function mcaptcha::api::v1::auth::runners::register_runner[−][src]

pub async fn register_runner(
    payload: &Register, 
    data: &AppData
) -> Result<(), ServiceError>
\ No newline at end of file +register_runner in mcaptcha::api::v1::auth::runners - Rust

Function mcaptcha::api::v1::auth::runners::register_runner[−][src]

pub async fn register_runner(
    payload: &Register, 
    data: &AppData
) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/index.html b/mcaptcha/api/v1/auth/runners/index.html index b4180f70..932e233a 100644 --- a/mcaptcha/api/v1/auth/runners/index.html +++ b/mcaptcha/api/v1/auth/runners/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::auth::runners - Rust - -

Module mcaptcha::api::v1::auth::runners[−][src]

Structs

-
Login
Password
Register

Functions

-
login_runner

returns Ok(()) when everything checks out and the user is authenticated. Erros otherwise

-
register_runner
\ No newline at end of file +mcaptcha::api::v1::auth::runners - Rust

Module mcaptcha::api::v1::auth::runners[−][src]

Structs

+
Login
Password
Register

Functions

+
login_runner

returns Ok(()) when everything checks out and the user is authenticated. Erros otherwise

+
register_runner
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/struct.Login.html b/mcaptcha/api/v1/auth/runners/struct.Login.html index e6e7f27f..47fdaccf 100644 --- a/mcaptcha/api/v1/auth/runners/struct.Login.html +++ b/mcaptcha/api/v1/auth/runners/struct.Login.html @@ -1,119 +1,118 @@ -Login in mcaptcha::api::v1::auth::runners - Rust - -

Struct mcaptcha::api::v1::auth::runners::Login[−][src]

pub struct Login {
-    pub login: String,
-    pub password: String,
-}

- Fields

login: Stringpassword: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Login in mcaptcha::api::v1::auth::runners - Rust

Struct mcaptcha::api::v1::auth::runners::Login[−][src]

pub struct Login {
+    pub login: String,
+    pub password: String,
+}

Fields

login: Stringpassword: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/struct.Password.html b/mcaptcha/api/v1/auth/runners/struct.Password.html index dd150f22..077d3664 100644 --- a/mcaptcha/api/v1/auth/runners/struct.Password.html +++ b/mcaptcha/api/v1/auth/runners/struct.Password.html @@ -1,118 +1,117 @@ -Password in mcaptcha::api::v1::auth::runners - Rust - -

Struct mcaptcha::api::v1::auth::runners::Password[−][src]

pub struct Password {
-    pub password: String,
-}

- Fields

password: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Password in mcaptcha::api::v1::auth::runners - Rust

Struct mcaptcha::api::v1::auth::runners::Password[−][src]

pub struct Password {
+    pub password: String,
+}

Fields

password: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/runners/struct.Register.html b/mcaptcha/api/v1/auth/runners/struct.Register.html index 96be34a5..f23c4020 100644 --- a/mcaptcha/api/v1/auth/runners/struct.Register.html +++ b/mcaptcha/api/v1/auth/runners/struct.Register.html @@ -1,121 +1,120 @@ -Register in mcaptcha::api::v1::auth::runners - Rust - -

Struct mcaptcha::api::v1::auth::runners::Register[−][src]

pub struct Register {
-    pub username: String,
-    pub password: String,
-    pub confirm_password: String,
-    pub email: Option<String>,
-}

- Fields

username: Stringpassword: Stringconfirm_password: Stringemail: Option<String>

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Register in mcaptcha::api::v1::auth::runners - Rust

Struct mcaptcha::api::v1::auth::runners::Register[−][src]

pub struct Register {
+    pub username: String,
+    pub password: String,
+    pub confirm_password: String,
+    pub email: Option<String>,
+}

Fields

username: Stringpassword: Stringconfirm_password: Stringemail: Option<String>

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/struct.login.html b/mcaptcha/api/v1/auth/struct.login.html index 9def3dbe..6db222e8 100644 --- a/mcaptcha/api/v1/auth/struct.login.html +++ b/mcaptcha/api/v1/auth/struct.login.html @@ -1,106 +1,106 @@ -login in mcaptcha::api::v1::auth - Rust - -

Struct mcaptcha::api::v1::auth::login[−][src]

pub struct login;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +login in mcaptcha::api::v1::auth - Rust

Struct mcaptcha::api::v1::auth::login[−][src]

pub struct login;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/struct.register.html b/mcaptcha/api/v1/auth/struct.register.html index 379018b8..69bf5e27 100644 --- a/mcaptcha/api/v1/auth/struct.register.html +++ b/mcaptcha/api/v1/auth/struct.register.html @@ -1,106 +1,106 @@ -register in mcaptcha::api::v1::auth - Rust - -

Struct mcaptcha::api::v1::auth::register[−][src]

pub struct register;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +register in mcaptcha::api::v1::auth - Rust

Struct mcaptcha::api::v1::auth::register[−][src]

pub struct register;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/auth/struct.signout.html b/mcaptcha/api/v1/auth/struct.signout.html index 0c04911f..64a9d5e0 100644 --- a/mcaptcha/api/v1/auth/struct.signout.html +++ b/mcaptcha/api/v1/auth/struct.signout.html @@ -1,106 +1,106 @@ -signout in mcaptcha::api::v1::auth - Rust - -

Struct mcaptcha::api::v1::auth::signout[−][src]

pub struct signout;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +signout in mcaptcha::api::v1::auth - Rust

Struct mcaptcha::api::v1::auth::signout[−][src]

pub struct signout;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/fn.services.html b/mcaptcha/api/v1/fn.services.html index 66f63d8f..54662d3a 100644 --- a/mcaptcha/api/v1/fn.services.html +++ b/mcaptcha/api/v1/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1 - Rust - -

Function mcaptcha::api::v1::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1 - Rust

Function mcaptcha::api::v1::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/index.html b/mcaptcha/api/v1/index.html index 0073778d..34692c52 100644 --- a/mcaptcha/api/v1/index.html +++ b/mcaptcha/api/v1/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1 - Rust - -

Module mcaptcha::api::v1[−][src]

Re-exports

-
pub use routes::ROUTES;

Modules

-
account
auth
mcaptcha
meta
notifications
pow
routes

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1 - Rust

Module mcaptcha::api::v1[−][src]

Re-exports

+
pub use routes::ROUTES;

Modules

+
account
auth
mcaptcha
meta
notifications
pow
routes

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/fn.add_mcaptcha_util.html b/mcaptcha/api/v1/mcaptcha/captcha/fn.add_mcaptcha_util.html index 008c2400..7d95b63c 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/fn.add_mcaptcha_util.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/fn.add_mcaptcha_util.html @@ -1,3 +1,3 @@ -add_mcaptcha_util in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Function mcaptcha::api::v1::mcaptcha::captcha::add_mcaptcha_util[−][src]

pub async fn add_mcaptcha_util(
    duration: u32, 
    description: &str, 
    data: &AppData, 
    id: &Identity
) -> Result<MCaptchaDetails, ServiceError>
\ No newline at end of file +add_mcaptcha_util in mcaptcha::api::v1::mcaptcha::captcha - Rust

Function mcaptcha::api::v1::mcaptcha::captcha::add_mcaptcha_util[−][src]

pub async fn add_mcaptcha_util(
    duration: u32, 
    description: &str, 
    data: &AppData, 
    id: &Identity
) -> Result<MCaptchaDetails, ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/fn.services.html b/mcaptcha/api/v1/mcaptcha/captcha/fn.services.html index 25d2d91b..55eadd31 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/fn.services.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Function mcaptcha::api::v1::mcaptcha::captcha::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::mcaptcha::captcha - Rust

Function mcaptcha::api::v1::mcaptcha::captcha::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/fn.update_token_helper.html b/mcaptcha/api/v1/mcaptcha/captcha/fn.update_token_helper.html index 546550b0..3d7b6890 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/fn.update_token_helper.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/fn.update_token_helper.html @@ -1,3 +1,3 @@ -update_token_helper in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Function mcaptcha::api::v1::mcaptcha::captcha::update_token_helper[−][src]

async fn update_token_helper(
    key: &str, 
    old_key: &str, 
    username: &str, 
    data: &AppData
) -> Result<(), Error>
\ No newline at end of file +update_token_helper in mcaptcha::api::v1::mcaptcha::captcha - Rust

Function mcaptcha::api::v1::mcaptcha::captcha::update_token_helper[−][src]

async fn update_token_helper(
    key: &str, 
    old_key: &str, 
    username: &str, 
    data: &AppData
) -> Result<(), Error>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/index.html b/mcaptcha/api/v1/mcaptcha/captcha/index.html index b6762f0d..99f126ac 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/index.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Module mcaptcha::api::v1::mcaptcha::captcha[−][src]

Modules

-
routes

Structs

-
DeleteCaptcha
MCaptchaDetails
MCaptchaID
StatsPayload
delete_mcaptcha
get_stats
update_token

Functions

-
add_mcaptcha_util
services
update_token_helper
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::captcha - Rust

Module mcaptcha::api::v1::mcaptcha::captcha[−][src]

Modules

+
routes

Structs

+
DeleteCaptcha
MCaptchaDetails
MCaptchaID
StatsPayload
delete_mcaptcha
get_stats
update_token

Functions

+
add_mcaptcha_util
services
update_token_helper
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/routes/index.html b/mcaptcha/api/v1/mcaptcha/captcha/routes/index.html index 6bfbe841..c1e2cf23 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/routes/index.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::mcaptcha::captcha::routes - Rust - -

Module mcaptcha::api::v1::mcaptcha::captcha::routes[−][src]

Structs

-
MCaptcha
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::captcha::routes - Rust

Module mcaptcha::api::v1::mcaptcha::captcha::routes[−][src]

Structs

+
MCaptcha
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/routes/struct.MCaptcha.html b/mcaptcha/api/v1/mcaptcha/captcha/routes/struct.MCaptcha.html index e03895c3..4f244e88 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/routes/struct.MCaptcha.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/routes/struct.MCaptcha.html @@ -1,111 +1,110 @@ -MCaptcha in mcaptcha::api::v1::mcaptcha::captcha::routes - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha[−][src]

pub struct MCaptcha {
-    pub delete: &'static str,
-    pub update_key: &'static str,
-    pub stats: &'static str,
-}

- Fields

delete: &'static strupdate_key: &'static strstats: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MCaptcha in mcaptcha::api::v1::mcaptcha::captcha::routes - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::routes::MCaptcha[−][src]

pub struct MCaptcha {
+    pub delete: &'static str,
+    pub update_key: &'static str,
+    pub stats: &'static str,
+}

Fields

delete: &'static strupdate_key: &'static strstats: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.DeleteCaptcha.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.DeleteCaptcha.html index 0cc9b355..f2b2714a 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.DeleteCaptcha.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.DeleteCaptcha.html @@ -1,119 +1,118 @@ -DeleteCaptcha in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha[−][src]

pub struct DeleteCaptcha {
-    pub key: String,
-    pub password: String,
-}

- Fields

key: Stringpassword: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +DeleteCaptcha in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::DeleteCaptcha[−][src]

pub struct DeleteCaptcha {
+    pub key: String,
+    pub password: String,
+}

Fields

key: Stringpassword: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaDetails.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaDetails.html index 0d6f1c12..0735428c 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaDetails.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaDetails.html @@ -1,119 +1,118 @@ -MCaptchaDetails in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails[−][src]

pub struct MCaptchaDetails {
-    pub name: String,
-    pub key: String,
-}

- Fields

name: Stringkey: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MCaptchaDetails in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::MCaptchaDetails[−][src]

pub struct MCaptchaDetails {
+    pub name: String,
+    pub key: String,
+}

Fields

name: Stringkey: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaID.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaID.html index 7297cf83..5df76487 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaID.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.MCaptchaID.html @@ -1,118 +1,117 @@ -MCaptchaID in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID[−][src]

pub struct MCaptchaID {
-    pub name: Option<String>,
-}

- Fields

name: Option<String>

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MCaptchaID in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::MCaptchaID[−][src]

pub struct MCaptchaID {
+    pub name: Option<String>,
+}

Fields

name: Option<String>

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.StatsPayload.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.StatsPayload.html index 03914a01..78fdffbe 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.StatsPayload.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.StatsPayload.html @@ -1,118 +1,117 @@ -StatsPayload in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::StatsPayload[−][src]

pub struct StatsPayload {
-    pub key: String,
-}

- Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +StatsPayload in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::StatsPayload[−][src]

pub struct StatsPayload {
+    pub key: String,
+}

Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.delete_mcaptcha.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.delete_mcaptcha.html index 46f3c294..57c03681 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.delete_mcaptcha.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.delete_mcaptcha.html @@ -1,106 +1,106 @@ -delete_mcaptcha in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha[−][src]

pub struct delete_mcaptcha;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +delete_mcaptcha in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::delete_mcaptcha[−][src]

pub struct delete_mcaptcha;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.get_stats.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.get_stats.html index 09c2b6b5..2caf5b05 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.get_stats.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.get_stats.html @@ -1,106 +1,106 @@ -get_stats in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::get_stats[−][src]

pub struct get_stats;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_stats in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::get_stats[−][src]

pub struct get_stats;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/captcha/struct.update_token.html b/mcaptcha/api/v1/mcaptcha/captcha/struct.update_token.html index 5a1c0059..97b3762c 100644 --- a/mcaptcha/api/v1/mcaptcha/captcha/struct.update_token.html +++ b/mcaptcha/api/v1/mcaptcha/captcha/struct.update_token.html @@ -1,106 +1,106 @@ -update_token in mcaptcha::api::v1::mcaptcha::captcha - Rust - -

Struct mcaptcha::api::v1::mcaptcha::captcha::update_token[−][src]

pub struct update_token;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_token in mcaptcha::api::v1::mcaptcha::captcha - Rust

Struct mcaptcha::api::v1::mcaptcha::captcha::update_token[−][src]

pub struct update_token;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/fn.services.html b/mcaptcha/api/v1/mcaptcha/duration/fn.services.html index 48654d70..99d67ae0 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/fn.services.html +++ b/mcaptcha/api/v1/mcaptcha/duration/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Function mcaptcha::api::v1::mcaptcha::duration::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::mcaptcha::duration - Rust

Function mcaptcha::api::v1::mcaptcha::duration::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/index.html b/mcaptcha/api/v1/mcaptcha/duration/index.html index 17d0c1d8..9338f5aa 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/index.html +++ b/mcaptcha/api/v1/mcaptcha/duration/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::mcaptcha::duration - Rust - -

Module mcaptcha::api::v1::mcaptcha::duration[−][src]

Modules

-
routes

Structs

-
GetDuration
GetDurationResp
UpdateDuration
get_duration
update_duration

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::duration - Rust

Module mcaptcha::api::v1::mcaptcha::duration[−][src]

Modules

+
routes

Structs

+
GetDuration
GetDurationResp
UpdateDuration
get_duration
update_duration

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/routes/index.html b/mcaptcha/api/v1/mcaptcha/duration/routes/index.html index 410e1310..2e0ae993 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/routes/index.html +++ b/mcaptcha/api/v1/mcaptcha/duration/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::mcaptcha::duration::routes - Rust - -

Module mcaptcha::api::v1::mcaptcha::duration::routes[−][src]

Structs

-
Duration
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::duration::routes - Rust

Module mcaptcha::api::v1::mcaptcha::duration::routes[−][src]

Structs

+
Duration
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/routes/struct.Duration.html b/mcaptcha/api/v1/mcaptcha/duration/routes/struct.Duration.html index 40ff1b92..1e454948 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/routes/struct.Duration.html +++ b/mcaptcha/api/v1/mcaptcha/duration/routes/struct.Duration.html @@ -1,110 +1,109 @@ -Duration in mcaptcha::api::v1::mcaptcha::duration::routes - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::routes::Duration[−][src]

pub struct Duration {
-    pub update: &'static str,
-    pub get: &'static str,
-}

- Fields

update: &'static strget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Duration in mcaptcha::api::v1::mcaptcha::duration::routes - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::routes::Duration[−][src]

pub struct Duration {
+    pub update: &'static str,
+    pub get: &'static str,
+}

Fields

update: &'static strget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/struct.GetDuration.html b/mcaptcha/api/v1/mcaptcha/duration/struct.GetDuration.html index ebb8b25f..11a6b69b 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/struct.GetDuration.html +++ b/mcaptcha/api/v1/mcaptcha/duration/struct.GetDuration.html @@ -1,111 +1,110 @@ -GetDuration in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::GetDuration[−][src]

pub struct GetDuration {
-    pub token: String,
-}

- Fields

token: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +GetDuration in mcaptcha::api::v1::mcaptcha::duration - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::GetDuration[−][src]

pub struct GetDuration {
+    pub token: String,
+}

Fields

token: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/struct.GetDurationResp.html b/mcaptcha/api/v1/mcaptcha/duration/struct.GetDurationResp.html index 9a18aa28..b7a77149 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/struct.GetDurationResp.html +++ b/mcaptcha/api/v1/mcaptcha/duration/struct.GetDurationResp.html @@ -1,111 +1,110 @@ -GetDurationResp in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::GetDurationResp[−][src]

pub struct GetDurationResp {
-    pub duration: i32,
-}

- Fields

duration: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +GetDurationResp in mcaptcha::api::v1::mcaptcha::duration - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::GetDurationResp[−][src]

pub struct GetDurationResp {
+    pub duration: i32,
+}

Fields

duration: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/struct.UpdateDuration.html b/mcaptcha/api/v1/mcaptcha/duration/struct.UpdateDuration.html index c6de60e1..d975a956 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/struct.UpdateDuration.html +++ b/mcaptcha/api/v1/mcaptcha/duration/struct.UpdateDuration.html @@ -1,112 +1,111 @@ -UpdateDuration in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::UpdateDuration[−][src]

pub struct UpdateDuration {
-    pub key: String,
-    pub duration: i32,
-}

- Fields

key: Stringduration: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +UpdateDuration in mcaptcha::api::v1::mcaptcha::duration - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::UpdateDuration[−][src]

pub struct UpdateDuration {
+    pub key: String,
+    pub duration: i32,
+}

Fields

key: Stringduration: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/struct.get_duration.html b/mcaptcha/api/v1/mcaptcha/duration/struct.get_duration.html index e9490a97..1f3d64b3 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/struct.get_duration.html +++ b/mcaptcha/api/v1/mcaptcha/duration/struct.get_duration.html @@ -1,106 +1,106 @@ -get_duration in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::get_duration[−][src]

pub struct get_duration;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_duration in mcaptcha::api::v1::mcaptcha::duration - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::get_duration[−][src]

pub struct get_duration;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/duration/struct.update_duration.html b/mcaptcha/api/v1/mcaptcha/duration/struct.update_duration.html index 2c44b9c7..ae8933c6 100644 --- a/mcaptcha/api/v1/mcaptcha/duration/struct.update_duration.html +++ b/mcaptcha/api/v1/mcaptcha/duration/struct.update_duration.html @@ -1,106 +1,106 @@ -update_duration in mcaptcha::api::v1::mcaptcha::duration - Rust - -

Struct mcaptcha::api::v1::mcaptcha::duration::update_duration[−][src]

pub struct update_duration;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_duration in mcaptcha::api::v1::mcaptcha::duration - Rust

Struct mcaptcha::api::v1::mcaptcha::duration::update_duration[−][src]

pub struct update_duration;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/fn.get_random.html b/mcaptcha/api/v1/mcaptcha/fn.get_random.html index 5305ef8d..3a5f05df 100644 --- a/mcaptcha/api/v1/mcaptcha/fn.get_random.html +++ b/mcaptcha/api/v1/mcaptcha/fn.get_random.html @@ -1,3 +1,3 @@ -get_random in mcaptcha::api::v1::mcaptcha - Rust - -

Function mcaptcha::api::v1::mcaptcha::get_random[−][src]

pub fn get_random(len: usize) -> String
\ No newline at end of file +get_random in mcaptcha::api::v1::mcaptcha - Rust

Function mcaptcha::api::v1::mcaptcha::get_random[−][src]

pub fn get_random(len: usize) -> String
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/fn.services.html b/mcaptcha/api/v1/mcaptcha/fn.services.html index 484b0b53..8a153aeb 100644 --- a/mcaptcha/api/v1/mcaptcha/fn.services.html +++ b/mcaptcha/api/v1/mcaptcha/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::mcaptcha - Rust - -

Function mcaptcha::api::v1::mcaptcha::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::mcaptcha - Rust

Function mcaptcha::api::v1::mcaptcha::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/index.html b/mcaptcha/api/v1/mcaptcha/index.html index b5f433eb..0ca60261 100644 --- a/mcaptcha/api/v1/mcaptcha/index.html +++ b/mcaptcha/api/v1/mcaptcha/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::mcaptcha - Rust - -

Module mcaptcha::api::v1::mcaptcha[−][src]

Modules

-
captcha
duration
levels

Functions

-
get_random
services
\ No newline at end of file +mcaptcha::api::v1::mcaptcha - Rust

Module mcaptcha::api::v1::mcaptcha[−][src]

Modules

+
captcha
duration
levels

Functions

+
get_random
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/fn.get_levels_util.html b/mcaptcha/api/v1/mcaptcha/levels/fn.get_levels_util.html index b34529f8..f4c8a945 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/fn.get_levels_util.html +++ b/mcaptcha/api/v1/mcaptcha/levels/fn.get_levels_util.html @@ -1,3 +1,3 @@ -get_levels_util in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Function mcaptcha::api::v1::mcaptcha::levels::get_levels_util[−][src]

async fn get_levels_util(
    key: &str, 
    username: &str, 
    data: &AppData
) -> Result<Vec<I32Levels>, ServiceError>
\ No newline at end of file +get_levels_util in mcaptcha::api::v1::mcaptcha::levels - Rust

Function mcaptcha::api::v1::mcaptcha::levels::get_levels_util[−][src]

async fn get_levels_util(
    key: &str, 
    username: &str, 
    data: &AppData
) -> Result<Vec<I32Levels>, ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/fn.services.html b/mcaptcha/api/v1/mcaptcha/levels/fn.services.html index b22f5eb3..f1140267 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/fn.services.html +++ b/mcaptcha/api/v1/mcaptcha/levels/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Function mcaptcha::api::v1::mcaptcha::levels::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::mcaptcha::levels - Rust

Function mcaptcha::api::v1::mcaptcha::levels::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/index.html b/mcaptcha/api/v1/mcaptcha/levels/index.html index 140c254a..b36ce49b 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/index.html +++ b/mcaptcha/api/v1/mcaptcha/levels/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::mcaptcha::levels - Rust - -

Module mcaptcha::api::v1::mcaptcha::levels[−][src]

Modules

-
routes

Structs

-
AddLevels
I32Levels
Levels
UpdateLevels
add_levels
get_levels
update_levels

Functions

-
get_levels_util
services
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::levels - Rust

Module mcaptcha::api::v1::mcaptcha::levels[−][src]

Modules

+
routes

Structs

+
AddLevels
I32Levels
Levels
UpdateLevels
add_levels
get_levels
update_levels

Functions

+
get_levels_util
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/routes/index.html b/mcaptcha/api/v1/mcaptcha/levels/routes/index.html index cc05c296..5600535c 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/routes/index.html +++ b/mcaptcha/api/v1/mcaptcha/levels/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::mcaptcha::levels::routes - Rust - -

Module mcaptcha::api::v1::mcaptcha::levels::routes[−][src]

Structs

-
Levels
\ No newline at end of file +mcaptcha::api::v1::mcaptcha::levels::routes - Rust

Module mcaptcha::api::v1::mcaptcha::levels::routes[−][src]

Structs

+
Levels
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/routes/struct.Levels.html b/mcaptcha/api/v1/mcaptcha/levels/routes/struct.Levels.html index ea33fb0a..a542a5a4 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/routes/struct.Levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/routes/struct.Levels.html @@ -1,111 +1,110 @@ -Levels in mcaptcha::api::v1::mcaptcha::levels::routes - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::routes::Levels[−][src]

pub struct Levels {
-    pub add: &'static str,
-    pub get: &'static str,
-    pub update: &'static str,
-}

- Fields

add: &'static strget: &'static strupdate: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Levels in mcaptcha::api::v1::mcaptcha::levels::routes - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::routes::Levels[−][src]

pub struct Levels {
+    pub add: &'static str,
+    pub get: &'static str,
+    pub update: &'static str,
+}

Fields

add: &'static strget: &'static strupdate: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.AddLevels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.AddLevels.html index bbabbcad..5f1a4f20 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.AddLevels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.AddLevels.html @@ -1,113 +1,112 @@ -AddLevels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::AddLevels[−][src]

pub struct AddLevels {
-    pub levels: Vec<Level>,
-    pub duration: u32,
-    pub description: String,
-}

- Fields

levels: Vec<Level>duration: u32description: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +AddLevels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::AddLevels[−][src]

pub struct AddLevels {
+    pub levels: Vec<Level>,
+    pub duration: u32,
+    pub description: String,
+}

Fields

levels: Vec<Level>duration: u32description: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.I32Levels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.I32Levels.html index c52b807b..fbfbb654 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.I32Levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.I32Levels.html @@ -1,119 +1,118 @@ -I32Levels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::I32Levels[−][src]

pub struct I32Levels {
-    pub difficulty_factor: i32,
-    pub visitor_threshold: i32,
-}

- Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +I32Levels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::I32Levels[−][src]

pub struct I32Levels {
+    pub difficulty_factor: i32,
+    pub visitor_threshold: i32,
+}

Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.Levels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.Levels.html index 2c3d45a7..8544e7b0 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.Levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.Levels.html @@ -1,118 +1,117 @@ -Levels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::Levels[−][src]

pub struct Levels {
+Levels in mcaptcha::api::v1::mcaptcha::levels - Rust
Struct mcaptcha::api::v1::mcaptcha::levels::Levels[−][src]
pub struct Levels {
     levels: I32Levels,
-}

-                       Fields
levels: I32Levels
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Serialize this value into the given Serde serializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

levels: I32Levels

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.UpdateLevels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.UpdateLevels.html index 049f7cf6..32a9644f 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.UpdateLevels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.UpdateLevels.html @@ -1,114 +1,113 @@ -UpdateLevels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::UpdateLevels[−][src]

pub struct UpdateLevels {
-    pub levels: Vec<Level>,
-    pub duration: u32,
-    pub description: String,
-    pub key: String,
-}

- Fields

levels: Vec<Level>duration: u32description: Stringkey: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +UpdateLevels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::UpdateLevels[−][src]

pub struct UpdateLevels {
+    pub levels: Vec<Level>,
+    pub duration: u32,
+    pub description: String,
+    pub key: String,
+}

Fields

levels: Vec<Level>duration: u32description: Stringkey: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.add_levels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.add_levels.html index 150a4664..ef0556db 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.add_levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.add_levels.html @@ -1,106 +1,106 @@ -add_levels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::add_levels[−][src]

pub struct add_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +add_levels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::add_levels[−][src]

pub struct add_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.get_levels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.get_levels.html index bbefe7b8..a83a9b54 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.get_levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.get_levels.html @@ -1,106 +1,106 @@ -get_levels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::get_levels[−][src]

pub struct get_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_levels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::get_levels[−][src]

pub struct get_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/mcaptcha/levels/struct.update_levels.html b/mcaptcha/api/v1/mcaptcha/levels/struct.update_levels.html index 050f0c2a..a1feaa5e 100644 --- a/mcaptcha/api/v1/mcaptcha/levels/struct.update_levels.html +++ b/mcaptcha/api/v1/mcaptcha/levels/struct.update_levels.html @@ -1,106 +1,106 @@ -update_levels in mcaptcha::api::v1::mcaptcha::levels - Rust - -

Struct mcaptcha::api::v1::mcaptcha::levels::update_levels[−][src]

pub struct update_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_levels in mcaptcha::api::v1::mcaptcha::levels - Rust

Struct mcaptcha::api::v1::mcaptcha::levels::update_levels[−][src]

pub struct update_levels;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/enum.BuildDetailsBuilderError.html b/mcaptcha/api/v1/meta/enum.BuildDetailsBuilderError.html index c8bdc74b..56f80f61 100644 --- a/mcaptcha/api/v1/meta/enum.BuildDetailsBuilderError.html +++ b/mcaptcha/api/v1/meta/enum.BuildDetailsBuilderError.html @@ -1,124 +1,122 @@ -BuildDetailsBuilderError in mcaptcha::api::v1::meta - Rust - -

Enum mcaptcha::api::v1::meta::BuildDetailsBuilderError[−][src]

#[non_exhaustive]
+BuildDetailsBuilderError in mcaptcha::api::v1::meta - Rust
Enum mcaptcha::api::v1::meta::BuildDetailsBuilderError[−][src]
#[non_exhaustive]
 pub enum BuildDetailsBuilderError {
-    UninitializedField(&'static str),
-    ValidationError(String),
+    UninitializedField(&'static str),
+    ValidationError(String),
 }
Expand description
Error type for BuildDetailsBuilder

-

-                   Variants (Non-exhaustive)

-
This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
UninitializedField(&'static str)
Uninitialized field

-
ValidationError(String)
Custom validation error

-
Trait Implementations
Formats the value using the given formatter. Read more

-
Formats the value using the given formatter. Read more

-
The lower-level source of this error, if any. Read more

-
🔬 This is a nightly-only experimental API. (backtrace)
Returns a stack backtrace, if available, of where this error occurred. Read more

-
👎 Deprecated since 1.42.0: 
use the Display impl or to_string()

-
 Read more
👎 Deprecated since 1.33.0: 
replaced by Error::source, which can support downcasting

-
Performs the conversion.

-
Performs the conversion.

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Variants (Non-exhaustive)
This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
UninitializedField(&'static str)
Uninitialized field

+
ValidationError(String)
Custom validation error

+
Trait Implementations
Formats the value using the given formatter. Read more

+
Formats the value using the given formatter. Read more

+
The lower-level source of this error, if any. Read more

+
🔬 This is a nightly-only experimental API. (backtrace)
Returns a stack backtrace, if available, of where this error occurred. Read more

+
👎 Deprecated since 1.42.0: 
use the Display impl or to_string()

+
 Read more
👎 Deprecated since 1.33.0: 
replaced by Error::source, which can support downcasting

+
Performs the conversion.

+
Performs the conversion.

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
Converts the given value to a String. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

Converts the given value to a String. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/enum.HealthBuilderError.html b/mcaptcha/api/v1/meta/enum.HealthBuilderError.html index d11510d2..f2768a2a 100644 --- a/mcaptcha/api/v1/meta/enum.HealthBuilderError.html +++ b/mcaptcha/api/v1/meta/enum.HealthBuilderError.html @@ -1,124 +1,122 @@ -HealthBuilderError in mcaptcha::api::v1::meta - Rust - -

Enum mcaptcha::api::v1::meta::HealthBuilderError[−][src]

#[non_exhaustive]
+HealthBuilderError in mcaptcha::api::v1::meta - Rust
Enum mcaptcha::api::v1::meta::HealthBuilderError[−][src]
#[non_exhaustive]
 pub enum HealthBuilderError {
-    UninitializedField(&'static str),
-    ValidationError(String),
+    UninitializedField(&'static str),
+    ValidationError(String),
 }
Expand description
Error type for HealthBuilder

-

-                   Variants (Non-exhaustive)

-
This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
UninitializedField(&'static str)
Uninitialized field

-
ValidationError(String)
Custom validation error

-
Trait Implementations
Formats the value using the given formatter. Read more

-
Formats the value using the given formatter. Read more

-
The lower-level source of this error, if any. Read more

-
🔬 This is a nightly-only experimental API. (backtrace)
Returns a stack backtrace, if available, of where this error occurred. Read more

-
👎 Deprecated since 1.42.0: 
use the Display impl or to_string()

-
 Read more
👎 Deprecated since 1.33.0: 
replaced by Error::source, which can support downcasting

-
Performs the conversion.

-
Performs the conversion.

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Variants (Non-exhaustive)
This enum is marked as non-exhaustive
Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.
UninitializedField(&'static str)
Uninitialized field

+
ValidationError(String)
Custom validation error

+
Trait Implementations
Formats the value using the given formatter. Read more

+
Formats the value using the given formatter. Read more

+
The lower-level source of this error, if any. Read more

+
🔬 This is a nightly-only experimental API. (backtrace)
Returns a stack backtrace, if available, of where this error occurred. Read more

+
👎 Deprecated since 1.42.0: 
use the Display impl or to_string()

+
 Read more
👎 Deprecated since 1.33.0: 
replaced by Error::source, which can support downcasting

+
Performs the conversion.

+
Performs the conversion.

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
Converts the given value to a String. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

Converts the given value to a String. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/fn.services.html b/mcaptcha/api/v1/meta/fn.services.html index 9769a2c3..ffb27cfe 100644 --- a/mcaptcha/api/v1/meta/fn.services.html +++ b/mcaptcha/api/v1/meta/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::meta - Rust - -

Function mcaptcha::api::v1::meta::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::meta - Rust

Function mcaptcha::api::v1::meta::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/index.html b/mcaptcha/api/v1/meta/index.html index d2482e5d..917e8bc3 100644 --- a/mcaptcha/api/v1/meta/index.html +++ b/mcaptcha/api/v1/meta/index.html @@ -1,14 +1,14 @@ -mcaptcha::api::v1::meta - Rust - -

Module mcaptcha::api::v1::meta[−][src]

Modules

-
routes

Structs

-
BuildDetails
BuildDetailsBuilder

Builder for BuildDetails.

-
Health

Health check return datatype

-
HealthBuilder

Builder for Health.

-
build_details

emmits build details of the bninary

-
health

checks all components of the system

-

Enums

-
BuildDetailsBuilderError

Error type for BuildDetailsBuilder

-
HealthBuilderError

Error type for HealthBuilder

-

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::meta - Rust

Module mcaptcha::api::v1::meta[−][src]

Modules

+
routes

Structs

+
BuildDetails
BuildDetailsBuilder

Builder for BuildDetails.

+
Health

Health check return datatype

+
HealthBuilder

Builder for Health.

+
build_details

emmits build details of the bninary

+
health

checks all components of the system

+

Enums

+
BuildDetailsBuilderError

Error type for BuildDetailsBuilder

+
HealthBuilderError

Error type for HealthBuilder

+

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/routes/index.html b/mcaptcha/api/v1/meta/routes/index.html index fa66c6cd..e07f4947 100644 --- a/mcaptcha/api/v1/meta/routes/index.html +++ b/mcaptcha/api/v1/meta/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::meta::routes - Rust - -

Module mcaptcha::api::v1::meta::routes[−][src]

Structs

-
Meta
\ No newline at end of file +mcaptcha::api::v1::meta::routes - Rust

Module mcaptcha::api::v1::meta::routes[−][src]

Structs

+
Meta
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/routes/struct.Meta.html b/mcaptcha/api/v1/meta/routes/struct.Meta.html index 2c801507..d6ac085e 100644 --- a/mcaptcha/api/v1/meta/routes/struct.Meta.html +++ b/mcaptcha/api/v1/meta/routes/struct.Meta.html @@ -1,110 +1,109 @@ -Meta in mcaptcha::api::v1::meta::routes - Rust - -

Struct mcaptcha::api::v1::meta::routes::Meta[−][src]

pub struct Meta {
-    pub build_details: &'static str,
-    pub health: &'static str,
-}

- Fields

build_details: &'static strhealth: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Meta in mcaptcha::api::v1::meta::routes - Rust

Struct mcaptcha::api::v1::meta::routes::Meta[−][src]

pub struct Meta {
+    pub build_details: &'static str,
+    pub health: &'static str,
+}

Fields

build_details: &'static strhealth: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.BuildDetails.html b/mcaptcha/api/v1/meta/struct.BuildDetails.html index c861f73c..10f2584b 100644 --- a/mcaptcha/api/v1/meta/struct.BuildDetails.html +++ b/mcaptcha/api/v1/meta/struct.BuildDetails.html @@ -1,119 +1,118 @@ -BuildDetails in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::BuildDetails[−][src]

pub struct BuildDetails {
-    pub version: &'static str,
-    pub git_commit_hash: &'static str,
-}

- Fields

version: &'static strgit_commit_hash: &'static str

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +BuildDetails in mcaptcha::api::v1::meta - Rust

Struct mcaptcha::api::v1::meta::BuildDetails[−][src]

pub struct BuildDetails {
+    pub version: &'static str,
+    pub git_commit_hash: &'static str,
+}

Fields

version: &'static strgit_commit_hash: &'static str

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.BuildDetailsBuilder.html b/mcaptcha/api/v1/meta/struct.BuildDetailsBuilder.html index 3bbfd5f8..49c9853e 100644 --- a/mcaptcha/api/v1/meta/struct.BuildDetailsBuilder.html +++ b/mcaptcha/api/v1/meta/struct.BuildDetailsBuilder.html @@ -1,121 +1,120 @@ -BuildDetailsBuilder in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::BuildDetailsBuilder[−][src]

pub struct BuildDetailsBuilder {
-    version: Option<&'static str>,
-    git_commit_hash: Option<&'static str>,
+BuildDetailsBuilder in mcaptcha::api::v1::meta - Rust
Struct mcaptcha::api::v1::meta::BuildDetailsBuilder[−][src]
pub struct BuildDetailsBuilder {
+    version: Option<&'static str>,
+    git_commit_hash: Option<&'static str>,
 }
Expand description
Builder for BuildDetails.

-

-                       Fields
version: Option<&'static str>git_commit_hash: Option<&'static str>
Implementations
Builds a new BuildDetails.

+
Fields
version: Option<&'static str>git_commit_hash: Option<&'static str>
Implementations
Builds a new BuildDetails.

 
Errors

 
If a required field has not been initialized.

-
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Returns the “default value” for a type. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Trait Implementations
Returns a copy of the value. Read more

+
Performs copy-assignment from source. Read more

+
Returns the “default value” for a type. Read more

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
The resulting type after obtaining ownership.

-
Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)
recently added

-
Uses borrowed data to replace owned data, usually by cloning. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.Health.html b/mcaptcha/api/v1/meta/struct.Health.html index 09283a58..0c5cc114 100644 --- a/mcaptcha/api/v1/meta/struct.Health.html +++ b/mcaptcha/api/v1/meta/struct.Health.html @@ -1,120 +1,119 @@ -Health in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::Health[−][src]

pub struct Health {
-    db: bool,
-    redis: Option<bool>,
+Health in mcaptcha::api::v1::meta - Rust
Struct mcaptcha::api::v1::meta::Health[−][src]
pub struct Health {
+    db: bool,
+    redis: Option<bool>,
 }
Expand description
Health check return datatype

-

-                       Fields
db: boolredis: Option<bool>
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Serialize this value into the given Serde serializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Fields
db: boolredis: Option<bool>
Implementations
Trait Implementations
Returns a copy of the value. Read more

+
Performs copy-assignment from source. Read more

+
Formats the value using the given formatter. Read more

+
Deserialize this value from the given Serde deserializer. Read more

+
Serialize this value into the given Serde serializer. Read more

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
The resulting type after obtaining ownership.

-
Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)
recently added

-
Uses borrowed data to replace owned data, usually by cloning. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.HealthBuilder.html b/mcaptcha/api/v1/meta/struct.HealthBuilder.html index 24a77dc7..02a505bf 100644 --- a/mcaptcha/api/v1/meta/struct.HealthBuilder.html +++ b/mcaptcha/api/v1/meta/struct.HealthBuilder.html @@ -1,121 +1,120 @@ -HealthBuilder in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::HealthBuilder[−][src]

pub struct HealthBuilder {
-    db: Option<bool>,
-    redis: Option<Option<bool>>,
+HealthBuilder in mcaptcha::api::v1::meta - Rust
Struct mcaptcha::api::v1::meta::HealthBuilder[−][src]
pub struct HealthBuilder {
+    db: Option<bool>,
+    redis: Option<Option<bool>>,
 }
Expand description
Builder for Health.

-

-                       Fields
db: Option<bool>redis: Option<Option<bool>>
Implementations
Builds a new Health.

+
Fields
db: Option<bool>redis: Option<Option<bool>>
Implementations
Builds a new Health.

 
Errors

 
If a required field has not been initialized.

-
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Returns the “default value” for a type. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Trait Implementations
Returns a copy of the value. Read more

+
Performs copy-assignment from source. Read more

+
Returns the “default value” for a type. Read more

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
The resulting type after obtaining ownership.

-
Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)
recently added

-
Uses borrowed data to replace owned data, usually by cloning. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.build_details.html b/mcaptcha/api/v1/meta/struct.build_details.html index b4ca59a7..81b51645 100644 --- a/mcaptcha/api/v1/meta/struct.build_details.html +++ b/mcaptcha/api/v1/meta/struct.build_details.html @@ -1,107 +1,107 @@ -build_details in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::build_details[−][src]

pub struct build_details;
Expand description

emmits build details of the bninary

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +build_details in mcaptcha::api::v1::meta - Rust

Struct mcaptcha::api::v1::meta::build_details[−][src]

pub struct build_details;
Expand description

emmits build details of the bninary

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/meta/struct.health.html b/mcaptcha/api/v1/meta/struct.health.html index cd8b0afe..3e0d3fd8 100644 --- a/mcaptcha/api/v1/meta/struct.health.html +++ b/mcaptcha/api/v1/meta/struct.health.html @@ -1,107 +1,107 @@ -health in mcaptcha::api::v1::meta - Rust - -

Struct mcaptcha::api::v1::meta::health[−][src]

pub struct health;
Expand description

checks all components of the system

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +health in mcaptcha::api::v1::meta - Rust

Struct mcaptcha::api::v1::meta::health[−][src]

pub struct health;
Expand description

checks all components of the system

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/add/index.html b/mcaptcha/api/v1/notifications/add/index.html index 3bbef0fb..d4768037 100644 --- a/mcaptcha/api/v1/notifications/add/index.html +++ b/mcaptcha/api/v1/notifications/add/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::notifications::add - Rust - -

Module mcaptcha::api::v1::notifications::add[−][src]

Structs

-
AddNotification
add_notification

route handler that adds a notification message

-
\ No newline at end of file +mcaptcha::api::v1::notifications::add - Rust

Module mcaptcha::api::v1::notifications::add[−][src]

Structs

+
AddNotification
add_notification

route handler that adds a notification message

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/add/struct.AddNotification.html b/mcaptcha/api/v1/notifications/add/struct.AddNotification.html index 814e17de..10b4c2d3 100644 --- a/mcaptcha/api/v1/notifications/add/struct.AddNotification.html +++ b/mcaptcha/api/v1/notifications/add/struct.AddNotification.html @@ -1,113 +1,112 @@ -AddNotification in mcaptcha::api::v1::notifications::add - Rust - -

Struct mcaptcha::api::v1::notifications::add::AddNotification[−][src]

pub struct AddNotification {
-    pub to: String,
-    pub heading: String,
-    pub message: String,
-}

- Fields

to: Stringheading: Stringmessage: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +AddNotification in mcaptcha::api::v1::notifications::add - Rust

Struct mcaptcha::api::v1::notifications::add::AddNotification[−][src]

pub struct AddNotification {
+    pub to: String,
+    pub heading: String,
+    pub message: String,
+}

Fields

to: Stringheading: Stringmessage: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/add/struct.add_notification.html b/mcaptcha/api/v1/notifications/add/struct.add_notification.html index 34b2f601..c7d41b20 100644 --- a/mcaptcha/api/v1/notifications/add/struct.add_notification.html +++ b/mcaptcha/api/v1/notifications/add/struct.add_notification.html @@ -1,107 +1,107 @@ -add_notification in mcaptcha::api::v1::notifications::add - Rust - -

Struct mcaptcha::api::v1::notifications::add::add_notification[−][src]

pub struct add_notification;
Expand description

route handler that adds a notification message

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +add_notification in mcaptcha::api::v1::notifications::add - Rust

Struct mcaptcha::api::v1::notifications::add::add_notification[−][src]

pub struct add_notification;
Expand description

route handler that adds a notification message

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/fn.services.html b/mcaptcha/api/v1/notifications/fn.services.html index 0d611d2f..50f404c6 100644 --- a/mcaptcha/api/v1/notifications/fn.services.html +++ b/mcaptcha/api/v1/notifications/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::notifications - Rust - -

Function mcaptcha::api::v1::notifications::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::notifications - Rust

Function mcaptcha::api::v1::notifications::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/index.html b/mcaptcha/api/v1/notifications/get/index.html index 742228de..f0ec489b 100644 --- a/mcaptcha/api/v1/notifications/get/index.html +++ b/mcaptcha/api/v1/notifications/get/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::notifications::get - Rust - -

Module mcaptcha::api::v1::notifications::get[−][src]

Modules

-
runner

Structs

-
Notification
NotificationResp
get_notification

route handler that gets all unread notifications

-
\ No newline at end of file +mcaptcha::api::v1::notifications::get - Rust

Module mcaptcha::api::v1::notifications::get[−][src]

Modules

+
runner

Structs

+
Notification
NotificationResp
get_notification

route handler that gets all unread notifications

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/runner/fn.get_notification.html b/mcaptcha/api/v1/notifications/get/runner/fn.get_notification.html index cdad4ec1..fa2c8706 100644 --- a/mcaptcha/api/v1/notifications/get/runner/fn.get_notification.html +++ b/mcaptcha/api/v1/notifications/get/runner/fn.get_notification.html @@ -1,3 +1,3 @@ -get_notification in mcaptcha::api::v1::notifications::get::runner - Rust - -

Function mcaptcha::api::v1::notifications::get::runner::get_notification[−][src]

pub async fn get_notification(
    data: &AppData, 
    receiver: &str
) -> Result<Vec<Notification>, ServiceError>
\ No newline at end of file +get_notification in mcaptcha::api::v1::notifications::get::runner - Rust

Function mcaptcha::api::v1::notifications::get::runner::get_notification[−][src]

pub async fn get_notification(
    data: &AppData, 
    receiver: &str
) -> Result<Vec<Notification>, ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/runner/index.html b/mcaptcha/api/v1/notifications/get/runner/index.html index 028bd6c8..8029b9da 100644 --- a/mcaptcha/api/v1/notifications/get/runner/index.html +++ b/mcaptcha/api/v1/notifications/get/runner/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::notifications::get::runner - Rust - -

Module mcaptcha::api::v1::notifications::get::runner[−][src]

Functions

-
get_notification
\ No newline at end of file +mcaptcha::api::v1::notifications::get::runner - Rust

Module mcaptcha::api::v1::notifications::get::runner[−][src]

Functions

+
get_notification
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/struct.Notification.html b/mcaptcha/api/v1/notifications/get/struct.Notification.html index 456bf47e..5f118e4d 100644 --- a/mcaptcha/api/v1/notifications/get/struct.Notification.html +++ b/mcaptcha/api/v1/notifications/get/struct.Notification.html @@ -1,115 +1,114 @@ -Notification in mcaptcha::api::v1::notifications::get - Rust - -

Struct mcaptcha::api::v1::notifications::get::Notification[−][src]

pub struct Notification {
-    pub name: Option<String>,
-    pub heading: Option<String>,
-    pub message: Option<String>,
-    pub received: Option<OffsetDateTime>,
-    pub id: Option<i32>,
-}

- Fields

name: Option<String>heading: Option<String>message: Option<String>received: Option<OffsetDateTime>id: Option<i32>

Trait Implementations

Performs the conversion.

-

Performs the conversion.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Notification in mcaptcha::api::v1::notifications::get - Rust

Struct mcaptcha::api::v1::notifications::get::Notification[−][src]

pub struct Notification {
+    pub name: Option<String>,
+    pub heading: Option<String>,
+    pub message: Option<String>,
+    pub received: Option<OffsetDateTime>,
+    pub id: Option<i32>,
+}

Fields

name: Option<String>heading: Option<String>message: Option<String>received: Option<OffsetDateTime>id: Option<i32>

Trait Implementations

Performs the conversion.

+

Performs the conversion.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/struct.NotificationResp.html b/mcaptcha/api/v1/notifications/get/struct.NotificationResp.html index b3fb6d7e..eaf4f43e 100644 --- a/mcaptcha/api/v1/notifications/get/struct.NotificationResp.html +++ b/mcaptcha/api/v1/notifications/get/struct.NotificationResp.html @@ -1,116 +1,115 @@ -NotificationResp in mcaptcha::api::v1::notifications::get - Rust - -

Struct mcaptcha::api::v1::notifications::get::NotificationResp[−][src]

pub struct NotificationResp {
-    pub name: String,
-    pub heading: String,
-    pub message: String,
-    pub received: i64,
-    pub id: i32,
-}

- Fields

name: Stringheading: Stringmessage: Stringreceived: i64id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Performs the conversion.

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +NotificationResp in mcaptcha::api::v1::notifications::get - Rust

Struct mcaptcha::api::v1::notifications::get::NotificationResp[−][src]

pub struct NotificationResp {
+    pub name: String,
+    pub heading: String,
+    pub message: String,
+    pub received: i64,
+    pub id: i32,
+}

Fields

name: Stringheading: Stringmessage: Stringreceived: i64id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Performs the conversion.

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/get/struct.get_notification.html b/mcaptcha/api/v1/notifications/get/struct.get_notification.html index feb32d57..d68a2d4c 100644 --- a/mcaptcha/api/v1/notifications/get/struct.get_notification.html +++ b/mcaptcha/api/v1/notifications/get/struct.get_notification.html @@ -1,107 +1,107 @@ -get_notification in mcaptcha::api::v1::notifications::get - Rust - -

Struct mcaptcha::api::v1::notifications::get::get_notification[−][src]

pub struct get_notification;
Expand description

route handler that gets all unread notifications

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_notification in mcaptcha::api::v1::notifications::get - Rust

Struct mcaptcha::api::v1::notifications::get::get_notification[−][src]

pub struct get_notification;
Expand description

route handler that gets all unread notifications

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/index.html b/mcaptcha/api/v1/notifications/index.html index c3064a80..f025788c 100644 --- a/mcaptcha/api/v1/notifications/index.html +++ b/mcaptcha/api/v1/notifications/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::notifications - Rust - -

Module mcaptcha::api::v1::notifications[−][src]

Modules

-
add
get
mark_read
routes

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::notifications - Rust

Module mcaptcha::api::v1::notifications[−][src]

Modules

+
add
get
mark_read
routes

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/mark_read/index.html b/mcaptcha/api/v1/notifications/mark_read/index.html index f89b85fc..cc66687b 100644 --- a/mcaptcha/api/v1/notifications/mark_read/index.html +++ b/mcaptcha/api/v1/notifications/mark_read/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::notifications::mark_read - Rust - -

Module mcaptcha::api::v1::notifications::mark_read[−][src]

Structs

-
MarkReadReq
NotificationResp
mark_read

route handler that marks a notification read

-
\ No newline at end of file +mcaptcha::api::v1::notifications::mark_read - Rust

Module mcaptcha::api::v1::notifications::mark_read[−][src]

Structs

+
MarkReadReq
NotificationResp
mark_read

route handler that marks a notification read

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/mark_read/struct.MarkReadReq.html b/mcaptcha/api/v1/notifications/mark_read/struct.MarkReadReq.html index a3839c9d..cdea215c 100644 --- a/mcaptcha/api/v1/notifications/mark_read/struct.MarkReadReq.html +++ b/mcaptcha/api/v1/notifications/mark_read/struct.MarkReadReq.html @@ -1,111 +1,110 @@ -MarkReadReq in mcaptcha::api::v1::notifications::mark_read - Rust - -

Struct mcaptcha::api::v1::notifications::mark_read::MarkReadReq[−][src]

pub struct MarkReadReq {
-    pub id: i32,
-}

- Fields

id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MarkReadReq in mcaptcha::api::v1::notifications::mark_read - Rust

Struct mcaptcha::api::v1::notifications::mark_read::MarkReadReq[−][src]

pub struct MarkReadReq {
+    pub id: i32,
+}

Fields

id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/mark_read/struct.NotificationResp.html b/mcaptcha/api/v1/notifications/mark_read/struct.NotificationResp.html index 47a9f3bf..a96c59c6 100644 --- a/mcaptcha/api/v1/notifications/mark_read/struct.NotificationResp.html +++ b/mcaptcha/api/v1/notifications/mark_read/struct.NotificationResp.html @@ -1,115 +1,114 @@ -NotificationResp in mcaptcha::api::v1::notifications::mark_read - Rust - -

Struct mcaptcha::api::v1::notifications::mark_read::NotificationResp[−][src]

pub struct NotificationResp {
-    pub name: String,
-    pub heading: String,
-    pub message: String,
-    pub received: i64,
-    pub id: i32,
-}

- Fields

name: Stringheading: Stringmessage: Stringreceived: i64id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +NotificationResp in mcaptcha::api::v1::notifications::mark_read - Rust

Struct mcaptcha::api::v1::notifications::mark_read::NotificationResp[−][src]

pub struct NotificationResp {
+    pub name: String,
+    pub heading: String,
+    pub message: String,
+    pub received: i64,
+    pub id: i32,
+}

Fields

name: Stringheading: Stringmessage: Stringreceived: i64id: i32

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/mark_read/struct.mark_read.html b/mcaptcha/api/v1/notifications/mark_read/struct.mark_read.html index d74e4543..3a97c673 100644 --- a/mcaptcha/api/v1/notifications/mark_read/struct.mark_read.html +++ b/mcaptcha/api/v1/notifications/mark_read/struct.mark_read.html @@ -1,107 +1,107 @@ -mark_read in mcaptcha::api::v1::notifications::mark_read - Rust - -

Struct mcaptcha::api::v1::notifications::mark_read::mark_read[−][src]

pub struct mark_read;
Expand description

route handler that marks a notification read

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +mark_read in mcaptcha::api::v1::notifications::mark_read - Rust

Struct mcaptcha::api::v1::notifications::mark_read::mark_read[−][src]

pub struct mark_read;
Expand description

route handler that marks a notification read

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/routes/index.html b/mcaptcha/api/v1/notifications/routes/index.html index 6ed1cddd..9491083a 100644 --- a/mcaptcha/api/v1/notifications/routes/index.html +++ b/mcaptcha/api/v1/notifications/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::notifications::routes - Rust - -

Module mcaptcha::api::v1::notifications::routes[−][src]

Structs

-
Notifications
\ No newline at end of file +mcaptcha::api::v1::notifications::routes - Rust

Module mcaptcha::api::v1::notifications::routes[−][src]

Structs

+
Notifications
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/notifications/routes/struct.Notifications.html b/mcaptcha/api/v1/notifications/routes/struct.Notifications.html index 59ace837..7001f69f 100644 --- a/mcaptcha/api/v1/notifications/routes/struct.Notifications.html +++ b/mcaptcha/api/v1/notifications/routes/struct.Notifications.html @@ -1,111 +1,110 @@ -Notifications in mcaptcha::api::v1::notifications::routes - Rust - -

Struct mcaptcha::api::v1::notifications::routes::Notifications[−][src]

pub struct Notifications {
-    pub add: &'static str,
-    pub mark_read: &'static str,
-    pub get: &'static str,
-}

- Fields

add: &'static strmark_read: &'static strget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Notifications in mcaptcha::api::v1::notifications::routes - Rust

Struct mcaptcha::api::v1::notifications::routes::Notifications[−][src]

pub struct Notifications {
+    pub add: &'static str,
+    pub mark_read: &'static str,
+    pub get: &'static str,
+}

Fields

add: &'static strmark_read: &'static strget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/fn.services.html b/mcaptcha/api/v1/pow/fn.services.html index 62b89afc..ec752822 100644 --- a/mcaptcha/api/v1/pow/fn.services.html +++ b/mcaptcha/api/v1/pow/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::api::v1::pow - Rust - -

Function mcaptcha::api::v1::pow::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::api::v1::pow - Rust

Function mcaptcha::api::v1::pow::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/get_config/fn.init_mcaptcha.html b/mcaptcha/api/v1/pow/get_config/fn.init_mcaptcha.html index 1dc61667..8b9dde57 100644 --- a/mcaptcha/api/v1/pow/get_config/fn.init_mcaptcha.html +++ b/mcaptcha/api/v1/pow/get_config/fn.init_mcaptcha.html @@ -1,6 +1,6 @@ -init_mcaptcha in mcaptcha::api::v1::pow::get_config - Rust - -

Function mcaptcha::api::v1::pow::get_config::init_mcaptcha[−][src]

async fn init_mcaptcha(data: &AppData, key: &str) -> Result<(), ServiceError>
Expand description

Call this when [MCaptcha][libmcaptcha::MCaptcha] is not in master.

+init_mcaptcha in mcaptcha::api::v1::pow::get_config - Rust

Function mcaptcha::api::v1::pow::get_config::init_mcaptcha[−][src]

async fn init_mcaptcha(data: &AppData, key: &str) -> Result<(), ServiceError>
Expand description

Call this when [MCaptcha][libmcaptcha::MCaptcha] is not in master.

This fn gets mcaptcha config from database, builds [Defense][libmcaptcha::Defense], creates [MCaptcha][libmcaptcha::MCaptcha] and adds it to [Master][libmcaptcha::Defense]

-
\ No newline at end of file +
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/get_config/index.html b/mcaptcha/api/v1/pow/get_config/index.html index 04f4fdae..3eb9c9e7 100644 --- a/mcaptcha/api/v1/pow/get_config/index.html +++ b/mcaptcha/api/v1/pow/get_config/index.html @@ -1,7 +1,7 @@ -mcaptcha::api::v1::pow::get_config - Rust - -

Module mcaptcha::api::v1::pow::get_config[−][src]

Structs

-
GetConfigPayload
get_config

get PoW configuration for an mcaptcha key

-

Functions

-
init_mcaptcha

Call this when [MCaptcha][libmcaptcha::MCaptcha] is not in master.

-
\ No newline at end of file +mcaptcha::api::v1::pow::get_config - Rust

Module mcaptcha::api::v1::pow::get_config[−][src]

Structs

+
GetConfigPayload
get_config

get PoW configuration for an mcaptcha key

+

Functions

+
init_mcaptcha

Call this when [MCaptcha][libmcaptcha::MCaptcha] is not in master.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/get_config/struct.GetConfigPayload.html b/mcaptcha/api/v1/pow/get_config/struct.GetConfigPayload.html index 79cfc8df..e72c7c0d 100644 --- a/mcaptcha/api/v1/pow/get_config/struct.GetConfigPayload.html +++ b/mcaptcha/api/v1/pow/get_config/struct.GetConfigPayload.html @@ -1,118 +1,117 @@ -GetConfigPayload in mcaptcha::api::v1::pow::get_config - Rust - -

Struct mcaptcha::api::v1::pow::get_config::GetConfigPayload[−][src]

pub struct GetConfigPayload {
-    pub key: String,
-}

- Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +GetConfigPayload in mcaptcha::api::v1::pow::get_config - Rust

Struct mcaptcha::api::v1::pow::get_config::GetConfigPayload[−][src]

pub struct GetConfigPayload {
+    pub key: String,
+}

Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/get_config/struct.get_config.html b/mcaptcha/api/v1/pow/get_config/struct.get_config.html index 53321ce6..faf18400 100644 --- a/mcaptcha/api/v1/pow/get_config/struct.get_config.html +++ b/mcaptcha/api/v1/pow/get_config/struct.get_config.html @@ -1,107 +1,107 @@ -get_config in mcaptcha::api::v1::pow::get_config - Rust - -

Struct mcaptcha::api::v1::pow::get_config::get_config[−][src]

pub struct get_config;
Expand description

get PoW configuration for an mcaptcha key

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +get_config in mcaptcha::api::v1::pow::get_config - Rust

Struct mcaptcha::api::v1::pow::get_config::get_config[−][src]

pub struct get_config;
Expand description

get PoW configuration for an mcaptcha key

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/index.html b/mcaptcha/api/v1/pow/index.html index b3799946..98581a88 100644 --- a/mcaptcha/api/v1/pow/index.html +++ b/mcaptcha/api/v1/pow/index.html @@ -1,8 +1,8 @@ -mcaptcha::api::v1::pow - Rust - -

Module mcaptcha::api::v1::pow[−][src]

Re-exports

-
pub use super::mcaptcha::duration::GetDurationResp;
pub use super::mcaptcha::levels::I32Levels;

Modules

-
get_config
routes
verify_pow

PoW Verification module

-
verify_token

PoW success token module

-

Functions

-
services
\ No newline at end of file +mcaptcha::api::v1::pow - Rust

Module mcaptcha::api::v1::pow[−][src]

Re-exports

+
pub use super::mcaptcha::duration::GetDurationResp;
pub use super::mcaptcha::levels::I32Levels;

Modules

+
get_config
routes
verify_pow

PoW Verification module

+
verify_token

PoW success token module

+

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/routes/index.html b/mcaptcha/api/v1/pow/routes/index.html index 72231032..34f34d06 100644 --- a/mcaptcha/api/v1/pow/routes/index.html +++ b/mcaptcha/api/v1/pow/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::api::v1::pow::routes - Rust - -

Module mcaptcha::api::v1::pow::routes[−][src]

Structs

-
PoW
\ No newline at end of file +mcaptcha::api::v1::pow::routes - Rust

Module mcaptcha::api::v1::pow::routes[−][src]

Structs

+
PoW
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/routes/struct.PoW.html b/mcaptcha/api/v1/pow/routes/struct.PoW.html index 6dfa311d..4c7f7ca6 100644 --- a/mcaptcha/api/v1/pow/routes/struct.PoW.html +++ b/mcaptcha/api/v1/pow/routes/struct.PoW.html @@ -1,112 +1,111 @@ -PoW in mcaptcha::api::v1::pow::routes - Rust - -

Struct mcaptcha::api::v1::pow::routes::PoW[−][src]

pub struct PoW {
-    pub get_config: &'static str,
-    pub verify_pow: &'static str,
-    pub validate_captcha_token: &'static str,
-    pub scope: &'static str,
-}

- Fields

get_config: &'static strverify_pow: &'static strvalidate_captcha_token: &'static strscope: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +PoW in mcaptcha::api::v1::pow::routes - Rust

Struct mcaptcha::api::v1::pow::routes::PoW[−][src]

pub struct PoW {
+    pub get_config: &'static str,
+    pub verify_pow: &'static str,
+    pub validate_captcha_token: &'static str,
+    pub scope: &'static str,
+}

Fields

get_config: &'static strverify_pow: &'static strvalidate_captcha_token: &'static strscope: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_pow/index.html b/mcaptcha/api/v1/pow/verify_pow/index.html index b8b79392..9ba132e5 100644 --- a/mcaptcha/api/v1/pow/verify_pow/index.html +++ b/mcaptcha/api/v1/pow/verify_pow/index.html @@ -1,9 +1,9 @@ -mcaptcha::api::v1::pow::verify_pow - Rust - -

Module mcaptcha::api::v1::pow::verify_pow[−][src]

Expand description

PoW Verification module

+mcaptcha::api::v1::pow::verify_pow - Rust

Module mcaptcha::api::v1::pow::verify_pow[−][src]

Expand description

PoW Verification module

Structs

-
ValidationToken

validation token that clients receive as proof for submiting +

ValidationToken

validation token that clients receive as proof for submiting valid PoW

-
verify_pow

route handler that verifies PoW and issues a solution token +

verify_pow

route handler that verifies PoW and issues a solution token if verification is successful

-
\ No newline at end of file +
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_pow/struct.ValidationToken.html b/mcaptcha/api/v1/pow/verify_pow/struct.ValidationToken.html index 4de33804..7c2bc6b8 100644 --- a/mcaptcha/api/v1/pow/verify_pow/struct.ValidationToken.html +++ b/mcaptcha/api/v1/pow/verify_pow/struct.ValidationToken.html @@ -1,120 +1,119 @@ -ValidationToken in mcaptcha::api::v1::pow::verify_pow - Rust - -

Struct mcaptcha::api::v1::pow::verify_pow::ValidationToken[−][src]

pub struct ValidationToken {
-    pub token: String,
+ValidationToken in mcaptcha::api::v1::pow::verify_pow - Rust
Struct mcaptcha::api::v1::pow::verify_pow::ValidationToken[−][src]
pub struct ValidationToken {
+    pub token: String,
 }
Expand description
validation token that clients receive as proof for submiting
 valid PoW

-

-                       Fields
token: String
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Serialize this value into the given Serde serializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Fields
token: String
Trait Implementations
Returns a copy of the value. Read more

+
Performs copy-assignment from source. Read more

+
Formats the value using the given formatter. Read more

+
Deserialize this value from the given Serde deserializer. Read more

+
Serialize this value into the given Serde serializer. Read more

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
The resulting type after obtaining ownership.

-
Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)
recently added

-
Uses borrowed data to replace owned data, usually by cloning. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_pow/struct.verify_pow.html b/mcaptcha/api/v1/pow/verify_pow/struct.verify_pow.html index 958794d5..6053f63e 100644 --- a/mcaptcha/api/v1/pow/verify_pow/struct.verify_pow.html +++ b/mcaptcha/api/v1/pow/verify_pow/struct.verify_pow.html @@ -1,108 +1,108 @@ -verify_pow in mcaptcha::api::v1::pow::verify_pow - Rust - -

Struct mcaptcha::api::v1::pow::verify_pow::verify_pow[−][src]

pub struct verify_pow;
Expand description

route handler that verifies PoW and issues a solution token +verify_pow in mcaptcha::api::v1::pow::verify_pow - Rust

Struct mcaptcha::api::v1::pow::verify_pow::verify_pow[−][src]

pub struct verify_pow;
Expand description

route handler that verifies PoW and issues a solution token if verification is successful

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_token/index.html b/mcaptcha/api/v1/pow/verify_token/index.html index 2df67138..990e5fab 100644 --- a/mcaptcha/api/v1/pow/verify_token/index.html +++ b/mcaptcha/api/v1/pow/verify_token/index.html @@ -1,6 +1,6 @@ -mcaptcha::api::v1::pow::verify_token - Rust - -

Module mcaptcha::api::v1::pow::verify_token[−][src]

Expand description

PoW success token module

+mcaptcha::api::v1::pow::verify_token - Rust

Module mcaptcha::api::v1::pow::verify_token[−][src]

Expand description

PoW success token module

Structs

-
CaptchaValidateResp
validate_captcha_token

route hander that validates a PoW solution token

-
\ No newline at end of file +
CaptchaValidateResp
validate_captcha_token

route hander that validates a PoW solution token

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_token/struct.CaptchaValidateResp.html b/mcaptcha/api/v1/pow/verify_token/struct.CaptchaValidateResp.html index 4a0dfd97..6462e8f6 100644 --- a/mcaptcha/api/v1/pow/verify_token/struct.CaptchaValidateResp.html +++ b/mcaptcha/api/v1/pow/verify_token/struct.CaptchaValidateResp.html @@ -1,118 +1,117 @@ -CaptchaValidateResp in mcaptcha::api::v1::pow::verify_token - Rust - -

Struct mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp[−][src]

pub struct CaptchaValidateResp {
-    pub valid: bool,
-}

- Fields

valid: bool

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CaptchaValidateResp in mcaptcha::api::v1::pow::verify_token - Rust

Struct mcaptcha::api::v1::pow::verify_token::CaptchaValidateResp[−][src]

pub struct CaptchaValidateResp {
+    pub valid: bool,
+}

Fields

valid: bool

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/pow/verify_token/struct.validate_captcha_token.html b/mcaptcha/api/v1/pow/verify_token/struct.validate_captcha_token.html index 8f99e7dc..758f3f76 100644 --- a/mcaptcha/api/v1/pow/verify_token/struct.validate_captcha_token.html +++ b/mcaptcha/api/v1/pow/verify_token/struct.validate_captcha_token.html @@ -1,107 +1,107 @@ -validate_captcha_token in mcaptcha::api::v1::pow::verify_token - Rust - -

Struct mcaptcha::api::v1::pow::verify_token::validate_captcha_token[−][src]

pub struct validate_captcha_token;
Expand description

route hander that validates a PoW solution token

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +validate_captcha_token in mcaptcha::api::v1::pow::verify_token - Rust

Struct mcaptcha::api::v1::pow::verify_token::validate_captcha_token[−][src]

pub struct validate_captcha_token;
Expand description

route hander that validates a PoW solution token

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/routes/constant.ROUTES.html b/mcaptcha/api/v1/routes/constant.ROUTES.html index 2c27d918..fe455f76 100644 --- a/mcaptcha/api/v1/routes/constant.ROUTES.html +++ b/mcaptcha/api/v1/routes/constant.ROUTES.html @@ -1,3 +1,3 @@ -ROUTES in mcaptcha::api::v1::routes - Rust - -

Constant mcaptcha::api::v1::routes::ROUTES[−][src]

pub const ROUTES: Routes;
\ No newline at end of file +ROUTES in mcaptcha::api::v1::routes - Rust

Constant mcaptcha::api::v1::routes::ROUTES[−][src]

pub const ROUTES: Routes;
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/routes/index.html b/mcaptcha/api/v1/routes/index.html index f865df6f..5978290f 100644 --- a/mcaptcha/api/v1/routes/index.html +++ b/mcaptcha/api/v1/routes/index.html @@ -1,5 +1,5 @@ -mcaptcha::api::v1::routes - Rust - -

Module mcaptcha::api::v1::routes[−][src]

Structs

-
Routes

Constants

-
ROUTES
\ No newline at end of file +mcaptcha::api::v1::routes - Rust

Module mcaptcha::api::v1::routes[−][src]

Structs

+
Routes

Constants

+
ROUTES
+ + \ No newline at end of file diff --git a/mcaptcha/api/v1/routes/struct.Routes.html b/mcaptcha/api/v1/routes/struct.Routes.html index 75dd4a06..d1f7cf4f 100644 --- a/mcaptcha/api/v1/routes/struct.Routes.html +++ b/mcaptcha/api/v1/routes/struct.Routes.html @@ -1,6 +1,4 @@ -Routes in mcaptcha::api::v1::routes - Rust - -

Struct mcaptcha::api::v1::routes::Routes[−][src]

pub struct Routes {
+Routes in mcaptcha::api::v1::routes - Rust
Struct mcaptcha::api::v1::routes::Routes[−][src]
pub struct Routes {
     pub auth: Auth,
     pub account: Account,
     pub levels: Levels,
@@ -9,108 +7,109 @@
     pub meta: Meta,
     pub pow: PoW,
     pub notifications: Notifications,
-}

-                       Fields
auth: Authaccount: Accountlevels: Levelsmcaptcha: MCaptchaduration: Durationmeta: Metapow: PoWnotifications: Notifications
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

auth: Authaccount: Accountlevels: Levelsmcaptcha: MCaptchaduration: Durationmeta: Metapow: PoWnotifications: Notifications

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/constant.CACHE_AGE.html b/mcaptcha/constant.CACHE_AGE.html index 04984fca..9ab0ac2e 100644 --- a/mcaptcha/constant.CACHE_AGE.html +++ b/mcaptcha/constant.CACHE_AGE.html @@ -1,3 +1,3 @@ -CACHE_AGE in mcaptcha - Rust - -

Constant mcaptcha::CACHE_AGE[−][src]

pub const CACHE_AGE: u32 = 604800;
\ No newline at end of file +CACHE_AGE in mcaptcha - Rust

Constant mcaptcha::CACHE_AGE[−][src]

pub const CACHE_AGE: u32 = 604800;
+ + \ No newline at end of file diff --git a/mcaptcha/constant.COMPILED_DATE.html b/mcaptcha/constant.COMPILED_DATE.html index 7090ed70..2dd49fe3 100644 --- a/mcaptcha/constant.COMPILED_DATE.html +++ b/mcaptcha/constant.COMPILED_DATE.html @@ -1,3 +1,3 @@ -COMPILED_DATE in mcaptcha - Rust - -

Constant mcaptcha::COMPILED_DATE[−][src]

pub const COMPILED_DATE: &str = "21-08-31";
\ No newline at end of file +COMPILED_DATE in mcaptcha - Rust

Constant mcaptcha::COMPILED_DATE[−][src]

pub const COMPILED_DATE: &str = "21-10-08";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.DOCS.html b/mcaptcha/constant.DOCS.html index 61aeeefa..fa44f645 100644 --- a/mcaptcha/constant.DOCS.html +++ b/mcaptcha/constant.DOCS.html @@ -1,3 +1,3 @@ -DOCS in mcaptcha - Rust - -

Constant mcaptcha::DOCS[−][src]

pub const DOCS: Docs;
\ No newline at end of file +DOCS in mcaptcha - Rust

Constant mcaptcha::DOCS[−][src]

pub const DOCS: Docs;
+ + \ No newline at end of file diff --git a/mcaptcha/constant.GIT_COMMIT_HASH.html b/mcaptcha/constant.GIT_COMMIT_HASH.html index e255e1db..22818138 100644 --- a/mcaptcha/constant.GIT_COMMIT_HASH.html +++ b/mcaptcha/constant.GIT_COMMIT_HASH.html @@ -1,3 +1,3 @@ -GIT_COMMIT_HASH in mcaptcha - Rust - -

Constant mcaptcha::GIT_COMMIT_HASH[−][src]

pub const GIT_COMMIT_HASH: &str = "f7afc72d814ae703fdf2ed4a85bb94bc6ff63895";
\ No newline at end of file +GIT_COMMIT_HASH in mcaptcha - Rust

Constant mcaptcha::GIT_COMMIT_HASH[−][src]

pub const GIT_COMMIT_HASH: &str = "53720ff7401d3875f11092f4b055a0fdede92ac2";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.OPEN_API_DOC.html b/mcaptcha/constant.OPEN_API_DOC.html index 72b1bb48..dc09a3c4 100644 --- a/mcaptcha/constant.OPEN_API_DOC.html +++ b/mcaptcha/constant.OPEN_API_DOC.html @@ -1,3 +1,3 @@ -OPEN_API_DOC in mcaptcha - Rust - -

Constant mcaptcha::OPEN_API_DOC[−][src]

pub const OPEN_API_DOC: &str = "{\"openapi\":\"3.0.0\",\"info\":{\"version\":\"0.1.0\",\"title\":\"mCaptcha/guard\"},\"servers\":[{\"url\":\"/\"}],\"paths\":{\"/api/v1/signup\":{\"post\":{\"summary\":\"Registration endpoint\",\"operationId\":\"registerUser\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/RegisterUser\"},\"example\":{\"username\":\"testuser\",\"password\":\"mysuperlongandsecurepassword\",\"email\":\"testuser@example.com\"}}}},\"responses\":{\"200\":{\"description\":\"Successful registration\"},\"400\":{\"description\":\"Bad request: username contains profainity/blacklisted words or email not acceptable or password too long/short or duplicate username/password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/signin\":{\"post\":{\"summary\":\"Login endpoint\",\"operationId\":\"loginUser\",\"tags\":[\"user\",\"authentication\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/LoginUser\"},\"example\":{\"username\":\"testuser\",\"password\":\"mysuperlongandsecurepassword\"}}}},\"responses\":{\"200\":{\"description\":\"Successful authentication\"},\"401\":{\"description\":\"authentication failed, wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"username not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/signout\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Signout endpoint\",\"operationId\":\"signoutUser\",\"tags\":[\"user\",\"authentication\"],\"responses\":{\"200\":{\"description\":\"OK\"}}}},\"/api/v1/account/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Delete account\",\"operationId\":\"deleteAccount\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/DeleteUser\"},\"example\":{\"password\":\"mysuperlongandsecurepassword\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"username not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/account/username/exists\":{\"post\":{\"summary\":\"Check if username exists\",\"operationId\":\"usernameExists\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheck\"},\"example\":{\"val\":\"testuser\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheckRes\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/account/email/exists\":{\"post\":{\"summary\":\"Check if email exists\",\"operationId\":\"emailExists\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheck\"},\"example\":{\"val\":\"testuser@example.com\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheckRes\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/meta/health\":{\"get\":{\"summary\":\"Health check\",\"operationId\":\"healthCheck\",\"tags\":[\"meta\",\"health\"],\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Health\"}}}}}}},\"/api/v1/meta/build\":{\"get\":{\"summary\":\"Get server binary build details\",\"operationId\":\"buildDetails\",\"tags\":[\"meta\",\"build\"],\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/BuildDetails\"}}}}}}},\"/api/v1/mcaptcha/domain/token/add\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Add token for registered domain\",\"operationId\":\"addToken\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI or duplicate token name\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Update token key\",\"operationId\":\"updateTokenKey\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI or duplicate token name\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Get token key\",\"operationId\":\"getTokenKey\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"token name not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Delete token from mcaptcha\",\"operationId\":\"deleteToken\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/add\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Add levels to a token\",\"operationId\":\"addTokenLevels\",\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"duplicate visitor count or difficulty_factor is zero or difficulty_factor decreases with increase in visitor count\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Update levels of a token\",\"operationId\":\"updateTokenLevels\",\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"duplicate visitor count or difficulty_factor is zero or difficulty_factor decreases with increase in visitor count\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"summary\":\"Delete levels of a token\",\"operationId\":\"deleteTokenLevels\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"summary\":\"Get levels of a token\",\"operationId\":\"getTokenLevels\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Levels\"}}}},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/token/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\",\"duration\"],\"summary\":\"Get duration of a token\",\"operationId\":\"getTokenDuration\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/GetDuration\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Duration\"}}}},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/token/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\",\"duration\"],\"summary\":\"update duration of a token\",\"operationId\":\"updateTokenDuration\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UpdateDuration\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"Bad request: Duration must be greater than 0\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}}},\"components\":{\"schemas\":{\"RegisterUser\":{\"type\":\"object\",\"required\":[\"username\",\"password\",\"email\"],\"properties\":{\"username\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"LoginUser\":{\"type\":\"object\",\"required\":[\"username\",\"password\"],\"properties\":{\"username\":{\"type\":\"string\"},\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"DeleteUser\":{\"type\":\"object\",\"required\":[\"password\"],\"properties\":{\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"Error\":{\"type\":\"object\",\"required\":[\"error\"],\"properties\":{\"error\":{\"type\":\"string\"}}},\"User\":{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\",\"format\":\"int64\"},\"name\":{\"type\":\"string\"}}},\"UserDetailCheck\":{\"type\":\"object\",\"required\":[\"val\"],\"properties\":{\"val\":{\"type\":\"string\"}}},\"Health\":{\"type\":\"object\",\"required\":[\"db\"],\"properties\":{\"db\":{\"type\":\"boolean\"}}},\"UserDetailCheckRes\":{\"type\":\"object\",\"required\":[\"exists\"],\"properties\":{\"val\":{\"type\":\"boolean\"}}},\"BuildDetails\":{\"type\":\"object\",\"required\":[\"version\",\"git_commit_hash\"],\"properties\":{\"version\":{\"type\":\"string\"},\"git_commit_hash\":{\"type\":\"string\"}}},\"AddDomain\":{\"type\":\"object\",\"required\":[\"name\"],\"properties\":{\"name\":{\"type\":\"string\"}}},\"DomainVerificationChallenge\":{\"type\":\"object\",\"required\":[\"verification_challenge\"],\"properties\":{\"verification_challenge\":{\"type\":\"string\"}}},\"MCaptchaID\":{\"type\":\"object\",\"required\":[\"name\",\"domain\"],\"properties\":{\"name\":{\"type\":\"string\"},\"domain\":{\"type\":\"string\"}}},\"MCaptchaDetails\":{\"type\":\"object\",\"required\":[\"name\",\"key\"],\"properties\":{\"name\":{\"type\":\"string\"},\"key\":{\"type\":\"string\"}}},\"Level\":{\"type\":\"object\",\"required\":[\"visitor_threshold\",\"difficulty_factor\"],\"properties\":{\"visitor_threshold\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647},\"difficulty_factor\":{\"type\":\"number\",\"minimum\":1}}},\"GetLevels\":{\"type\":\"object\",\"required\":[\"token\"],\"properties\":{\"token\":{\"type\":\"string\"}}},\"Levels\":{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Level\"}},\"AddLevels\":{\"type\":\"object\",\"required\":[\"name\",\"levels\"],\"properties\":{\"name\":{\"type\":\"string\"},\"levels\":{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Level\"}}}},\"GetDuration\":{\"type\":\"object\",\"required\":[\"token\"],\"properties\":{\"token\":{\"type\":\"string\"}}},\"Duration\":{\"type\":\"object\",\"required\":[\"duration\"],\"properties\":{\"duration\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647}}},\"UpdateDuration\":{\"type\":\"object\",\"required\":[\"duration\",\"token_name\"],\"properties\":{\"token_name\":{\"type\":\"string\"},\"duration\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647}}}},\"securitySchemes\":{\"cookieAuth\":{\"type\":\"apiKey\",\"in\":\"cookie\",\"name\":\"Authorization\"}}}}";
\ No newline at end of file +OPEN_API_DOC in mcaptcha - Rust

Constant mcaptcha::OPEN_API_DOC[−][src]

pub const OPEN_API_DOC: &str = "{\"openapi\":\"3.0.0\",\"info\":{\"version\":\"0.1.0\",\"title\":\"mCaptcha/guard\"},\"servers\":[{\"url\":\"/\"}],\"paths\":{\"/api/v1/signup\":{\"post\":{\"summary\":\"Registration endpoint\",\"operationId\":\"registerUser\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/RegisterUser\"},\"example\":{\"username\":\"testuser\",\"password\":\"mysuperlongandsecurepassword\",\"email\":\"testuser@example.com\"}}}},\"responses\":{\"200\":{\"description\":\"Successful registration\"},\"400\":{\"description\":\"Bad request: username contains profainity/blacklisted words or email not acceptable or password too long/short or duplicate username/password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/signin\":{\"post\":{\"summary\":\"Login endpoint\",\"operationId\":\"loginUser\",\"tags\":[\"user\",\"authentication\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/LoginUser\"},\"example\":{\"username\":\"testuser\",\"password\":\"mysuperlongandsecurepassword\"}}}},\"responses\":{\"200\":{\"description\":\"Successful authentication\"},\"401\":{\"description\":\"authentication failed, wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"username not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/signout\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Signout endpoint\",\"operationId\":\"signoutUser\",\"tags\":[\"user\",\"authentication\"],\"responses\":{\"200\":{\"description\":\"OK\"}}}},\"/api/v1/account/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Delete account\",\"operationId\":\"deleteAccount\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/DeleteUser\"},\"example\":{\"password\":\"mysuperlongandsecurepassword\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"username not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/account/username/exists\":{\"post\":{\"summary\":\"Check if username exists\",\"operationId\":\"usernameExists\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheck\"},\"example\":{\"val\":\"testuser\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheckRes\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/account/email/exists\":{\"post\":{\"summary\":\"Check if email exists\",\"operationId\":\"emailExists\",\"tags\":[\"user\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheck\"},\"example\":{\"val\":\"testuser@example.com\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UserDetailCheckRes\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/meta/health\":{\"get\":{\"summary\":\"Health check\",\"operationId\":\"healthCheck\",\"tags\":[\"meta\",\"health\"],\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Health\"}}}}}}},\"/api/v1/meta/build\":{\"get\":{\"summary\":\"Get server binary build details\",\"operationId\":\"buildDetails\",\"tags\":[\"meta\",\"build\"],\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/BuildDetails\"}}}}}}},\"/api/v1/mcaptcha/domain/token/add\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Add token for registered domain\",\"operationId\":\"addToken\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI or duplicate token name\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Update token key\",\"operationId\":\"updateTokenKey\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI or duplicate token name\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Get token key\",\"operationId\":\"getTokenKey\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaDetails\"}}}},\"400\":{\"description\":\"Bad request: Submited URI is not a URI\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"404\":{\"description\":\"token name not found\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Delete token from mcaptcha\",\"operationId\":\"deleteToken\",\"tags\":[\"mcaptcha\",\"domain\",\"token\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/MCaptchaID\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/add\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Add levels to a token\",\"operationId\":\"addTokenLevels\",\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"duplicate visitor count or difficulty_factor is zero or difficulty_factor decreases with increase in visitor count\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"summary\":\"Update levels of a token\",\"operationId\":\"updateTokenLevels\",\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"duplicate visitor count or difficulty_factor is zero or difficulty_factor decreases with increase in visitor count\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"401\":{\"description\":\"authentication failed\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/delete\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"summary\":\"Delete levels of a token\",\"operationId\":\"deleteTokenLevels\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/levels/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\"],\"summary\":\"Get levels of a token\",\"operationId\":\"getTokenLevels\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/AddLevels\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Levels\"}}}},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/token/get\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\",\"duration\"],\"summary\":\"Get duration of a token\",\"operationId\":\"getTokenDuration\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/GetDuration\"}}}},\"responses\":{\"200\":{\"description\":\"OK\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Duration\"}}}},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}},\"/api/v1/mcaptcha/domain/token/token/update\":{\"post\":{\"security\":[{\"cookieAuth\":[]}],\"tags\":[\"mcaptcha\",\"domain\",\"token\",\"levels\",\"duration\"],\"summary\":\"update duration of a token\",\"operationId\":\"updateTokenDuration\",\"requestBody\":{\"required\":true,\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/UpdateDuration\"}}}},\"responses\":{\"200\":{\"description\":\"OK\"},\"400\":{\"description\":\"Bad request: Duration must be greater than 0\"},\"401\":{\"description\":\"(cookie)authentication required or wrong password\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}},\"500\":{\"description\":\"Internal server error\",\"content\":{\"application/json\":{\"schema\":{\"$ref\":\"#/components/schemas/Error\"}}}}}}}},\"components\":{\"schemas\":{\"RegisterUser\":{\"type\":\"object\",\"required\":[\"username\",\"password\",\"email\"],\"properties\":{\"username\":{\"type\":\"string\"},\"email\":{\"type\":\"string\"},\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"LoginUser\":{\"type\":\"object\",\"required\":[\"username\",\"password\"],\"properties\":{\"username\":{\"type\":\"string\"},\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"DeleteUser\":{\"type\":\"object\",\"required\":[\"password\"],\"properties\":{\"password\":{\"type\":\"string\",\"format\":\"password\"}}},\"Error\":{\"type\":\"object\",\"required\":[\"error\"],\"properties\":{\"error\":{\"type\":\"string\"}}},\"User\":{\"type\":\"object\",\"required\":[\"id\",\"name\"],\"properties\":{\"id\":{\"type\":\"integer\",\"format\":\"int64\"},\"name\":{\"type\":\"string\"}}},\"UserDetailCheck\":{\"type\":\"object\",\"required\":[\"val\"],\"properties\":{\"val\":{\"type\":\"string\"}}},\"Health\":{\"type\":\"object\",\"required\":[\"db\"],\"properties\":{\"db\":{\"type\":\"boolean\"}}},\"UserDetailCheckRes\":{\"type\":\"object\",\"required\":[\"exists\"],\"properties\":{\"val\":{\"type\":\"boolean\"}}},\"BuildDetails\":{\"type\":\"object\",\"required\":[\"version\",\"git_commit_hash\"],\"properties\":{\"version\":{\"type\":\"string\"},\"git_commit_hash\":{\"type\":\"string\"}}},\"AddDomain\":{\"type\":\"object\",\"required\":[\"name\"],\"properties\":{\"name\":{\"type\":\"string\"}}},\"DomainVerificationChallenge\":{\"type\":\"object\",\"required\":[\"verification_challenge\"],\"properties\":{\"verification_challenge\":{\"type\":\"string\"}}},\"MCaptchaID\":{\"type\":\"object\",\"required\":[\"name\",\"domain\"],\"properties\":{\"name\":{\"type\":\"string\"},\"domain\":{\"type\":\"string\"}}},\"MCaptchaDetails\":{\"type\":\"object\",\"required\":[\"name\",\"key\"],\"properties\":{\"name\":{\"type\":\"string\"},\"key\":{\"type\":\"string\"}}},\"Level\":{\"type\":\"object\",\"required\":[\"visitor_threshold\",\"difficulty_factor\"],\"properties\":{\"visitor_threshold\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647},\"difficulty_factor\":{\"type\":\"number\",\"minimum\":1}}},\"GetLevels\":{\"type\":\"object\",\"required\":[\"token\"],\"properties\":{\"token\":{\"type\":\"string\"}}},\"Levels\":{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Level\"}},\"AddLevels\":{\"type\":\"object\",\"required\":[\"name\",\"levels\"],\"properties\":{\"name\":{\"type\":\"string\"},\"levels\":{\"type\":\"array\",\"items\":{\"$ref\":\"#/components/schemas/Level\"}}}},\"GetDuration\":{\"type\":\"object\",\"required\":[\"token\"],\"properties\":{\"token\":{\"type\":\"string\"}}},\"Duration\":{\"type\":\"object\",\"required\":[\"duration\"],\"properties\":{\"duration\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647}}},\"UpdateDuration\":{\"type\":\"object\",\"required\":[\"duration\",\"token_name\"],\"properties\":{\"token_name\":{\"type\":\"string\"},\"duration\":{\"type\":\"number\",\"minimum\":1,\"maximum\":2147483647}}}},\"securitySchemes\":{\"cookieAuth\":{\"type\":\"apiKey\",\"in\":\"cookie\",\"name\":\"Authorization\"}}}}";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.PAGES.html b/mcaptcha/constant.PAGES.html index 19d1940f..65ec5859 100644 --- a/mcaptcha/constant.PAGES.html +++ b/mcaptcha/constant.PAGES.html @@ -1,3 +1,3 @@ -PAGES in mcaptcha - Rust - -

Constant mcaptcha::PAGES[−][src]

pub const PAGES: Routes;
\ No newline at end of file +PAGES in mcaptcha - Rust

Constant mcaptcha::PAGES[−][src]

pub const PAGES: Routes;
+ + \ No newline at end of file diff --git a/mcaptcha/constant.PKG_DESCRIPTION.html b/mcaptcha/constant.PKG_DESCRIPTION.html index 39a9e59f..91f28a2d 100644 --- a/mcaptcha/constant.PKG_DESCRIPTION.html +++ b/mcaptcha/constant.PKG_DESCRIPTION.html @@ -1,3 +1,3 @@ -PKG_DESCRIPTION in mcaptcha - Rust - -

Constant mcaptcha::PKG_DESCRIPTION[−][src]

pub const PKG_DESCRIPTION: &str = "mCaptcha - a PoW-based CAPTCHA system";
\ No newline at end of file +PKG_DESCRIPTION in mcaptcha - Rust

Constant mcaptcha::PKG_DESCRIPTION[−][src]

pub const PKG_DESCRIPTION: &str = "mCaptcha - a PoW-based CAPTCHA system";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.PKG_HOMEPAGE.html b/mcaptcha/constant.PKG_HOMEPAGE.html index 458a1b41..aadf1d1c 100644 --- a/mcaptcha/constant.PKG_HOMEPAGE.html +++ b/mcaptcha/constant.PKG_HOMEPAGE.html @@ -1,3 +1,3 @@ -PKG_HOMEPAGE in mcaptcha - Rust - -

Constant mcaptcha::PKG_HOMEPAGE[−][src]

pub const PKG_HOMEPAGE: &str = "https://mcaptcha.org";
\ No newline at end of file +PKG_HOMEPAGE in mcaptcha - Rust

Constant mcaptcha::PKG_HOMEPAGE[−][src]

pub const PKG_HOMEPAGE: &str = "https://mcaptcha.org";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.PKG_NAME.html b/mcaptcha/constant.PKG_NAME.html index 006221b9..26c91fb0 100644 --- a/mcaptcha/constant.PKG_NAME.html +++ b/mcaptcha/constant.PKG_NAME.html @@ -1,3 +1,3 @@ -PKG_NAME in mcaptcha - Rust - -

Constant mcaptcha::PKG_NAME[−][src]

pub const PKG_NAME: &str = "mcaptcha";
\ No newline at end of file +PKG_NAME in mcaptcha - Rust

Constant mcaptcha::PKG_NAME[−][src]

pub const PKG_NAME: &str = "mcaptcha";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.V1_API_ROUTES.html b/mcaptcha/constant.V1_API_ROUTES.html index a70c3ef3..09475fdf 100644 --- a/mcaptcha/constant.V1_API_ROUTES.html +++ b/mcaptcha/constant.V1_API_ROUTES.html @@ -1,3 +1,3 @@ -V1_API_ROUTES in mcaptcha - Rust - -

Constant mcaptcha::V1_API_ROUTES[−][src]

pub const V1_API_ROUTES: Routes;
\ No newline at end of file +V1_API_ROUTES in mcaptcha - Rust

Constant mcaptcha::V1_API_ROUTES[−][src]

pub const V1_API_ROUTES: Routes;
+ + \ No newline at end of file diff --git a/mcaptcha/constant.VERSION.html b/mcaptcha/constant.VERSION.html index 77598af3..60653510 100644 --- a/mcaptcha/constant.VERSION.html +++ b/mcaptcha/constant.VERSION.html @@ -1,3 +1,3 @@ -VERSION in mcaptcha - Rust - -

Constant mcaptcha::VERSION[−][src]

pub const VERSION: &str = "0.1.0";
\ No newline at end of file +VERSION in mcaptcha - Rust

Constant mcaptcha::VERSION[−][src]

pub const VERSION: &str = "0.1.0";
+ + \ No newline at end of file diff --git a/mcaptcha/constant.WIDGET_ROUTES.html b/mcaptcha/constant.WIDGET_ROUTES.html index 7acfe164..6ebc6964 100644 --- a/mcaptcha/constant.WIDGET_ROUTES.html +++ b/mcaptcha/constant.WIDGET_ROUTES.html @@ -1,3 +1,3 @@ -WIDGET_ROUTES in mcaptcha - Rust - -

Constant mcaptcha::WIDGET_ROUTES[−][src]

pub const WIDGET_ROUTES: Widget;
\ No newline at end of file +WIDGET_ROUTES in mcaptcha - Rust

Constant mcaptcha::WIDGET_ROUTES[−][src]

pub const WIDGET_ROUTES: Widget;
+ + \ No newline at end of file diff --git a/mcaptcha/data/enum.SystemGroup.html b/mcaptcha/data/enum.SystemGroup.html index faa07b80..7493df9e 100644 --- a/mcaptcha/data/enum.SystemGroup.html +++ b/mcaptcha/data/enum.SystemGroup.html @@ -1,114 +1,112 @@ -SystemGroup in mcaptcha::data - Rust - -

Enum mcaptcha::data::SystemGroup[−][src]

pub enum SystemGroup {
+SystemGroup in mcaptcha::data - Rust
Enum mcaptcha::data::SystemGroup[−][src]
pub enum SystemGroup {
     Embedded(System<HashCache, EmbeddedMaster>),
     Redis(System<RedisCache, RedisMaster>),
 }
Expand description
Represents mCaptcha cache and master system.
 When Redis is configured, SystemGroup::Redis is used and
 in its absense, SystemGroup::Embedded is used

-

-                   Variants

-
Embedded(System<HashCache, EmbeddedMaster>)
Redis(System<RedisCache, RedisMaster>)
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
Variants
Embedded(System<HashCache, EmbeddedMaster>)
Redis(System<RedisCache, RedisMaster>)
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/data/index.html b/mcaptcha/data/index.html index c18ce891..4ad842d7 100644 --- a/mcaptcha/data/index.html +++ b/mcaptcha/data/index.html @@ -1,12 +1,12 @@ -mcaptcha::data - Rust - -

Module mcaptcha::data[−][src]

Expand description

App data: redis cache, database connections, etc.

+mcaptcha::data - Rust

Module mcaptcha::data[−][src]

Expand description

App data: redis cache, database connections, etc.

Structs

-
Data

App data

-

Enums

-
SystemGroup

Represents mCaptcha cache and master system. +

Data

App data

+

Enums

+
SystemGroup

Represents mCaptcha cache and master system. When Redis is configured, SystemGroup::Redis is used and in its absense, SystemGroup::Embedded is used

-

Type Definitions

-
Mailer

Mailer data type AsyncSmtpTransport

-
\ No newline at end of file +

Type Definitions

+
Mailer

Mailer data type AsyncSmtpTransport

+
+ + \ No newline at end of file diff --git a/mcaptcha/data/struct.Data.html b/mcaptcha/data/struct.Data.html index bf405d1a..0477416a 100644 --- a/mcaptcha/data/struct.Data.html +++ b/mcaptcha/data/struct.Data.html @@ -1,118 +1,117 @@ -Data in mcaptcha::data - Rust - -

Struct mcaptcha::data::Data[−][src]

pub struct Data {
+Data in mcaptcha::data - Rust
Struct mcaptcha::data::Data[−][src]
pub struct Data {
     pub db: PgPool,
     pub creds: Config,
     pub captcha: SystemGroup,
-    pub mailer: Option<AsyncSmtpTransport<Tokio1Executor>>,
+    pub mailer: Option<AsyncSmtpTransport<Tokio1Executor>>,
 }
Expand description
App data

-

-                       Fields
db: PgPool
databse pool

+
Fields
db: PgPool
databse pool

 
creds: Config
credential management configuration

 
captcha: SystemGroup
mCaptcha system: Redis cache, etc.

-
mailer: Option<AsyncSmtpTransport<Tokio1Executor>>
email client

-
Implementations
create new instance of app data

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
mailer: Option<AsyncSmtpTransport<Tokio1Executor>>
email client

+
Implementations
create new instance of app data

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/data/type.Mailer.html b/mcaptcha/data/type.Mailer.html index fd876d51..e4f203d5 100644 --- a/mcaptcha/data/type.Mailer.html +++ b/mcaptcha/data/type.Mailer.html @@ -1,4 +1,4 @@ -Mailer in mcaptcha::data - Rust - -

Type Definition mcaptcha::data::Mailer[−][src]

type Mailer = AsyncSmtpTransport<Tokio1Executor>;
Expand description

Mailer data type AsyncSmtpTransport

-
\ No newline at end of file +Mailer in mcaptcha::data - Rust

Type Definition mcaptcha::data::Mailer[−][src]

pub type Mailer = AsyncSmtpTransport<Tokio1Executor>;
Expand description

Mailer data type AsyncSmtpTransport

+
+ + \ No newline at end of file diff --git a/mcaptcha/date/constant.DAY.html b/mcaptcha/date/constant.DAY.html index 3a9f4fb0..3c4543dd 100644 --- a/mcaptcha/date/constant.DAY.html +++ b/mcaptcha/date/constant.DAY.html @@ -1,3 +1,3 @@ -DAY in mcaptcha::date - Rust - -

Constant mcaptcha::date::DAY[−][src]

pub const DAY: i64 = HOUR * 24; // 86_400i64
\ No newline at end of file +DAY in mcaptcha::date - Rust

Constant mcaptcha::date::DAY[−][src]

pub const DAY: i64 = HOUR * 24; // 86_400i64
+ + \ No newline at end of file diff --git a/mcaptcha/date/constant.HOUR.html b/mcaptcha/date/constant.HOUR.html index f27012f4..12d5405c 100644 --- a/mcaptcha/date/constant.HOUR.html +++ b/mcaptcha/date/constant.HOUR.html @@ -1,3 +1,3 @@ -HOUR in mcaptcha::date - Rust - -

Constant mcaptcha::date::HOUR[−][src]

pub const HOUR: i64 = MINUTE * 60; // 3_600i64
\ No newline at end of file +HOUR in mcaptcha::date - Rust

Constant mcaptcha::date::HOUR[−][src]

pub const HOUR: i64 = MINUTE * 60; // 3_600i64
+ + \ No newline at end of file diff --git a/mcaptcha/date/constant.MINUTE.html b/mcaptcha/date/constant.MINUTE.html index 5d4f5ddc..2b5208e3 100644 --- a/mcaptcha/date/constant.MINUTE.html +++ b/mcaptcha/date/constant.MINUTE.html @@ -1,3 +1,3 @@ -MINUTE in mcaptcha::date - Rust - -

Constant mcaptcha::date::MINUTE[−][src]

pub const MINUTE: i64 = 60;
\ No newline at end of file +MINUTE in mcaptcha::date - Rust

Constant mcaptcha::date::MINUTE[−][src]

pub const MINUTE: i64 = 60;
+ + \ No newline at end of file diff --git a/mcaptcha/date/constant.WEEK.html b/mcaptcha/date/constant.WEEK.html index 11a105db..4ba8c39b 100644 --- a/mcaptcha/date/constant.WEEK.html +++ b/mcaptcha/date/constant.WEEK.html @@ -1,3 +1,3 @@ -WEEK in mcaptcha::date - Rust - -

Constant mcaptcha::date::WEEK[−][src]

pub const WEEK: i64 = DAY * 7; // 604_800i64
\ No newline at end of file +WEEK in mcaptcha::date - Rust

Constant mcaptcha::date::WEEK[−][src]

pub const WEEK: i64 = DAY * 7; // 604_800i64
+ + \ No newline at end of file diff --git a/mcaptcha/date/index.html b/mcaptcha/date/index.html index 55ca5b94..b1b8b38f 100644 --- a/mcaptcha/date/index.html +++ b/mcaptcha/date/index.html @@ -1,5 +1,5 @@ -mcaptcha::date - Rust - -

Module mcaptcha::date[−][src]

Structs

-
Date

Constants

-
DAY
HOUR
MINUTE
WEEK
\ No newline at end of file +mcaptcha::date - Rust

Module mcaptcha::date[−][src]

Structs

+
Date

Constants

+
DAY
HOUR
MINUTE
WEEK
+ + \ No newline at end of file diff --git a/mcaptcha/date/struct.Date.html b/mcaptcha/date/struct.Date.html index b6bc3a2b..468010f4 100644 --- a/mcaptcha/date/struct.Date.html +++ b/mcaptcha/date/struct.Date.html @@ -1,118 +1,117 @@ -Date in mcaptcha::date - Rust - -

Struct mcaptcha::date::Date[−][src]

pub struct Date {
+Date in mcaptcha::date - Rust
Struct mcaptcha::date::Date[−][src]
pub struct Date {
     pub time: OffsetDateTime,
-}

-                       Fields
time: OffsetDateTime
Implementations
print relative time from date

-
print date

-
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

time: OffsetDateTime

Implementations

print relative time from date

+

print date

+

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/demo/constant.DEMO_PASSWORD.html b/mcaptcha/demo/constant.DEMO_PASSWORD.html index efe6022e..5dcb5cc5 100644 --- a/mcaptcha/demo/constant.DEMO_PASSWORD.html +++ b/mcaptcha/demo/constant.DEMO_PASSWORD.html @@ -1,4 +1,4 @@ -DEMO_PASSWORD in mcaptcha::demo - Rust - -

Constant mcaptcha::demo::DEMO_PASSWORD[−][src]

pub const DEMO_PASSWORD: &str = "password";
Expand description

Demo password

-
\ No newline at end of file +DEMO_PASSWORD in mcaptcha::demo - Rust

Constant mcaptcha::demo::DEMO_PASSWORD[−][src]

pub const DEMO_PASSWORD: &str = "password";
Expand description

Demo password

+
+ + \ No newline at end of file diff --git a/mcaptcha/demo/constant.DEMO_USER.html b/mcaptcha/demo/constant.DEMO_USER.html index 2a418235..027fcb6a 100644 --- a/mcaptcha/demo/constant.DEMO_USER.html +++ b/mcaptcha/demo/constant.DEMO_USER.html @@ -1,4 +1,4 @@ -DEMO_USER in mcaptcha::demo - Rust - -

Constant mcaptcha::demo::DEMO_USER[−][src]

pub const DEMO_USER: &str = "aaronsw";
Expand description

Demo username

-
\ No newline at end of file +DEMO_USER in mcaptcha::demo - Rust

Constant mcaptcha::demo::DEMO_USER[−][src]

pub const DEMO_USER: &str = "aaronsw";
Expand description

Demo username

+
+ + \ No newline at end of file diff --git a/mcaptcha/demo/fn.delete_demo_user.html b/mcaptcha/demo/fn.delete_demo_user.html index 4de450bd..b42c1c99 100644 --- a/mcaptcha/demo/fn.delete_demo_user.html +++ b/mcaptcha/demo/fn.delete_demo_user.html @@ -1,3 +1,3 @@ -delete_demo_user in mcaptcha::demo - Rust - -

Function mcaptcha::demo::delete_demo_user[−][src]

async fn delete_demo_user(data: &AppData) -> Result<(), ServiceError>
\ No newline at end of file +delete_demo_user in mcaptcha::demo - Rust

Function mcaptcha::demo::delete_demo_user[−][src]

async fn delete_demo_user(data: &AppData) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/demo/fn.register_demo_user.html b/mcaptcha/demo/fn.register_demo_user.html index 6e2832b3..7a6d5989 100644 --- a/mcaptcha/demo/fn.register_demo_user.html +++ b/mcaptcha/demo/fn.register_demo_user.html @@ -1,4 +1,4 @@ -register_demo_user in mcaptcha::demo - Rust - -

Function mcaptcha::demo::register_demo_user[−][src]

async fn register_demo_user(data: &AppData) -> Result<(), ServiceError>
Expand description

register demo user runner

-
\ No newline at end of file +register_demo_user in mcaptcha::demo - Rust

Function mcaptcha::demo::register_demo_user[−][src]

async fn register_demo_user(data: &AppData) -> Result<(), ServiceError>
Expand description

register demo user runner

+
+ + \ No newline at end of file diff --git a/mcaptcha/demo/fn.run.html b/mcaptcha/demo/fn.run.html index a0967896..7bf285e9 100644 --- a/mcaptcha/demo/fn.run.html +++ b/mcaptcha/demo/fn.run.html @@ -1,3 +1,3 @@ -run in mcaptcha::demo - Rust - -

Function mcaptcha::demo::run[−][src]

pub async fn run(data: AppData, duration: Duration) -> Result<(), ServiceError>
\ No newline at end of file +run in mcaptcha::demo - Rust

Function mcaptcha::demo::run[−][src]

pub async fn run(data: AppData, duration: Duration) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/demo/index.html b/mcaptcha/demo/index.html index 13621c76..7021ea87 100644 --- a/mcaptcha/demo/index.html +++ b/mcaptcha/demo/index.html @@ -1,8 +1,8 @@ -mcaptcha::demo - Rust - -

Module mcaptcha::demo[−][src]

Constants

-
DEMO_PASSWORD

Demo password

-
DEMO_USER

Demo username

-

Functions

-
delete_demo_user
register_demo_user

register demo user runner

-
run
\ No newline at end of file +mcaptcha::demo - Rust

Module mcaptcha::demo[−][src]

Constants

+
DEMO_PASSWORD

Demo password

+
DEMO_USER

Demo username

+

Functions

+
delete_demo_user
register_demo_user

register demo user runner

+
run
+ + \ No newline at end of file diff --git a/mcaptcha/docs/constant.DOCS.html b/mcaptcha/docs/constant.DOCS.html index 2e25c0b0..a2550770 100644 --- a/mcaptcha/docs/constant.DOCS.html +++ b/mcaptcha/docs/constant.DOCS.html @@ -1,3 +1,3 @@ -DOCS in mcaptcha::docs - Rust - -

Constant mcaptcha::docs::DOCS[−][src]

pub const DOCS: Docs;
\ No newline at end of file +DOCS in mcaptcha::docs - Rust

Constant mcaptcha::docs::DOCS[−][src]

pub const DOCS: Docs;
+ + \ No newline at end of file diff --git a/mcaptcha/docs/fn.handle_embedded_file.html b/mcaptcha/docs/fn.handle_embedded_file.html index 0f41689b..8fd1d203 100644 --- a/mcaptcha/docs/fn.handle_embedded_file.html +++ b/mcaptcha/docs/fn.handle_embedded_file.html @@ -1,3 +1,3 @@ -handle_embedded_file in mcaptcha::docs - Rust - -

Function mcaptcha::docs::handle_embedded_file[−][src]

pub fn handle_embedded_file(path: &str) -> HttpResponse
\ No newline at end of file +handle_embedded_file in mcaptcha::docs - Rust

Function mcaptcha::docs::handle_embedded_file[−][src]

pub fn handle_embedded_file(path: &str) -> HttpResponse
+ + \ No newline at end of file diff --git a/mcaptcha/docs/fn.services.html b/mcaptcha/docs/fn.services.html index 50ef9c0a..5fbdfb30 100644 --- a/mcaptcha/docs/fn.services.html +++ b/mcaptcha/docs/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::docs - Rust - -

Function mcaptcha::docs::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::docs - Rust

Function mcaptcha::docs::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/docs/index.html b/mcaptcha/docs/index.html index ab1538e6..21bb95fa 100644 --- a/mcaptcha/docs/index.html +++ b/mcaptcha/docs/index.html @@ -1,7 +1,7 @@ -mcaptcha::docs - Rust - -

Module mcaptcha::docs[−][src]

Modules

-
routes

Structs

-
Asset
dist
index
spec

Constants

-
DOCS

Functions

-
handle_embedded_file
services
\ No newline at end of file +mcaptcha::docs - Rust

Module mcaptcha::docs[−][src]

Modules

+
routes

Structs

+
Asset
dist
index
spec

Constants

+
DOCS

Functions

+
handle_embedded_file
services
+ + \ No newline at end of file diff --git a/mcaptcha/docs/routes/index.html b/mcaptcha/docs/routes/index.html index 2d2c5c1d..877dbce7 100644 --- a/mcaptcha/docs/routes/index.html +++ b/mcaptcha/docs/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::docs::routes - Rust - -

Module mcaptcha::docs::routes[−][src]

Structs

-
Docs
\ No newline at end of file +mcaptcha::docs::routes - Rust

Module mcaptcha::docs::routes[−][src]

Structs

+
Docs
+ + \ No newline at end of file diff --git a/mcaptcha/docs/routes/struct.Docs.html b/mcaptcha/docs/routes/struct.Docs.html index 65f32f45..aabf53af 100644 --- a/mcaptcha/docs/routes/struct.Docs.html +++ b/mcaptcha/docs/routes/struct.Docs.html @@ -1,111 +1,110 @@ -Docs in mcaptcha::docs::routes - Rust - -

Struct mcaptcha::docs::routes::Docs[−][src]

pub struct Docs {
-    pub home: &'static str,
-    pub spec: &'static str,
-    pub assets: &'static str,
-}

- Fields

home: &'static strspec: &'static strassets: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Docs in mcaptcha::docs::routes - Rust

Struct mcaptcha::docs::routes::Docs[−][src]

pub struct Docs {
+    pub home: &'static str,
+    pub spec: &'static str,
+    pub assets: &'static str,
+}

Fields

home: &'static strspec: &'static strassets: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/docs/struct.Asset.html b/mcaptcha/docs/struct.Asset.html index dd780f9b..c9403dc6 100644 --- a/mcaptcha/docs/struct.Asset.html +++ b/mcaptcha/docs/struct.Asset.html @@ -1,108 +1,108 @@ -Asset in mcaptcha::docs - Rust - -

Struct mcaptcha::docs::Asset[−][src]

struct Asset;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

-

Iterates over the file paths in the folder. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Asset in mcaptcha::docs - Rust

Struct mcaptcha::docs::Asset[−][src]

struct Asset;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

+

Iterates over the file paths in the folder. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/docs/struct.dist.html b/mcaptcha/docs/struct.dist.html index 8cc24486..b7bbfe46 100644 --- a/mcaptcha/docs/struct.dist.html +++ b/mcaptcha/docs/struct.dist.html @@ -1,106 +1,106 @@ -dist in mcaptcha::docs - Rust - -

Struct mcaptcha::docs::dist[−][src]

pub struct dist;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +dist in mcaptcha::docs - Rust

Struct mcaptcha::docs::dist[−][src]

pub struct dist;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/docs/struct.index.html b/mcaptcha/docs/struct.index.html index 2f1e9eef..242201ab 100644 --- a/mcaptcha/docs/struct.index.html +++ b/mcaptcha/docs/struct.index.html @@ -1,106 +1,106 @@ -index in mcaptcha::docs - Rust - -

Struct mcaptcha::docs::index[−][src]

pub struct index;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +index in mcaptcha::docs - Rust

Struct mcaptcha::docs::index[−][src]

pub struct index;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/docs/struct.spec.html b/mcaptcha/docs/struct.spec.html index f1ea09c1..24745ebe 100644 --- a/mcaptcha/docs/struct.spec.html +++ b/mcaptcha/docs/struct.spec.html @@ -1,106 +1,106 @@ -spec in mcaptcha::docs - Rust - -

Struct mcaptcha::docs::spec[−][src]

pub struct spec;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +spec in mcaptcha::docs - Rust

Struct mcaptcha::docs::spec[−][src]

pub struct spec;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/email/index.html b/mcaptcha/email/index.html index 07824e26..01f4edf9 100644 --- a/mcaptcha/email/index.html +++ b/mcaptcha/email/index.html @@ -1,5 +1,5 @@ -mcaptcha::email - Rust - -

Module mcaptcha::email[−][src]

Modules

-
verification

Email operations: verification, notification, etc

-
\ No newline at end of file +mcaptcha::email - Rust

Module mcaptcha::email[−][src]

Modules

+
verification

Email operations: verification, notification, etc

+
+ + \ No newline at end of file diff --git a/mcaptcha/email/verification/constant.PAGE.html b/mcaptcha/email/verification/constant.PAGE.html index ee61b4f1..d9d9576e 100644 --- a/mcaptcha/email/verification/constant.PAGE.html +++ b/mcaptcha/email/verification/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::email::verification - Rust - -

Constant mcaptcha::email::verification::PAGE[−][src]

const PAGE: &str = "Login";
\ No newline at end of file +PAGE in mcaptcha::email::verification - Rust

Constant mcaptcha::email::verification::PAGE[−][src]

const PAGE: &str = "Login";
+ + \ No newline at end of file diff --git a/mcaptcha/email/verification/fn.verification.html b/mcaptcha/email/verification/fn.verification.html index 8c5ac312..99b8c802 100644 --- a/mcaptcha/email/verification/fn.verification.html +++ b/mcaptcha/email/verification/fn.verification.html @@ -1,3 +1,3 @@ -verification in mcaptcha::email::verification - Rust - -

Function mcaptcha::email::verification::verification[−][src]

async fn verification(
    data: &Data, 
    to: &str, 
    verification_link: &str
) -> Result<(), ServiceError>
\ No newline at end of file +verification in mcaptcha::email::verification - Rust

Function mcaptcha::email::verification::verification[−][src]

async fn verification(
    data: &Data, 
    to: &str, 
    verification_link: &str
) -> Result<(), ServiceError>
+ + \ No newline at end of file diff --git a/mcaptcha/email/verification/index.html b/mcaptcha/email/verification/index.html index 9fd81142..233cf011 100644 --- a/mcaptcha/email/verification/index.html +++ b/mcaptcha/email/verification/index.html @@ -1,7 +1,7 @@ -mcaptcha::email::verification - Rust - -

Module mcaptcha::email::verification[−][src]

Expand description

Email operations: verification, notification, etc

+mcaptcha::email::verification - Rust

Module mcaptcha::email::verification[−][src]

Expand description

Email operations: verification, notification, etc

Structs

-
IndexPage

Constants

-
PAGE

Functions

-
verification
\ No newline at end of file +
IndexPage

Constants

+
PAGE

Functions

+
verification
+ + \ No newline at end of file diff --git a/mcaptcha/email/verification/struct.IndexPage.html b/mcaptcha/email/verification/struct.IndexPage.html index baca20fa..c019ae58 100644 --- a/mcaptcha/email/verification/struct.IndexPage.html +++ b/mcaptcha/email/verification/struct.IndexPage.html @@ -1,117 +1,116 @@ -IndexPage in mcaptcha::email::verification - Rust - -

Struct mcaptcha::email::verification::IndexPage[−][src]

struct IndexPage<'a> {
-    verification_link: &'a str,
-}

- Fields

verification_link: &'a str

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::email::verification - Rust

Struct mcaptcha::email::verification::IndexPage[−][src]

struct IndexPage<'a> {
+    verification_link: &'a str,
+}

Fields

verification_link: &'a str

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/errors/enum.PageError.html b/mcaptcha/errors/enum.PageError.html index c693fe13..95fee02a 100644 --- a/mcaptcha/errors/enum.PageError.html +++ b/mcaptcha/errors/enum.PageError.html @@ -1,125 +1,123 @@ -PageError in mcaptcha::errors - Rust - -

Enum mcaptcha::errors::PageError[−][src]

pub enum PageError {
+PageError in mcaptcha::errors - Rust
Enum mcaptcha::errors::PageError[−][src]
pub enum PageError {
     InternalServerError,
     ServiceError(ServiceError),
-}

-                   Variants

-
InternalServerError
ServiceError(ServiceError)
Trait Implementations
Formats the value using the given formatter. Read more

-
Formats the value using the given formatter. Read more

-
The lower-level source of this error, if any. Read more

-
🔬 This is a nightly-only experimental API. (backtrace)
Returns a stack backtrace, if available, of where this error occurred. Read more

-
👎 Deprecated since 1.42.0: 
use the Display impl or to_string()

-
 Read more
👎 Deprecated since 1.33.0: 
replaced by Error::source, which can support downcasting

-
Performs the conversion.

-
Performs the conversion.

-
This method tests for self and other values to be equal, and is used
-by ==. Read more

-
This method tests for !=.

-
Creates full response for error. Read more

-
Returns appropriate status code for error. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Variants

InternalServerError
ServiceError(ServiceError)

Trait Implementations

Formats the value using the given formatter. Read more

+

Formats the value using the given formatter. Read more

+

The lower-level source of this error, if any. Read more

+
🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

+
👎 Deprecated since 1.42.0:

use the Display impl or to_string()

+
Read more
👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

+

Performs the conversion.

+

Performs the conversion.

+

This method tests for self and other values to be equal, and is used +by ==. Read more

+

This method tests for !=.

+

Creates full response for error. Read more

+

Returns appropriate status code for error. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Converts the given value to a String. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Converts the given value to a String. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/errors/enum.ServiceError.html b/mcaptcha/errors/enum.ServiceError.html index 45ccc3a6..f857046e 100644 --- a/mcaptcha/errors/enum.ServiceError.html +++ b/mcaptcha/errors/enum.ServiceError.html @@ -1,7 +1,5 @@ -ServiceError in mcaptcha::errors - Rust - -

Enum mcaptcha::errors::ServiceError[−][src]

pub enum ServiceError {
-
Show variants    InternalServerError,
+ServiceError in mcaptcha::errors - Rust
Enum mcaptcha::errors::ServiceError[−][src]
pub enum ServiceError {
+
Show 18 variants    InternalServerError,
     ClosedForRegistration,
     NotAnEmail,
     NotAUrl,
@@ -19,9 +17,7 @@
     UnableToSendEmail(SmtpErrorWrapper),
     TokenNotFound,
     CaptchaError(CaptchaError),
-
}

-                   Variants

-
InternalServerError
ClosedForRegistration
NotAnEmail
NotAUrl
WrongPassword
UsernameNotFound
AccountNotFound
ProfainityError
when the value passed contains profainity

+
}

Variants

InternalServerError
ClosedForRegistration
NotAnEmail
NotAUrl
WrongPassword
UsernameNotFound
AccountNotFound
ProfainityError

when the value passed contains profainity

BlacklistError

when the value passed contains blacklisted words see blacklist

UsernameCaseMappedError

when the value passed contains characters not present @@ -32,128 +28,130 @@ profile

UnableToSendEmail(SmtpErrorWrapper)

Unable to send email

TokenNotFound

when the a token name is already taken token not found

-
CaptchaError(CaptchaError)

Trait Implementations

Formats the value using the given formatter. Read more

-

Formats the value using the given formatter. Read more

-

The lower-level source of this error, if any. Read more

-
🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

-
👎 Deprecated since 1.42.0:

use the Display impl or to_string()

-
Read more
👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

Performs the conversion.

-

This method tests for self and other values to be equal, and is used -by ==. Read more

-

This method tests for !=.

-

Creates full response for error. Read more

-

Returns appropriate status code for error. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

CaptchaError(CaptchaError)

Trait Implementations

Formats the value using the given formatter. Read more

+

Formats the value using the given formatter. Read more

+

The lower-level source of this error, if any. Read more

+
🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

+
👎 Deprecated since 1.42.0:

use the Display impl or to_string()

+
Read more
👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

Performs the conversion.

+

This method tests for self and other values to be equal, and is used +by ==. Read more

+

This method tests for !=.

+

Creates full response for error. Read more

+

Returns appropriate status code for error. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Converts the given value to a String. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Converts the given value to a String. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/errors/index.html b/mcaptcha/errors/index.html index 62d28d96..eb271216 100644 --- a/mcaptcha/errors/index.html +++ b/mcaptcha/errors/index.html @@ -1,6 +1,6 @@ -mcaptcha::errors - Rust - -

Module mcaptcha::errors[−][src]

Structs

-
ErrorToResponse
SmtpErrorWrapper

Enums

-
PageError
ServiceError

Type Definitions

-
PageResult
ServiceResult
\ No newline at end of file +mcaptcha::errors - Rust

Module mcaptcha::errors[−][src]

Structs

+
ErrorToResponse
SmtpErrorWrapper

Enums

+
PageError
ServiceError

Type Definitions

+
PageResult
ServiceResult
+ + \ No newline at end of file diff --git a/mcaptcha/errors/struct.ErrorToResponse.html b/mcaptcha/errors/struct.ErrorToResponse.html index ed9c7fab..4f69ae2c 100644 --- a/mcaptcha/errors/struct.ErrorToResponse.html +++ b/mcaptcha/errors/struct.ErrorToResponse.html @@ -1,111 +1,110 @@ -ErrorToResponse in mcaptcha::errors - Rust - -

Struct mcaptcha::errors::ErrorToResponse[−][src]

pub struct ErrorToResponse {
-    pub error: String,
-}

- Fields

error: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +ErrorToResponse in mcaptcha::errors - Rust

Struct mcaptcha::errors::ErrorToResponse[−][src]

pub struct ErrorToResponse {
+    pub error: String,
+}

Fields

error: String

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/errors/struct.SmtpErrorWrapper.html b/mcaptcha/errors/struct.SmtpErrorWrapper.html index f9e6b478..b936a672 100644 --- a/mcaptcha/errors/struct.SmtpErrorWrapper.html +++ b/mcaptcha/errors/struct.SmtpErrorWrapper.html @@ -1,116 +1,116 @@ -SmtpErrorWrapper in mcaptcha::errors - Rust - -

Struct mcaptcha::errors::SmtpErrorWrapper[−][src]

pub struct SmtpErrorWrapper(SmtpError);

Trait Implementations

Formats the value using the given formatter. Read more

-

Formats the value using the given formatter. Read more

-

The lower-level source of this error, if any. Read more

-
🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

-
👎 Deprecated since 1.42.0:

use the Display impl or to_string()

-
Read more
👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

-

This method tests for self and other values to be equal, and is used -by ==. Read more

-

This method tests for !=.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SmtpErrorWrapper in mcaptcha::errors - Rust

Struct mcaptcha::errors::SmtpErrorWrapper[−][src]

pub struct SmtpErrorWrapper(SmtpError);

Trait Implementations

Formats the value using the given formatter. Read more

+

Formats the value using the given formatter. Read more

+

The lower-level source of this error, if any. Read more

+
🔬 This is a nightly-only experimental API. (backtrace)

Returns a stack backtrace, if available, of where this error occurred. Read more

+
👎 Deprecated since 1.42.0:

use the Display impl or to_string()

+
Read more
👎 Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

+

This method tests for self and other values to be equal, and is used +by ==. Read more

+

This method tests for !=.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Converts the given value to a String. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Converts the given value to a String. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/errors/type.PageResult.html b/mcaptcha/errors/type.PageResult.html index caaaa805..136755ad 100644 --- a/mcaptcha/errors/type.PageResult.html +++ b/mcaptcha/errors/type.PageResult.html @@ -1,3 +1,3 @@ -PageResult in mcaptcha::errors - Rust - -

Type Definition mcaptcha::errors::PageResult[−][src]

type PageResult<V> = Result<V, PageError>;
\ No newline at end of file +PageResult in mcaptcha::errors - Rust

Type Definition mcaptcha::errors::PageResult[−][src]

pub type PageResult<V> = Result<V, PageError>;
+ + \ No newline at end of file diff --git a/mcaptcha/errors/type.ServiceResult.html b/mcaptcha/errors/type.ServiceResult.html index 9298d367..1cf433b7 100644 --- a/mcaptcha/errors/type.ServiceResult.html +++ b/mcaptcha/errors/type.ServiceResult.html @@ -1,3 +1,3 @@ -ServiceResult in mcaptcha::errors - Rust - -

Type Definition mcaptcha::errors::ServiceResult[−][src]

type ServiceResult<V> = Result<V, ServiceError>;
\ No newline at end of file +ServiceResult in mcaptcha::errors - Rust

Type Definition mcaptcha::errors::ServiceResult[−][src]

pub type ServiceResult<V> = Result<V, ServiceError>;
+ + \ No newline at end of file diff --git a/mcaptcha/fn.get_identity_service.html b/mcaptcha/fn.get_identity_service.html index dbb14d95..8c3a1794 100644 --- a/mcaptcha/fn.get_identity_service.html +++ b/mcaptcha/fn.get_identity_service.html @@ -1,3 +1,3 @@ -get_identity_service in mcaptcha - Rust - -

Function mcaptcha::get_identity_service[−][src]

pub fn get_identity_service() -> IdentityService<CookieIdentityPolicy>
\ No newline at end of file +get_identity_service in mcaptcha - Rust

Function mcaptcha::get_identity_service[−][src]

pub fn get_identity_service() -> IdentityService<CookieIdentityPolicy>
+ + \ No newline at end of file diff --git a/mcaptcha/fn.get_json_err.html b/mcaptcha/fn.get_json_err.html index fc9a8201..6205aa31 100644 --- a/mcaptcha/fn.get_json_err.html +++ b/mcaptcha/fn.get_json_err.html @@ -1,3 +1,3 @@ -get_json_err in mcaptcha - Rust - -

Function mcaptcha::get_json_err[−][src]

pub fn get_json_err() -> JsonConfig
\ No newline at end of file +get_json_err in mcaptcha - Rust

Function mcaptcha::get_json_err[−][src]

pub fn get_json_err() -> JsonConfig
+ + \ No newline at end of file diff --git a/mcaptcha/fn.main.html b/mcaptcha/fn.main.html index f6606d0f..e35c5861 100644 --- a/mcaptcha/fn.main.html +++ b/mcaptcha/fn.main.html @@ -1,3 +1,3 @@ -main in mcaptcha - Rust - -

Function mcaptcha::main[−][src]

pub(crate) fn main() -> Result<()>
\ No newline at end of file +main in mcaptcha - Rust

Function mcaptcha::main[−][src]

pub(crate) fn main() -> Result<()>
+ + \ No newline at end of file diff --git a/mcaptcha/index.html b/mcaptcha/index.html index 6e440567..d6541422 100644 --- a/mcaptcha/index.html +++ b/mcaptcha/index.html @@ -1,14 +1,14 @@ -mcaptcha - Rust - -

Crate mcaptcha[−][src]

Modules

-
api
data

App data: redis cache, database connections, etc.

-
date
demo
docs
email
errors
middleware
pages
routes
settings
static_assets
stats
widget

User facing CAPTCHA widget

-

Macros

-
define_resource

Defines resoures for Methods

-

Structs

-
BAR_CHART
CREDIT_CARD
CSS
CheckLogin
DOCS_ICON
Data

App data

-
FILES
GITHUB
HELP_CIRCLE
HOME
JS
KEY
MCAPTCHA_TRANS_ICON
MESSAGE
MOBILE_CSS
SETTINGS
SETTINGS_ICON
SOURCE_FILES_OF_INSTANCE

points to source files matching build commit

-
Settings
VERIFICATIN_WIDGET_CSS
VERIFICATIN_WIDGET_JS

Constants

-
CACHE_AGE
COMPILED_DATE
DOCS
GIT_COMMIT_HASH
OPEN_API_DOC
PAGES
PKG_DESCRIPTION
PKG_HOMEPAGE
PKG_NAME
V1_API_ROUTES
VERSION
WIDGET_ROUTES

Functions

-
get_identity_service
get_json_err
main

Type Definitions

-
AppData
\ No newline at end of file +mcaptcha - Rust

Crate mcaptcha[−][src]

Modules

+
api
data

App data: redis cache, database connections, etc.

+
date
demo
docs
email
errors
middleware
pages
routes
settings
static_assets
stats
widget

User facing CAPTCHA widget

+

Macros

+
define_resource

Defines resoures for Methods

+

Structs

+
BAR_CHART
CREDIT_CARD
CSS
CheckLogin
DOCS_ICON
Data

App data

+
FILES
GITHUB
HELP_CIRCLE
HOME
JS
KEY
MCAPTCHA_TRANS_ICON
MESSAGE
MOBILE_CSS
SETTINGS
SETTINGS_ICON
SOURCE_FILES_OF_INSTANCE

points to source files matching build commit

+
Settings
VERIFICATIN_WIDGET_CSS
VERIFICATIN_WIDGET_JS

Constants

+
CACHE_AGE
COMPILED_DATE
DOCS
GIT_COMMIT_HASH
OPEN_API_DOC
PAGES
PKG_DESCRIPTION
PKG_HOMEPAGE
PKG_NAME
V1_API_ROUTES
VERSION
WIDGET_ROUTES

Functions

+
get_identity_service
get_json_err
main

Type Definitions

+
AppData
+ + \ No newline at end of file diff --git a/mcaptcha/macro.define_resource.html b/mcaptcha/macro.define_resource.html index ab82b8f6..7b96b4e2 100644 --- a/mcaptcha/macro.define_resource.html +++ b/mcaptcha/macro.define_resource.html @@ -1,11 +1,11 @@ -define_resource in mcaptcha - Rust - -

Macro mcaptcha::define_resource[−][src]

+define_resource in mcaptcha - Rust
Macro mcaptcha::define_resource[−][src]
 macro_rules! define_resource {
-    ($cfg:expr, $path:expr, Methods::Get, $to:expr) => { ... };
-    ($cfg:expr, $path:expr, Methods::Post, $to:expr) => { ... };
-    ($cfg:expr, $path:expr, Methods::ProtectPost, $to:expr) => { ... };
-    ($cfg:expr, $path:expr, Methods::ProtectGet, $to:expr) => { ... };
+    ($cfg : expr, $path : expr, Methods :: Get, $to : expr) => { ... };
+    ($cfg : expr, $path : expr, Methods :: Post, $to : expr) => { ... };
+    ($cfg : expr, $path : expr, Methods :: ProtectPost, $to : expr) => { ... };
+    ($cfg : expr, $path : expr, Methods :: ProtectGet, $to : expr) => { ... };
 }

 
Expand description
Defines resoures for Methods

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/mcaptcha/middleware/auth/index.html b/mcaptcha/middleware/auth/index.html index 61b4343a..22ba62c8 100644 --- a/mcaptcha/middleware/auth/index.html +++ b/mcaptcha/middleware/auth/index.html @@ -1,4 +1,4 @@ -mcaptcha::middleware::auth - Rust - -

Module mcaptcha::middleware::auth[−][src]

Structs

-
CheckLogin
CheckLoginMiddleware
\ No newline at end of file +mcaptcha::middleware::auth - Rust

Module mcaptcha::middleware::auth[−][src]

Structs

+
CheckLogin
CheckLoginMiddleware
+ + \ No newline at end of file diff --git a/mcaptcha/middleware/auth/struct.CheckLogin.html b/mcaptcha/middleware/auth/struct.CheckLogin.html index 637aa7b6..116f49e0 100644 --- a/mcaptcha/middleware/auth/struct.CheckLogin.html +++ b/mcaptcha/middleware/auth/struct.CheckLogin.html @@ -1,112 +1,112 @@ -CheckLogin in mcaptcha::middleware::auth - Rust - -

Struct mcaptcha::middleware::auth::CheckLogin[−][src]

pub struct CheckLogin;

Trait Implementations

Responses produced by the service.

-

Errors produced by the service.

-

The TransformService value created by this factory

-

Errors produced while building a transform service.

-

The future response value.

-

Creates and returns a new Transform component, asynchronously

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CheckLogin in mcaptcha::middleware::auth - Rust

Struct mcaptcha::middleware::auth::CheckLogin[−][src]

pub struct CheckLogin;

Trait Implementations

Responses produced by the service.

+

Errors produced by the service.

+

The TransformService value created by this factory

+

Errors produced while building a transform service.

+

The future response value.

+

Creates and returns a new Transform component, asynchronously

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/middleware/auth/struct.CheckLoginMiddleware.html b/mcaptcha/middleware/auth/struct.CheckLoginMiddleware.html index 951c6227..7c951eeb 100644 --- a/mcaptcha/middleware/auth/struct.CheckLoginMiddleware.html +++ b/mcaptcha/middleware/auth/struct.CheckLoginMiddleware.html @@ -1,119 +1,118 @@ -CheckLoginMiddleware in mcaptcha::middleware::auth - Rust - -

Struct mcaptcha::middleware::auth::CheckLoginMiddleware[−][src]

pub struct CheckLoginMiddleware<S> {
+CheckLoginMiddleware in mcaptcha::middleware::auth - Rust
Struct mcaptcha::middleware::auth::CheckLoginMiddleware[−][src]
pub struct CheckLoginMiddleware<S> {
     service: S,
-}

-                       Fields
service: S
Trait Implementations
Responses given by the service.

-
Errors produced by the service when polling readiness or executing call.

-
The future response value.

-
Returns Ready when the service is able to process requests. Read more

-
Process the request and return the response asynchronously. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

service: S

Trait Implementations

Responses given by the service.

+

Errors produced by the service when polling readiness or executing call.

+

The future response value.

+

Returns Ready when the service is able to process requests. Read more

+

Process the request and return the response asynchronously. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Convert to a Service

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Convert to a Service

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Map this service’s output to a different type, returning a new service +

Should always be Self

+

Map this service’s output to a different type, returning a new service of the resulting type. Read more

-

Map this service’s error to a different error, returning a new service. Read more

-

Call another service after call to this one has resolved successfully. Read more

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Map this service’s error to a different error, returning a new service. Read more

+

Call another service after call to this one has resolved successfully. Read more

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/middleware/index.html b/mcaptcha/middleware/index.html index 69c179ca..ea1b70b6 100644 --- a/mcaptcha/middleware/index.html +++ b/mcaptcha/middleware/index.html @@ -1,4 +1,4 @@ -mcaptcha::middleware - Rust - -

Module mcaptcha::middleware[−][src]

Modules

-
auth
\ No newline at end of file +mcaptcha::middleware - Rust

Module mcaptcha::middleware[−][src]

Modules

+
auth
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/fn.services.html b/mcaptcha/pages/auth/fn.services.html index b9adbcf0..3f970c07 100644 --- a/mcaptcha/pages/auth/fn.services.html +++ b/mcaptcha/pages/auth/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages::auth - Rust - -

Function mcaptcha::pages::auth::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages::auth - Rust

Function mcaptcha::pages::auth::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/index.html b/mcaptcha/pages/auth/index.html index e645affc..73ae4251 100644 --- a/mcaptcha/pages/auth/index.html +++ b/mcaptcha/pages/auth/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::auth - Rust - -

Module mcaptcha::pages::auth[−][src]

Modules

-
login
register
routes
sudo

Functions

-
services
\ No newline at end of file +mcaptcha::pages::auth - Rust

Module mcaptcha::pages::auth[−][src]

Modules

+
login
register
routes
sudo

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/login/constant.PAGE.html b/mcaptcha/pages/auth/login/constant.PAGE.html index 0b427fa8..ec370ce9 100644 --- a/mcaptcha/pages/auth/login/constant.PAGE.html +++ b/mcaptcha/pages/auth/login/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::auth::login - Rust - -

Constant mcaptcha::pages::auth::login::PAGE[−][src]

const PAGE: &str = "Login";
\ No newline at end of file +PAGE in mcaptcha::pages::auth::login - Rust

Constant mcaptcha::pages::auth::login::PAGE[−][src]

const PAGE: &str = "Login";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/login/index.html b/mcaptcha/pages/auth/login/index.html index 64bbe56a..48dff225 100644 --- a/mcaptcha/pages/auth/login/index.html +++ b/mcaptcha/pages/auth/login/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::auth::login - Rust - -

Module mcaptcha::pages::auth::login[−][src]

Structs

-
INDEX
IndexPage
login

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::auth::login - Rust

Module mcaptcha::pages::auth::login[−][src]

Structs

+
INDEX
IndexPage
login

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/login/struct.INDEX.html b/mcaptcha/pages/auth/login/struct.INDEX.html index 3dc5ac8f..d461ebc4 100644 --- a/mcaptcha/pages/auth/login/struct.INDEX.html +++ b/mcaptcha/pages/auth/login/struct.INDEX.html @@ -1,9 +1,6 @@ -INDEX in mcaptcha::pages::auth::login - Rust - -

Struct mcaptcha::pages::auth::login::INDEX[−][src]

struct INDEX {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INDEX in mcaptcha::pages::auth::login - Rust

Struct mcaptcha::pages::auth::login::INDEX[−][src]

struct INDEX {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/login/struct.IndexPage.html b/mcaptcha/pages/auth/login/struct.IndexPage.html index 2ea6d057..38bca4ad 100644 --- a/mcaptcha/pages/auth/login/struct.IndexPage.html +++ b/mcaptcha/pages/auth/login/struct.IndexPage.html @@ -1,115 +1,115 @@ -IndexPage in mcaptcha::pages::auth::login - Rust - -

Struct mcaptcha::pages::auth::login::IndexPage[−][src]

struct IndexPage;

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Returns the “default value” for a type. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::auth::login - Rust

Struct mcaptcha::pages::auth::login::IndexPage[−][src]

struct IndexPage;

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Returns the “default value” for a type. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/login/struct.login.html b/mcaptcha/pages/auth/login/struct.login.html index e85b9f36..eb81bb52 100644 --- a/mcaptcha/pages/auth/login/struct.login.html +++ b/mcaptcha/pages/auth/login/struct.login.html @@ -1,106 +1,106 @@ -login in mcaptcha::pages::auth::login - Rust - -

Struct mcaptcha::pages::auth::login::login[−][src]

pub struct login;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +login in mcaptcha::pages::auth::login - Rust

Struct mcaptcha::pages::auth::login::login[−][src]

pub struct login;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/register/constant.PAGE.html b/mcaptcha/pages/auth/register/constant.PAGE.html index 0849a5e5..5d3d647e 100644 --- a/mcaptcha/pages/auth/register/constant.PAGE.html +++ b/mcaptcha/pages/auth/register/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::auth::register - Rust - -

Constant mcaptcha::pages::auth::register::PAGE[−][src]

const PAGE: &str = "Join";
\ No newline at end of file +PAGE in mcaptcha::pages::auth::register - Rust

Constant mcaptcha::pages::auth::register::PAGE[−][src]

const PAGE: &str = "Join";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/register/index.html b/mcaptcha/pages/auth/register/index.html index f6d39ddc..a8a89d97 100644 --- a/mcaptcha/pages/auth/register/index.html +++ b/mcaptcha/pages/auth/register/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::auth::register - Rust - -

Module mcaptcha::pages::auth::register[−][src]

Structs

-
INDEX
IndexPage
join

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::auth::register - Rust

Module mcaptcha::pages::auth::register[−][src]

Structs

+
INDEX
IndexPage
join

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/register/struct.INDEX.html b/mcaptcha/pages/auth/register/struct.INDEX.html index efb24962..cd738674 100644 --- a/mcaptcha/pages/auth/register/struct.INDEX.html +++ b/mcaptcha/pages/auth/register/struct.INDEX.html @@ -1,9 +1,6 @@ -INDEX in mcaptcha::pages::auth::register - Rust - -

Struct mcaptcha::pages::auth::register::INDEX[−][src]

struct INDEX {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INDEX in mcaptcha::pages::auth::register - Rust

Struct mcaptcha::pages::auth::register::INDEX[−][src]

struct INDEX {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/register/struct.IndexPage.html b/mcaptcha/pages/auth/register/struct.IndexPage.html index 7e58c4f0..38804029 100644 --- a/mcaptcha/pages/auth/register/struct.IndexPage.html +++ b/mcaptcha/pages/auth/register/struct.IndexPage.html @@ -1,115 +1,115 @@ -IndexPage in mcaptcha::pages::auth::register - Rust - -

Struct mcaptcha::pages::auth::register::IndexPage[−][src]

struct IndexPage;

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Returns the “default value” for a type. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::auth::register - Rust

Struct mcaptcha::pages::auth::register::IndexPage[−][src]

struct IndexPage;

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Returns the “default value” for a type. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/register/struct.join.html b/mcaptcha/pages/auth/register/struct.join.html index 59a2eb03..ea602478 100644 --- a/mcaptcha/pages/auth/register/struct.join.html +++ b/mcaptcha/pages/auth/register/struct.join.html @@ -1,106 +1,106 @@ -join in mcaptcha::pages::auth::register - Rust - -

Struct mcaptcha::pages::auth::register::join[−][src]

pub struct join;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +join in mcaptcha::pages::auth::register - Rust

Struct mcaptcha::pages::auth::register::join[−][src]

pub struct join;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/routes/index.html b/mcaptcha/pages/auth/routes/index.html index 1bf134af..e1de73b7 100644 --- a/mcaptcha/pages/auth/routes/index.html +++ b/mcaptcha/pages/auth/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::auth::routes - Rust - -

Module mcaptcha::pages::auth::routes[−][src]

Structs

-
Auth
\ No newline at end of file +mcaptcha::pages::auth::routes - Rust

Module mcaptcha::pages::auth::routes[−][src]

Structs

+
Auth
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/routes/struct.Auth.html b/mcaptcha/pages/auth/routes/struct.Auth.html index 962fa308..952f9880 100644 --- a/mcaptcha/pages/auth/routes/struct.Auth.html +++ b/mcaptcha/pages/auth/routes/struct.Auth.html @@ -1,110 +1,109 @@ -Auth in mcaptcha::pages::auth::routes - Rust - -

Struct mcaptcha::pages::auth::routes::Auth[−][src]

pub struct Auth {
-    pub login: &'static str,
-    pub join: &'static str,
-}

- Fields

login: &'static strjoin: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Auth in mcaptcha::pages::auth::routes - Rust

Struct mcaptcha::pages::auth::routes::Auth[−][src]

pub struct Auth {
+    pub login: &'static str,
+    pub join: &'static str,
+}

Fields

login: &'static strjoin: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/sudo/constant.PAGE.html b/mcaptcha/pages/auth/sudo/constant.PAGE.html index fe94efbc..d340bcfe 100644 --- a/mcaptcha/pages/auth/sudo/constant.PAGE.html +++ b/mcaptcha/pages/auth/sudo/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::auth::sudo - Rust - -

Constant mcaptcha::pages::auth::sudo::PAGE[−][src]

pub const PAGE: &str = "Confirm Access";
\ No newline at end of file +PAGE in mcaptcha::pages::auth::sudo - Rust

Constant mcaptcha::pages::auth::sudo::PAGE[−][src]

pub const PAGE: &str = "Confirm Access";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/sudo/index.html b/mcaptcha/pages/auth/sudo/index.html index 7143b922..fb7c97d9 100644 --- a/mcaptcha/pages/auth/sudo/index.html +++ b/mcaptcha/pages/auth/sudo/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::auth::sudo - Rust - -

Module mcaptcha::pages::auth::sudo[−][src]

Structs

-
SudoPage

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::auth::sudo - Rust

Module mcaptcha::pages::auth::sudo[−][src]

Structs

+
SudoPage

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/auth/sudo/struct.SudoPage.html b/mcaptcha/pages/auth/sudo/struct.SudoPage.html index 14184453..48cd5730 100644 --- a/mcaptcha/pages/auth/sudo/struct.SudoPage.html +++ b/mcaptcha/pages/auth/sudo/struct.SudoPage.html @@ -1,118 +1,117 @@ -SudoPage in mcaptcha::pages::auth::sudo - Rust - -

Struct mcaptcha::pages::auth::sudo::SudoPage[−][src]

pub struct SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render,  {
-    url: &'a str,
-    data: Option<Vec<(K, V)>>,
-}

- Fields

url: &'a strdata: Option<Vec<(K, V)>>

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SudoPage in mcaptcha::pages::auth::sudo - Rust

Struct mcaptcha::pages::auth::sudo::SudoPage[−][src]

pub struct SudoPage<'a, K, V> where
    K: Display + Render,
    V: Display + Render,  {
+    url: &'a str,
+    data: Option<Vec<(K, V)>>,
+}

Fields

url: &'a strdata: Option<Vec<(K, V)>>

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/constant.NAME.html b/mcaptcha/pages/constant.NAME.html index 09288288..2690d783 100644 --- a/mcaptcha/pages/constant.NAME.html +++ b/mcaptcha/pages/constant.NAME.html @@ -1,3 +1,3 @@ -NAME in mcaptcha::pages - Rust - -

Constant mcaptcha::pages::NAME[−][src]

pub const NAME: &str = "mCaptcha";
\ No newline at end of file +NAME in mcaptcha::pages - Rust

Constant mcaptcha::pages::NAME[−][src]

pub const NAME: &str = "mCaptcha";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/constant.ERROR_ROUTE.html b/mcaptcha/pages/errors/constant.ERROR_ROUTE.html index e8fd7b2e..530debb8 100644 --- a/mcaptcha/pages/errors/constant.ERROR_ROUTE.html +++ b/mcaptcha/pages/errors/constant.ERROR_ROUTE.html @@ -1,3 +1,3 @@ -ERROR_ROUTE in mcaptcha::pages::errors - Rust - -

Constant mcaptcha::pages::errors::ERROR_ROUTE[−][src]

const ERROR_ROUTE: &str = "/error/{id}";
\ No newline at end of file +ERROR_ROUTE in mcaptcha::pages::errors - Rust

Constant mcaptcha::pages::errors::ERROR_ROUTE[−][src]

const ERROR_ROUTE: &str = "/error/{id}";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/constant.PAGE.html b/mcaptcha/pages/errors/constant.PAGE.html index cb3afbb6..c1ce4133 100644 --- a/mcaptcha/pages/errors/constant.PAGE.html +++ b/mcaptcha/pages/errors/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::errors - Rust - -

Constant mcaptcha::pages::errors::PAGE[−][src]

const PAGE: &str = "Error";
\ No newline at end of file +PAGE in mcaptcha::pages::errors - Rust

Constant mcaptcha::pages::errors::PAGE[−][src]

const PAGE: &str = "Error";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/fn.services.html b/mcaptcha/pages/errors/fn.services.html index 3d2eb45b..1b6687b3 100644 --- a/mcaptcha/pages/errors/fn.services.html +++ b/mcaptcha/pages/errors/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages::errors - Rust - -

Function mcaptcha::pages::errors::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages::errors - Rust

Function mcaptcha::pages::errors::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/index.html b/mcaptcha/pages/errors/index.html index 9edbfd41..a458a7a2 100644 --- a/mcaptcha/pages/errors/index.html +++ b/mcaptcha/pages/errors/index.html @@ -1,7 +1,7 @@ -mcaptcha::pages::errors - Rust - -

Module mcaptcha::pages::errors[−][src]

Modules

-
routes

Structs

-
ErrorPage
INTERNAL_SERVER_ERROR_BODY
UNKNOWN_ERROR_BODY
error

Constants

-
ERROR_ROUTE
PAGE

Functions

-
services
\ No newline at end of file +mcaptcha::pages::errors - Rust

Module mcaptcha::pages::errors[−][src]

Modules

+
routes

Structs

+
ErrorPage
INTERNAL_SERVER_ERROR_BODY
UNKNOWN_ERROR_BODY
error

Constants

+
ERROR_ROUTE
PAGE

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/routes/index.html b/mcaptcha/pages/errors/routes/index.html index 31ed99b9..9e90b630 100644 --- a/mcaptcha/pages/errors/routes/index.html +++ b/mcaptcha/pages/errors/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::errors::routes - Rust - -

Module mcaptcha::pages::errors::routes[−][src]

Structs

-
Errors
\ No newline at end of file +mcaptcha::pages::errors::routes - Rust

Module mcaptcha::pages::errors::routes[−][src]

Structs

+
Errors
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/routes/struct.Errors.html b/mcaptcha/pages/errors/routes/struct.Errors.html index 80f36b4d..f12b0ced 100644 --- a/mcaptcha/pages/errors/routes/struct.Errors.html +++ b/mcaptcha/pages/errors/routes/struct.Errors.html @@ -1,110 +1,109 @@ -Errors in mcaptcha::pages::errors::routes - Rust - -

Struct mcaptcha::pages::errors::routes::Errors[−][src]

pub struct Errors {
-    pub internal_server_error: &'static str,
-    pub unknown_error: &'static str,
-}

- Fields

internal_server_error: &'static strunknown_error: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Errors in mcaptcha::pages::errors::routes - Rust

Struct mcaptcha::pages::errors::routes::Errors[−][src]

pub struct Errors {
+    pub internal_server_error: &'static str,
+    pub unknown_error: &'static str,
+}

Fields

internal_server_error: &'static strunknown_error: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/struct.ErrorPage.html b/mcaptcha/pages/errors/struct.ErrorPage.html index e64e5ef1..00c2fd81 100644 --- a/mcaptcha/pages/errors/struct.ErrorPage.html +++ b/mcaptcha/pages/errors/struct.ErrorPage.html @@ -1,118 +1,117 @@ -ErrorPage in mcaptcha::pages::errors - Rust - -

Struct mcaptcha::pages::errors::ErrorPage[−][src]

struct ErrorPage<'a> {
-    title: &'a str,
-    message: &'a str,
-}

- Fields

title: &'a strmessage: &'a str

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +ErrorPage in mcaptcha::pages::errors - Rust

Struct mcaptcha::pages::errors::ErrorPage[−][src]

struct ErrorPage<'a> {
+    title: &'a str,
+    message: &'a str,
+}

Fields

title: &'a strmessage: &'a str

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/struct.INTERNAL_SERVER_ERROR_BODY.html b/mcaptcha/pages/errors/struct.INTERNAL_SERVER_ERROR_BODY.html index 0dee8142..f17179b9 100644 --- a/mcaptcha/pages/errors/struct.INTERNAL_SERVER_ERROR_BODY.html +++ b/mcaptcha/pages/errors/struct.INTERNAL_SERVER_ERROR_BODY.html @@ -1,9 +1,6 @@ -INTERNAL_SERVER_ERROR_BODY in mcaptcha::pages::errors - Rust - -

Struct mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY[−][src]

struct INTERNAL_SERVER_ERROR_BODY {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INTERNAL_SERVER_ERROR_BODY in mcaptcha::pages::errors - Rust

Struct mcaptcha::pages::errors::INTERNAL_SERVER_ERROR_BODY[−][src]

struct INTERNAL_SERVER_ERROR_BODY {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/struct.UNKNOWN_ERROR_BODY.html b/mcaptcha/pages/errors/struct.UNKNOWN_ERROR_BODY.html index 81d42731..5da414d8 100644 --- a/mcaptcha/pages/errors/struct.UNKNOWN_ERROR_BODY.html +++ b/mcaptcha/pages/errors/struct.UNKNOWN_ERROR_BODY.html @@ -1,9 +1,6 @@ -UNKNOWN_ERROR_BODY in mcaptcha::pages::errors - Rust - -

Struct mcaptcha::pages::errors::UNKNOWN_ERROR_BODY[−][src]

struct UNKNOWN_ERROR_BODY {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+UNKNOWN_ERROR_BODY in mcaptcha::pages::errors - Rust

Struct mcaptcha::pages::errors::UNKNOWN_ERROR_BODY[−][src]

struct UNKNOWN_ERROR_BODY {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/errors/struct.error.html b/mcaptcha/pages/errors/struct.error.html index 3bdbedfe..05d94d8d 100644 --- a/mcaptcha/pages/errors/struct.error.html +++ b/mcaptcha/pages/errors/struct.error.html @@ -1,106 +1,106 @@ -error in mcaptcha::pages::errors - Rust - -

Struct mcaptcha::pages::errors::error[−][src]

pub struct error;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +error in mcaptcha::pages::errors - Rust

Struct mcaptcha::pages::errors::error[−][src]

pub struct error;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/fn.services.html b/mcaptcha/pages/fn.services.html index e64da819..e6e3f058 100644 --- a/mcaptcha/pages/fn.services.html +++ b/mcaptcha/pages/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages - Rust - -

Function mcaptcha::pages::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages - Rust

Function mcaptcha::pages::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/index.html b/mcaptcha/pages/index.html index ac0e7a64..9dcac3b8 100644 --- a/mcaptcha/pages/index.html +++ b/mcaptcha/pages/index.html @@ -1,6 +1,6 @@ -mcaptcha::pages - Rust - -

Module mcaptcha::pages[−][src]

Modules

-
auth
errors
panel
routes
sitemap

Constants

-
NAME

Functions

-
services
\ No newline at end of file +mcaptcha::pages - Rust

Module mcaptcha::pages[−][src]

Modules

+
auth
errors
panel
routes
sitemap

Constants

+
NAME

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/constant.PAGE.html b/mcaptcha/pages/panel/constant.PAGE.html index 99d5bbdb..7dcafa7f 100644 --- a/mcaptcha/pages/panel/constant.PAGE.html +++ b/mcaptcha/pages/panel/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel - Rust - -

Constant mcaptcha::pages::panel::PAGE[−][src]

const PAGE: &str = "Dashboard";
\ No newline at end of file +PAGE in mcaptcha::pages::panel - Rust

Constant mcaptcha::pages::panel::PAGE[−][src]

const PAGE: &str = "Dashboard";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/fn.services.html b/mcaptcha/pages/panel/fn.services.html index 37cd6502..2f1841b8 100644 --- a/mcaptcha/pages/panel/fn.services.html +++ b/mcaptcha/pages/panel/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages::panel - Rust - -

Function mcaptcha::pages::panel::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages::panel - Rust

Function mcaptcha::pages::panel::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/index.html b/mcaptcha/pages/panel/index.html index a45df494..009df164 100644 --- a/mcaptcha/pages/panel/index.html +++ b/mcaptcha/pages/panel/index.html @@ -1,7 +1,7 @@ -mcaptcha::pages::panel - Rust - -

Module mcaptcha::pages::panel[−][src]

Modules

-
notifications
routes
settings
sitekey

Structs

-
IndexPage
panel

Constants

-
PAGE

Functions

-
services
\ No newline at end of file +mcaptcha::pages::panel - Rust

Module mcaptcha::pages::panel[−][src]

Modules

+
notifications
routes
settings
sitekey

Structs

+
IndexPage
panel

Constants

+
PAGE

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/notifications/constant.PAGE.html b/mcaptcha/pages/panel/notifications/constant.PAGE.html index 3e4b3833..d5dec3b3 100644 --- a/mcaptcha/pages/panel/notifications/constant.PAGE.html +++ b/mcaptcha/pages/panel/notifications/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::notifications - Rust - -

Constant mcaptcha::pages::panel::notifications::PAGE[−][src]

const PAGE: &str = "Notifications";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::notifications - Rust

Constant mcaptcha::pages::panel::notifications::PAGE[−][src]

const PAGE: &str = "Notifications";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/notifications/index.html b/mcaptcha/pages/panel/notifications/index.html index 87c5d866..b1d133ec 100644 --- a/mcaptcha/pages/panel/notifications/index.html +++ b/mcaptcha/pages/panel/notifications/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::panel::notifications - Rust - -

Module mcaptcha::pages::panel::notifications[−][src]

Structs

-
IndexPage
Notification
notifications

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::panel::notifications - Rust

Module mcaptcha::pages::panel::notifications[−][src]

Structs

+
IndexPage
Notification
notifications

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/notifications/struct.IndexPage.html b/mcaptcha/pages/panel/notifications/struct.IndexPage.html index 4815f1db..17853dff 100644 --- a/mcaptcha/pages/panel/notifications/struct.IndexPage.html +++ b/mcaptcha/pages/panel/notifications/struct.IndexPage.html @@ -1,112 +1,111 @@ -IndexPage in mcaptcha::pages::panel::notifications - Rust - -

Struct mcaptcha::pages::panel::notifications::IndexPage[−][src]

pub struct IndexPage {
-    n: Vec<Notification>,
-}

- Fields

n: Vec<Notification>

notifications

-

Implementations

Trait Implementations

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel::notifications - Rust

Struct mcaptcha::pages::panel::notifications::IndexPage[−][src]

pub struct IndexPage {
+    n: Vec<Notification>,
+}

Fields

n: Vec<Notification>

notifications

+

Implementations

Trait Implementations

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/notifications/struct.Notification.html b/mcaptcha/pages/panel/notifications/struct.Notification.html index 852d17c8..c58d1aed 100644 --- a/mcaptcha/pages/panel/notifications/struct.Notification.html +++ b/mcaptcha/pages/panel/notifications/struct.Notification.html @@ -1,114 +1,113 @@ -Notification in mcaptcha::pages::panel::notifications - Rust - -

Struct mcaptcha::pages::panel::notifications::Notification[−][src]

pub struct Notification {
-    pub name: String,
-    pub heading: String,
-    pub message: String,
+Notification in mcaptcha::pages::panel::notifications - Rust
Struct mcaptcha::pages::panel::notifications::Notification[−][src]
pub struct Notification {
+    pub name: String,
+    pub heading: String,
+    pub message: String,
     pub received: OffsetDateTime,
-    pub id: i32,
-}

-                       Fields
name: Stringheading: Stringmessage: Stringreceived: OffsetDateTimeid: i32
Implementations
Trait Implementations
Performs the conversion.

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub id: i32,
+}

Fields

name: Stringheading: Stringmessage: Stringreceived: OffsetDateTimeid: i32

Implementations

Trait Implementations

Performs the conversion.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/notifications/struct.notifications.html b/mcaptcha/pages/panel/notifications/struct.notifications.html index 32bb02cc..8c39a73e 100644 --- a/mcaptcha/pages/panel/notifications/struct.notifications.html +++ b/mcaptcha/pages/panel/notifications/struct.notifications.html @@ -1,106 +1,106 @@ -notifications in mcaptcha::pages::panel::notifications - Rust - -

Struct mcaptcha::pages::panel::notifications::notifications[−][src]

pub struct notifications;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +notifications in mcaptcha::pages::panel::notifications - Rust

Struct mcaptcha::pages::panel::notifications::notifications[−][src]

pub struct notifications;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/routes/index.html b/mcaptcha/pages/panel/routes/index.html index ef7d18f2..545d56c5 100644 --- a/mcaptcha/pages/panel/routes/index.html +++ b/mcaptcha/pages/panel/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::panel::routes - Rust - -

Module mcaptcha::pages::panel::routes[−][src]

Structs

-
Panel
\ No newline at end of file +mcaptcha::pages::panel::routes - Rust

Module mcaptcha::pages::panel::routes[−][src]

Structs

+
Panel
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/routes/struct.Panel.html b/mcaptcha/pages/panel/routes/struct.Panel.html index 30c6df94..d421c8e6 100644 --- a/mcaptcha/pages/panel/routes/struct.Panel.html +++ b/mcaptcha/pages/panel/routes/struct.Panel.html @@ -1,112 +1,111 @@ -Panel in mcaptcha::pages::panel::routes - Rust - -

Struct mcaptcha::pages::panel::routes::Panel[−][src]

pub struct Panel {
-    pub home: &'static str,
+Panel in mcaptcha::pages::panel::routes - Rust
Struct mcaptcha::pages::panel::routes::Panel[−][src]
pub struct Panel {
+    pub home: &'static str,
     pub sitekey: Sitekey,
-    pub notifications: &'static str,
+    pub notifications: &'static str,
     pub settings: Settings,
-}

-                       Fields
home: &'static strsitekey: Sitekeynotifications: &'static strsettings: Settings
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

home: &'static strsitekey: Sitekeynotifications: &'static strsettings: Settings

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/constant.PAGE.html b/mcaptcha/pages/panel/settings/constant.PAGE.html index 6fceb5e0..323f51db 100644 --- a/mcaptcha/pages/panel/settings/constant.PAGE.html +++ b/mcaptcha/pages/panel/settings/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::settings - Rust - -

Constant mcaptcha::pages::panel::settings::PAGE[−][src]

const PAGE: &str = "Settings";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::settings - Rust

Constant mcaptcha::pages::panel::settings::PAGE[−][src]

const PAGE: &str = "Settings";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/fn.services.html b/mcaptcha/pages/panel/settings/fn.services.html index becf544b..a29989e9 100644 --- a/mcaptcha/pages/panel/settings/fn.services.html +++ b/mcaptcha/pages/panel/settings/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages::panel::settings - Rust - -

Function mcaptcha::pages::panel::settings::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages::panel::settings - Rust

Function mcaptcha::pages::panel::settings::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/index.html b/mcaptcha/pages/panel/settings/index.html index c740cab2..b6a32342 100644 --- a/mcaptcha/pages/panel/settings/index.html +++ b/mcaptcha/pages/panel/settings/index.html @@ -1,7 +1,7 @@ -mcaptcha::pages::panel::settings - Rust - -

Module mcaptcha::pages::panel::settings[−][src]

Modules

-
routes

Structs

-
IndexPage
delete_account
settings
update_secret

Constants

-
PAGE

Functions

-
services
\ No newline at end of file +mcaptcha::pages::panel::settings - Rust

Module mcaptcha::pages::panel::settings[−][src]

Modules

+
routes

Structs

+
IndexPage
delete_account
settings
update_secret

Constants

+
PAGE

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/routes/index.html b/mcaptcha/pages/panel/settings/routes/index.html index 15ebb753..ba68beea 100644 --- a/mcaptcha/pages/panel/settings/routes/index.html +++ b/mcaptcha/pages/panel/settings/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::panel::settings::routes - Rust - -

Module mcaptcha::pages::panel::settings::routes[−][src]

Structs

-
Settings
\ No newline at end of file +mcaptcha::pages::panel::settings::routes - Rust

Module mcaptcha::pages::panel::settings::routes[−][src]

Structs

+
Settings
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/routes/struct.Settings.html b/mcaptcha/pages/panel/settings/routes/struct.Settings.html index 463ec813..5805f763 100644 --- a/mcaptcha/pages/panel/settings/routes/struct.Settings.html +++ b/mcaptcha/pages/panel/settings/routes/struct.Settings.html @@ -1,111 +1,110 @@ -Settings in mcaptcha::pages::panel::settings::routes - Rust - -

Struct mcaptcha::pages::panel::settings::routes::Settings[−][src]

pub struct Settings {
-    pub home: &'static str,
-    pub delete_account: &'static str,
-    pub update_secret: &'static str,
-}

- Fields

home: &'static strdelete_account: &'static strupdate_secret: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Settings in mcaptcha::pages::panel::settings::routes - Rust

Struct mcaptcha::pages::panel::settings::routes::Settings[−][src]

pub struct Settings {
+    pub home: &'static str,
+    pub delete_account: &'static str,
+    pub update_secret: &'static str,
+}

Fields

home: &'static strdelete_account: &'static strupdate_secret: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/struct.IndexPage.html b/mcaptcha/pages/panel/settings/struct.IndexPage.html index bb4bfd41..da1c555f 100644 --- a/mcaptcha/pages/panel/settings/struct.IndexPage.html +++ b/mcaptcha/pages/panel/settings/struct.IndexPage.html @@ -1,119 +1,118 @@ -IndexPage in mcaptcha::pages::panel::settings - Rust - -

Struct mcaptcha::pages::panel::settings::IndexPage[−][src]

pub struct IndexPage<'a> {
-    email: Option<String>,
-    secret: String,
-    username: &'a str,
-}

- Fields

email: Option<String>secret: Stringusername: &'a str

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel::settings - Rust

Struct mcaptcha::pages::panel::settings::IndexPage[−][src]

pub struct IndexPage<'a> {
+    email: Option<String>,
+    secret: String,
+    username: &'a str,
+}

Fields

email: Option<String>secret: Stringusername: &'a str

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/struct.delete_account.html b/mcaptcha/pages/panel/settings/struct.delete_account.html index 339b637a..990e1a93 100644 --- a/mcaptcha/pages/panel/settings/struct.delete_account.html +++ b/mcaptcha/pages/panel/settings/struct.delete_account.html @@ -1,106 +1,106 @@ -delete_account in mcaptcha::pages::panel::settings - Rust - -

Struct mcaptcha::pages::panel::settings::delete_account[−][src]

pub struct delete_account;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +delete_account in mcaptcha::pages::panel::settings - Rust

Struct mcaptcha::pages::panel::settings::delete_account[−][src]

pub struct delete_account;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/struct.settings.html b/mcaptcha/pages/panel/settings/struct.settings.html index c2be656f..7f27fe82 100644 --- a/mcaptcha/pages/panel/settings/struct.settings.html +++ b/mcaptcha/pages/panel/settings/struct.settings.html @@ -1,106 +1,106 @@ -settings in mcaptcha::pages::panel::settings - Rust - -

Struct mcaptcha::pages::panel::settings::settings[−][src]

pub struct settings;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +settings in mcaptcha::pages::panel::settings - Rust

Struct mcaptcha::pages::panel::settings::settings[−][src]

pub struct settings;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/settings/struct.update_secret.html b/mcaptcha/pages/panel/settings/struct.update_secret.html index 9f44e7b4..c4aa0d04 100644 --- a/mcaptcha/pages/panel/settings/struct.update_secret.html +++ b/mcaptcha/pages/panel/settings/struct.update_secret.html @@ -1,106 +1,106 @@ -update_secret in mcaptcha::pages::panel::settings - Rust - -

Struct mcaptcha::pages::panel::settings::update_secret[−][src]

pub struct update_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +update_secret in mcaptcha::pages::panel::settings - Rust

Struct mcaptcha::pages::panel::settings::update_secret[−][src]

pub struct update_secret;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/add/constant.PAGE.html b/mcaptcha/pages/panel/sitekey/add/constant.PAGE.html index d637cb80..67788654 100644 --- a/mcaptcha/pages/panel/sitekey/add/constant.PAGE.html +++ b/mcaptcha/pages/panel/sitekey/add/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::sitekey::add - Rust - -

Constant mcaptcha::pages::panel::sitekey::add::PAGE[−][src]

const PAGE: &str = "Add Sitekey";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::sitekey::add - Rust

Constant mcaptcha::pages::panel::sitekey::add::PAGE[−][src]

const PAGE: &str = "Add Sitekey";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/add/index.html b/mcaptcha/pages/panel/sitekey/add/index.html index e75805d4..cadde907 100644 --- a/mcaptcha/pages/panel/sitekey/add/index.html +++ b/mcaptcha/pages/panel/sitekey/add/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::panel::sitekey::add - Rust - -

Module mcaptcha::pages::panel::sitekey::add[−][src]

Structs

-
INDEX
IndexPage
add_sitekey

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::panel::sitekey::add - Rust

Module mcaptcha::pages::panel::sitekey::add[−][src]

Structs

+
INDEX
IndexPage
add_sitekey

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/add/struct.INDEX.html b/mcaptcha/pages/panel/sitekey/add/struct.INDEX.html index 44b5c07d..50ce276e 100644 --- a/mcaptcha/pages/panel/sitekey/add/struct.INDEX.html +++ b/mcaptcha/pages/panel/sitekey/add/struct.INDEX.html @@ -1,9 +1,6 @@ -INDEX in mcaptcha::pages::panel::sitekey::add - Rust - -

Struct mcaptcha::pages::panel::sitekey::add::INDEX[−][src]

struct INDEX {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INDEX in mcaptcha::pages::panel::sitekey::add - Rust

Struct mcaptcha::pages::panel::sitekey::add::INDEX[−][src]

struct INDEX {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/add/struct.IndexPage.html b/mcaptcha/pages/panel/sitekey/add/struct.IndexPage.html index 282d07d9..fa269371 100644 --- a/mcaptcha/pages/panel/sitekey/add/struct.IndexPage.html +++ b/mcaptcha/pages/panel/sitekey/add/struct.IndexPage.html @@ -1,121 +1,120 @@ -IndexPage in mcaptcha::pages::panel::sitekey::add - Rust - -

Struct mcaptcha::pages::panel::sitekey::add::IndexPage[−][src]

pub struct IndexPage<'a> {
-    pub levels: usize,
-    pub form_title: &'a str,
-    pub form_description: &'a str,
-    pub form_duration: usize,
-}

- Fields

levels: usizeform_title: &'a strform_description: &'a strform_duration: usize

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Returns the “default value” for a type. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel::sitekey::add - Rust

Struct mcaptcha::pages::panel::sitekey::add::IndexPage[−][src]

pub struct IndexPage<'a> {
+    pub levels: usize,
+    pub form_title: &'a str,
+    pub form_description: &'a str,
+    pub form_duration: usize,
+}

Fields

levels: usizeform_title: &'a strform_description: &'a strform_duration: usize

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Returns the “default value” for a type. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/add/struct.add_sitekey.html b/mcaptcha/pages/panel/sitekey/add/struct.add_sitekey.html index 72ca727e..6415b914 100644 --- a/mcaptcha/pages/panel/sitekey/add/struct.add_sitekey.html +++ b/mcaptcha/pages/panel/sitekey/add/struct.add_sitekey.html @@ -1,106 +1,106 @@ -add_sitekey in mcaptcha::pages::panel::sitekey::add - Rust - -

Struct mcaptcha::pages::panel::sitekey::add::add_sitekey[−][src]

pub struct add_sitekey;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +add_sitekey in mcaptcha::pages::panel::sitekey::add - Rust

Struct mcaptcha::pages::panel::sitekey::add::add_sitekey[−][src]

pub struct add_sitekey;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/delete/index.html b/mcaptcha/pages/panel/sitekey/delete/index.html index 2fbf8cd5..13d64b81 100644 --- a/mcaptcha/pages/panel/sitekey/delete/index.html +++ b/mcaptcha/pages/panel/sitekey/delete/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::panel::sitekey::delete - Rust - -

Module mcaptcha::pages::panel::sitekey::delete[−][src]

Structs

-
delete_sitekey
\ No newline at end of file +mcaptcha::pages::panel::sitekey::delete - Rust

Module mcaptcha::pages::panel::sitekey::delete[−][src]

Structs

+
delete_sitekey
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/delete/struct.delete_sitekey.html b/mcaptcha/pages/panel/sitekey/delete/struct.delete_sitekey.html index 39e90867..8d80b64c 100644 --- a/mcaptcha/pages/panel/sitekey/delete/struct.delete_sitekey.html +++ b/mcaptcha/pages/panel/sitekey/delete/struct.delete_sitekey.html @@ -1,106 +1,106 @@ -delete_sitekey in mcaptcha::pages::panel::sitekey::delete - Rust - -

Struct mcaptcha::pages::panel::sitekey::delete::delete_sitekey[−][src]

pub struct delete_sitekey;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +delete_sitekey in mcaptcha::pages::panel::sitekey::delete - Rust

Struct mcaptcha::pages::panel::sitekey::delete::delete_sitekey[−][src]

pub struct delete_sitekey;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/constant.PAGE.html b/mcaptcha/pages/panel/sitekey/edit/constant.PAGE.html index 9db23299..269f62ea 100644 --- a/mcaptcha/pages/panel/sitekey/edit/constant.PAGE.html +++ b/mcaptcha/pages/panel/sitekey/edit/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::sitekey::edit - Rust - -

Constant mcaptcha::pages::panel::sitekey::edit::PAGE[−][src]

const PAGE: &str = "SiteKeys";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::sitekey::edit - Rust

Constant mcaptcha::pages::panel::sitekey::edit::PAGE[−][src]

const PAGE: &str = "SiteKeys";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/index.html b/mcaptcha/pages/panel/sitekey/edit/index.html index 92427a7b..40563a06 100644 --- a/mcaptcha/pages/panel/sitekey/edit/index.html +++ b/mcaptcha/pages/panel/sitekey/edit/index.html @@ -1,6 +1,6 @@ -mcaptcha::pages::panel::sitekey::edit - Rust - -

Module mcaptcha::pages::panel::sitekey::edit[−][src]

Structs

-
IndexPage
Level
McaptchaConfig
edit_sitekey

route handler that renders individual views for sitekeys

-

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::panel::sitekey::edit - Rust

Module mcaptcha::pages::panel::sitekey::edit[−][src]

Structs

+
IndexPage
Level
McaptchaConfig
edit_sitekey

route handler that renders individual views for sitekeys

+

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/struct.IndexPage.html b/mcaptcha/pages/panel/sitekey/edit/struct.IndexPage.html index 34ad66b2..40c904d7 100644 --- a/mcaptcha/pages/panel/sitekey/edit/struct.IndexPage.html +++ b/mcaptcha/pages/panel/sitekey/edit/struct.IndexPage.html @@ -1,120 +1,119 @@ -IndexPage in mcaptcha::pages::panel::sitekey::edit - Rust - -

Struct mcaptcha::pages::panel::sitekey::edit::IndexPage[−][src]

struct IndexPage {
-    duration: u32,
-    name: String,
-    key: String,
-    levels: Vec<Level>,
-}

- Fields

duration: u32name: Stringkey: Stringlevels: Vec<Level>

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel::sitekey::edit - Rust

Struct mcaptcha::pages::panel::sitekey::edit::IndexPage[−][src]

struct IndexPage {
+    duration: u32,
+    name: String,
+    key: String,
+    levels: Vec<Level>,
+}

Fields

duration: u32name: Stringkey: Stringlevels: Vec<Level>

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/struct.Level.html b/mcaptcha/pages/panel/sitekey/edit/struct.Level.html index 47bcc979..a8ebf5b7 100644 --- a/mcaptcha/pages/panel/sitekey/edit/struct.Level.html +++ b/mcaptcha/pages/panel/sitekey/edit/struct.Level.html @@ -1,116 +1,115 @@ -Level in mcaptcha::pages::panel::sitekey::edit - Rust - -

Struct mcaptcha::pages::panel::sitekey::edit::Level[−][src]

struct Level {
-    difficulty_factor: i32,
-    visitor_threshold: i32,
-}

- Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Level in mcaptcha::pages::panel::sitekey::edit - Rust

Struct mcaptcha::pages::panel::sitekey::edit::Level[−][src]

struct Level {
+    difficulty_factor: i32,
+    visitor_threshold: i32,
+}

Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/struct.McaptchaConfig.html b/mcaptcha/pages/panel/sitekey/edit/struct.McaptchaConfig.html index 5dc956ef..1e1fdb26 100644 --- a/mcaptcha/pages/panel/sitekey/edit/struct.McaptchaConfig.html +++ b/mcaptcha/pages/panel/sitekey/edit/struct.McaptchaConfig.html @@ -1,117 +1,116 @@ -McaptchaConfig in mcaptcha::pages::panel::sitekey::edit - Rust - -

Struct mcaptcha::pages::panel::sitekey::edit::McaptchaConfig[−][src]

struct McaptchaConfig {
-    config_id: i32,
-    duration: i32,
-    name: String,
-}

- Fields

config_id: i32duration: i32name: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +McaptchaConfig in mcaptcha::pages::panel::sitekey::edit - Rust

Struct mcaptcha::pages::panel::sitekey::edit::McaptchaConfig[−][src]

struct McaptchaConfig {
+    config_id: i32,
+    duration: i32,
+    name: String,
+}

Fields

config_id: i32duration: i32name: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/edit/struct.edit_sitekey.html b/mcaptcha/pages/panel/sitekey/edit/struct.edit_sitekey.html index 70981cb0..28ac88de 100644 --- a/mcaptcha/pages/panel/sitekey/edit/struct.edit_sitekey.html +++ b/mcaptcha/pages/panel/sitekey/edit/struct.edit_sitekey.html @@ -1,107 +1,107 @@ -edit_sitekey in mcaptcha::pages::panel::sitekey::edit - Rust - -

Struct mcaptcha::pages::panel::sitekey::edit::edit_sitekey[−][src]

pub struct edit_sitekey;
Expand description

route handler that renders individual views for sitekeys

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +edit_sitekey in mcaptcha::pages::panel::sitekey::edit - Rust

Struct mcaptcha::pages::panel::sitekey::edit::edit_sitekey[−][src]

pub struct edit_sitekey;
Expand description

route handler that renders individual views for sitekeys

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/fn.services.html b/mcaptcha/pages/panel/sitekey/fn.services.html index 2430f247..e53eae5f 100644 --- a/mcaptcha/pages/panel/sitekey/fn.services.html +++ b/mcaptcha/pages/panel/sitekey/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::pages::panel::sitekey - Rust - -

Function mcaptcha::pages::panel::sitekey::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::pages::panel::sitekey - Rust

Function mcaptcha::pages::panel::sitekey::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/index.html b/mcaptcha/pages/panel/sitekey/index.html index 382f565b..f19d3590 100644 --- a/mcaptcha/pages/panel/sitekey/index.html +++ b/mcaptcha/pages/panel/sitekey/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::panel::sitekey - Rust - -

Module mcaptcha::pages::panel::sitekey[−][src]

Modules

-
add
delete
edit
list
routes
view

Functions

-
services
\ No newline at end of file +mcaptcha::pages::panel::sitekey - Rust

Module mcaptcha::pages::panel::sitekey[−][src]

Modules

+
add
delete
edit
list
routes
view

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/constant.PAGE.html b/mcaptcha/pages/panel/sitekey/list/constant.PAGE.html index 408efec6..18a14109 100644 --- a/mcaptcha/pages/panel/sitekey/list/constant.PAGE.html +++ b/mcaptcha/pages/panel/sitekey/list/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::sitekey::list - Rust - -

Constant mcaptcha::pages::panel::sitekey::list::PAGE[−][src]

const PAGE: &str = "SiteKeys";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::sitekey::list - Rust

Constant mcaptcha::pages::panel::sitekey::list::PAGE[−][src]

const PAGE: &str = "SiteKeys";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/fn.get_list_sitekeys.html b/mcaptcha/pages/panel/sitekey/list/fn.get_list_sitekeys.html index a2a400e8..85614dfe 100644 --- a/mcaptcha/pages/panel/sitekey/list/fn.get_list_sitekeys.html +++ b/mcaptcha/pages/panel/sitekey/list/fn.get_list_sitekeys.html @@ -1,4 +1,4 @@ -get_list_sitekeys in mcaptcha::pages::panel::sitekey::list - Rust - -

Function mcaptcha::pages::panel::sitekey::list::get_list_sitekeys[−][src]

pub async fn get_list_sitekeys(
    data: &AppData, 
    id: &Identity
) -> Result<Vec<MCaptchaDetails>, PageError>
Expand description

utility function to get a list of all sitekeys that a user owns

-
\ No newline at end of file +get_list_sitekeys in mcaptcha::pages::panel::sitekey::list - Rust

Function mcaptcha::pages::panel::sitekey::list::get_list_sitekeys[−][src]

pub async fn get_list_sitekeys(
    data: &AppData, 
    id: &Identity
) -> Result<Vec<MCaptchaDetails>, PageError>
Expand description

utility function to get a list of all sitekeys that a user owns

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/index.html b/mcaptcha/pages/panel/sitekey/list/index.html index 93c74a31..97c68e2e 100644 --- a/mcaptcha/pages/panel/sitekey/list/index.html +++ b/mcaptcha/pages/panel/sitekey/list/index.html @@ -1,9 +1,9 @@ -mcaptcha::pages::panel::sitekey::list - Rust - -

Module mcaptcha::pages::panel::sitekey::list[−][src]

Structs

-
IndexPage
list_sitekeys

render a list of all sitekeys that a user has

-

Constants

-
PAGE

Functions

-
get_list_sitekeys

utility function to get a list of all sitekeys that a user owns

-

Type Definitions

-
SiteKeys
\ No newline at end of file +mcaptcha::pages::panel::sitekey::list - Rust

Module mcaptcha::pages::panel::sitekey::list[−][src]

Structs

+
IndexPage
list_sitekeys

render a list of all sitekeys that a user has

+

Constants

+
PAGE

Functions

+
get_list_sitekeys

utility function to get a list of all sitekeys that a user owns

+

Type Definitions

+
SiteKeys
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/struct.IndexPage.html b/mcaptcha/pages/panel/sitekey/list/struct.IndexPage.html index 54cb877c..43e7d92e 100644 --- a/mcaptcha/pages/panel/sitekey/list/struct.IndexPage.html +++ b/mcaptcha/pages/panel/sitekey/list/struct.IndexPage.html @@ -1,117 +1,116 @@ -IndexPage in mcaptcha::pages::panel::sitekey::list - Rust - -

Struct mcaptcha::pages::panel::sitekey::list::IndexPage[−][src]

pub struct IndexPage {
-    sitekeys: Vec<MCaptchaDetails>,
-}

- Fields

sitekeys: Vec<MCaptchaDetails>

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel::sitekey::list - Rust

Struct mcaptcha::pages::panel::sitekey::list::IndexPage[−][src]

pub struct IndexPage {
+    sitekeys: Vec<MCaptchaDetails>,
+}

Fields

sitekeys: Vec<MCaptchaDetails>

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/struct.list_sitekeys.html b/mcaptcha/pages/panel/sitekey/list/struct.list_sitekeys.html index d0bc66f1..4158ff8a 100644 --- a/mcaptcha/pages/panel/sitekey/list/struct.list_sitekeys.html +++ b/mcaptcha/pages/panel/sitekey/list/struct.list_sitekeys.html @@ -1,107 +1,107 @@ -list_sitekeys in mcaptcha::pages::panel::sitekey::list - Rust - -

Struct mcaptcha::pages::panel::sitekey::list::list_sitekeys[−][src]

pub struct list_sitekeys;
Expand description

render a list of all sitekeys that a user has

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +list_sitekeys in mcaptcha::pages::panel::sitekey::list - Rust

Struct mcaptcha::pages::panel::sitekey::list::list_sitekeys[−][src]

pub struct list_sitekeys;
Expand description

render a list of all sitekeys that a user has

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/list/type.SiteKeys.html b/mcaptcha/pages/panel/sitekey/list/type.SiteKeys.html index 96b01dac..b4a2c49f 100644 --- a/mcaptcha/pages/panel/sitekey/list/type.SiteKeys.html +++ b/mcaptcha/pages/panel/sitekey/list/type.SiteKeys.html @@ -1,3 +1,3 @@ -SiteKeys in mcaptcha::pages::panel::sitekey::list - Rust - -

Type Definition mcaptcha::pages::panel::sitekey::list::SiteKeys[−][src]

type SiteKeys = Vec<MCaptchaDetails>;
\ No newline at end of file +SiteKeys in mcaptcha::pages::panel::sitekey::list - Rust

Type Definition mcaptcha::pages::panel::sitekey::list::SiteKeys[−][src]

pub type SiteKeys = Vec<MCaptchaDetails>;
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/routes/index.html b/mcaptcha/pages/panel/sitekey/routes/index.html index cff3b9a2..2ec6bb19 100644 --- a/mcaptcha/pages/panel/sitekey/routes/index.html +++ b/mcaptcha/pages/panel/sitekey/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::panel::sitekey::routes - Rust - -

Module mcaptcha::pages::panel::sitekey::routes[−][src]

Structs

-
Sitekey
\ No newline at end of file +mcaptcha::pages::panel::sitekey::routes - Rust

Module mcaptcha::pages::panel::sitekey::routes[−][src]

Structs

+
Sitekey
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/routes/struct.Sitekey.html b/mcaptcha/pages/panel/sitekey/routes/struct.Sitekey.html index 1edb30d3..870620c9 100644 --- a/mcaptcha/pages/panel/sitekey/routes/struct.Sitekey.html +++ b/mcaptcha/pages/panel/sitekey/routes/struct.Sitekey.html @@ -1,113 +1,112 @@ -Sitekey in mcaptcha::pages::panel::sitekey::routes - Rust - -

Struct mcaptcha::pages::panel::sitekey::routes::Sitekey[−][src]

pub struct Sitekey {
-    pub list: &'static str,
-    pub add: &'static str,
-    pub view: &'static str,
-    pub edit: &'static str,
-    pub delete: &'static str,
-}

- Fields

list: &'static stradd: &'static strview: &'static stredit: &'static strdelete: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Sitekey in mcaptcha::pages::panel::sitekey::routes - Rust

Struct mcaptcha::pages::panel::sitekey::routes::Sitekey[−][src]

pub struct Sitekey {
+    pub list: &'static str,
+    pub add: &'static str,
+    pub view: &'static str,
+    pub edit: &'static str,
+    pub delete: &'static str,
+}

Fields

list: &'static stradd: &'static strview: &'static stredit: &'static strdelete: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/constant.PAGE.html b/mcaptcha/pages/panel/sitekey/view/constant.PAGE.html index 1be46e26..072fd8b8 100644 --- a/mcaptcha/pages/panel/sitekey/view/constant.PAGE.html +++ b/mcaptcha/pages/panel/sitekey/view/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::pages::panel::sitekey::view - Rust - -

Constant mcaptcha::pages::panel::sitekey::view::PAGE[−][src]

const PAGE: &str = "SiteKeys";
\ No newline at end of file +PAGE in mcaptcha::pages::panel::sitekey::view - Rust

Constant mcaptcha::pages::panel::sitekey::view::PAGE[−][src]

const PAGE: &str = "SiteKeys";
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/index.html b/mcaptcha/pages/panel/sitekey/view/index.html index 8161a780..faee500d 100644 --- a/mcaptcha/pages/panel/sitekey/view/index.html +++ b/mcaptcha/pages/panel/sitekey/view/index.html @@ -1,6 +1,6 @@ -mcaptcha::pages::panel::sitekey::view - Rust - -

Module mcaptcha::pages::panel::sitekey::view[−][src]

Structs

-
IndexPage
Level
McaptchaConfig
view_sitekey

route handler that renders individual views for sitekeys

-

Constants

-
PAGE
\ No newline at end of file +mcaptcha::pages::panel::sitekey::view - Rust

Module mcaptcha::pages::panel::sitekey::view[−][src]

Structs

+
IndexPage
Level
McaptchaConfig
view_sitekey

route handler that renders individual views for sitekeys

+

Constants

+
PAGE
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/struct.IndexPage.html b/mcaptcha/pages/panel/sitekey/view/struct.IndexPage.html index ebcd2642..90ece4e2 100644 --- a/mcaptcha/pages/panel/sitekey/view/struct.IndexPage.html +++ b/mcaptcha/pages/panel/sitekey/view/struct.IndexPage.html @@ -1,121 +1,120 @@ -IndexPage in mcaptcha::pages::panel::sitekey::view - Rust - -

Struct mcaptcha::pages::panel::sitekey::view::IndexPage[−][src]

struct IndexPage {
-    duration: u32,
-    name: String,
-    key: String,
-    levels: Vec<Level>,
+IndexPage in mcaptcha::pages::panel::sitekey::view - Rust
Struct mcaptcha::pages::panel::sitekey::view::IndexPage[−][src]
struct IndexPage {
+    duration: u32,
+    name: String,
+    key: String,
+    levels: Vec<Level>,
     stats: Stats,
-}

-                       Fields
duration: u32name: Stringkey: Stringlevels: Vec<Level>stats: Stats
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Render the template and return the rendering result as RenderResult Read more

-
Render the template and append the result to buf. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

duration: u32name: Stringkey: Stringlevels: Vec<Level>stats: Stats

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/struct.Level.html b/mcaptcha/pages/panel/sitekey/view/struct.Level.html index 8a2a1f37..031001b0 100644 --- a/mcaptcha/pages/panel/sitekey/view/struct.Level.html +++ b/mcaptcha/pages/panel/sitekey/view/struct.Level.html @@ -1,116 +1,115 @@ -Level in mcaptcha::pages::panel::sitekey::view - Rust - -

Struct mcaptcha::pages::panel::sitekey::view::Level[−][src]

struct Level {
-    difficulty_factor: i32,
-    visitor_threshold: i32,
-}

- Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Level in mcaptcha::pages::panel::sitekey::view - Rust

Struct mcaptcha::pages::panel::sitekey::view::Level[−][src]

struct Level {
+    difficulty_factor: i32,
+    visitor_threshold: i32,
+}

Fields

difficulty_factor: i32visitor_threshold: i32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/struct.McaptchaConfig.html b/mcaptcha/pages/panel/sitekey/view/struct.McaptchaConfig.html index 933c881d..2d4b627f 100644 --- a/mcaptcha/pages/panel/sitekey/view/struct.McaptchaConfig.html +++ b/mcaptcha/pages/panel/sitekey/view/struct.McaptchaConfig.html @@ -1,117 +1,116 @@ -McaptchaConfig in mcaptcha::pages::panel::sitekey::view - Rust - -

Struct mcaptcha::pages::panel::sitekey::view::McaptchaConfig[−][src]

struct McaptchaConfig {
-    config_id: i32,
-    duration: i32,
-    name: String,
-}

- Fields

config_id: i32duration: i32name: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +McaptchaConfig in mcaptcha::pages::panel::sitekey::view - Rust

Struct mcaptcha::pages::panel::sitekey::view::McaptchaConfig[−][src]

struct McaptchaConfig {
+    config_id: i32,
+    duration: i32,
+    name: String,
+}

Fields

config_id: i32duration: i32name: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/sitekey/view/struct.view_sitekey.html b/mcaptcha/pages/panel/sitekey/view/struct.view_sitekey.html index c4fa89a2..9f502522 100644 --- a/mcaptcha/pages/panel/sitekey/view/struct.view_sitekey.html +++ b/mcaptcha/pages/panel/sitekey/view/struct.view_sitekey.html @@ -1,107 +1,107 @@ -view_sitekey in mcaptcha::pages::panel::sitekey::view - Rust - -

Struct mcaptcha::pages::panel::sitekey::view::view_sitekey[−][src]

pub struct view_sitekey;
Expand description

route handler that renders individual views for sitekeys

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +view_sitekey in mcaptcha::pages::panel::sitekey::view - Rust

Struct mcaptcha::pages::panel::sitekey::view::view_sitekey[−][src]

pub struct view_sitekey;
Expand description

route handler that renders individual views for sitekeys

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/struct.IndexPage.html b/mcaptcha/pages/panel/struct.IndexPage.html index a3b6ec40..ca00d980 100644 --- a/mcaptcha/pages/panel/struct.IndexPage.html +++ b/mcaptcha/pages/panel/struct.IndexPage.html @@ -1,117 +1,116 @@ -IndexPage in mcaptcha::pages::panel - Rust - -

Struct mcaptcha::pages::panel::IndexPage[−][src]

pub struct IndexPage {
-    sitekeys: Vec<MCaptchaDetails>,
-}

- Fields

sitekeys: Vec<MCaptchaDetails>

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::panel - Rust

Struct mcaptcha::pages::panel::IndexPage[−][src]

pub struct IndexPage {
+    sitekeys: Vec<MCaptchaDetails>,
+}

Fields

sitekeys: Vec<MCaptchaDetails>

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/panel/struct.panel.html b/mcaptcha/pages/panel/struct.panel.html index 1ef2b4e4..fc8df02c 100644 --- a/mcaptcha/pages/panel/struct.panel.html +++ b/mcaptcha/pages/panel/struct.panel.html @@ -1,106 +1,106 @@ -panel in mcaptcha::pages::panel - Rust - -

Struct mcaptcha::pages::panel::panel[−][src]

pub struct panel;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +panel in mcaptcha::pages::panel - Rust

Struct mcaptcha::pages::panel::panel[−][src]

pub struct panel;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/routes/constant.ROUTES.html b/mcaptcha/pages/routes/constant.ROUTES.html index da6c4b5d..8c90f2d9 100644 --- a/mcaptcha/pages/routes/constant.ROUTES.html +++ b/mcaptcha/pages/routes/constant.ROUTES.html @@ -1,3 +1,3 @@ -ROUTES in mcaptcha::pages::routes - Rust - -

Constant mcaptcha::pages::routes::ROUTES[−][src]

pub const ROUTES: Routes;
\ No newline at end of file +ROUTES in mcaptcha::pages::routes - Rust

Constant mcaptcha::pages::routes::ROUTES[−][src]

pub const ROUTES: Routes;
+ + \ No newline at end of file diff --git a/mcaptcha/pages/routes/index.html b/mcaptcha/pages/routes/index.html index 706ade79..01d3f669 100644 --- a/mcaptcha/pages/routes/index.html +++ b/mcaptcha/pages/routes/index.html @@ -1,5 +1,5 @@ -mcaptcha::pages::routes - Rust - -

Module mcaptcha::pages::routes[−][src]

Structs

-
Routes

Constants

-
ROUTES
\ No newline at end of file +mcaptcha::pages::routes - Rust

Module mcaptcha::pages::routes[−][src]

Structs

+
Routes

Constants

+
ROUTES
+ + \ No newline at end of file diff --git a/mcaptcha/pages/routes/struct.Routes.html b/mcaptcha/pages/routes/struct.Routes.html index b54127a1..24679459 100644 --- a/mcaptcha/pages/routes/struct.Routes.html +++ b/mcaptcha/pages/routes/struct.Routes.html @@ -1,118 +1,117 @@ -Routes in mcaptcha::pages::routes - Rust - -

Struct mcaptcha::pages::routes::Routes[−][src]

pub struct Routes {
-    pub home: &'static str,
+Routes in mcaptcha::pages::routes - Rust
Struct mcaptcha::pages::routes::Routes[−][src]
pub struct Routes {
+    pub home: &'static str,
     pub auth: Auth,
     pub panel: Panel,
     pub errors: Errors,
-    pub about: &'static str,
-    pub sitemap: &'static str,
-    pub thanks: &'static str,
-    pub donate: &'static str,
-    pub security: &'static str,
-    pub privacy: &'static str,
-}

-                       Fields
home: &'static strauth: Authpanel: Panelerrors: Errorsabout: &'static strsitemap: &'static strthanks: &'static strdonate: &'static strsecurity: &'static strprivacy: &'static str
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub about: &'static str,
+    pub sitemap: &'static str,
+    pub thanks: &'static str,
+    pub donate: &'static str,
+    pub security: &'static str,
+    pub privacy: &'static str,
+}

Fields

home: &'static strauth: Authpanel: Panelerrors: Errorsabout: &'static strsitemap: &'static strthanks: &'static strdonate: &'static strsecurity: &'static strprivacy: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/sitemap/index.html b/mcaptcha/pages/sitemap/index.html index 48f18013..42348a08 100644 --- a/mcaptcha/pages/sitemap/index.html +++ b/mcaptcha/pages/sitemap/index.html @@ -1,4 +1,4 @@ -mcaptcha::pages::sitemap - Rust - -

Module mcaptcha::pages::sitemap[−][src]

Structs

-
INDEX
IndexPage
sitemap
\ No newline at end of file +mcaptcha::pages::sitemap - Rust

Module mcaptcha::pages::sitemap[−][src]

Structs

+
INDEX
IndexPage
sitemap
+ + \ No newline at end of file diff --git a/mcaptcha/pages/sitemap/struct.INDEX.html b/mcaptcha/pages/sitemap/struct.INDEX.html index 3dec807c..484346aa 100644 --- a/mcaptcha/pages/sitemap/struct.INDEX.html +++ b/mcaptcha/pages/sitemap/struct.INDEX.html @@ -1,9 +1,6 @@ -INDEX in mcaptcha::pages::sitemap - Rust - -

Struct mcaptcha::pages::sitemap::INDEX[−][src]

struct INDEX {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INDEX in mcaptcha::pages::sitemap - Rust

Struct mcaptcha::pages::sitemap::INDEX[−][src]

struct INDEX {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/sitemap/struct.IndexPage.html b/mcaptcha/pages/sitemap/struct.IndexPage.html index d2023106..a05fc963 100644 --- a/mcaptcha/pages/sitemap/struct.IndexPage.html +++ b/mcaptcha/pages/sitemap/struct.IndexPage.html @@ -1,119 +1,118 @@ -IndexPage in mcaptcha::pages::sitemap - Rust - -

Struct mcaptcha::pages::sitemap::IndexPage[−][src]

struct IndexPage {
-    urls: [&'static str; 7],
-    domain: &'static str,
-}

- Fields

urls: [&'static str; 7]domain: &'static str

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Returns the “default value” for a type. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::pages::sitemap - Rust

Struct mcaptcha::pages::sitemap::IndexPage[−][src]

struct IndexPage {
+    urls: [&'static str; 7],
+    domain: &'static str,
+}

Fields

urls: [&'static str; 7]domain: &'static str

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Returns the “default value” for a type. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/pages/sitemap/struct.sitemap.html b/mcaptcha/pages/sitemap/struct.sitemap.html index bbf057f8..bc71ca56 100644 --- a/mcaptcha/pages/sitemap/struct.sitemap.html +++ b/mcaptcha/pages/sitemap/struct.sitemap.html @@ -1,106 +1,106 @@ -sitemap in mcaptcha::pages::sitemap - Rust - -

Struct mcaptcha::pages::sitemap::sitemap[−][src]

pub struct sitemap;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +sitemap in mcaptcha::pages::sitemap - Rust

Struct mcaptcha::pages::sitemap::sitemap[−][src]

pub struct sitemap;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/routes/enum.Methods.html b/mcaptcha/routes/enum.Methods.html index a77f9218..093aafe7 100644 --- a/mcaptcha/routes/enum.Methods.html +++ b/mcaptcha/routes/enum.Methods.html @@ -1,117 +1,115 @@ -Methods in mcaptcha::routes - Rust - -

Enum mcaptcha::routes::Methods[−][src]

pub enum Methods {
+Methods in mcaptcha::routes - Rust
Enum mcaptcha::routes::Methods[−][src]
pub enum Methods {
     Get,
     Post,
     ProtectGet,
     ProtectPost,
-}

-                   Variants

-
Get
GET hander

+}

Variants

Get

GET hander

Post

POST handler

ProtectGet

Protected GET handler

ProtectPost

Protected POST handler

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/routes/index.html b/mcaptcha/routes/index.html index ac89dd13..8624d601 100644 --- a/mcaptcha/routes/index.html +++ b/mcaptcha/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::routes - Rust - -

Module mcaptcha::routes[−][src]

Enums

-
Methods
\ No newline at end of file +mcaptcha::routes - Rust

Module mcaptcha::routes[−][src]

Enums

+
Methods
+ + \ No newline at end of file diff --git a/mcaptcha/settings/fn.check_url.html b/mcaptcha/settings/fn.check_url.html index cdfcf2ab..ca4c1805 100644 --- a/mcaptcha/settings/fn.check_url.html +++ b/mcaptcha/settings/fn.check_url.html @@ -1,3 +1,3 @@ -check_url in mcaptcha::settings - Rust - -

Function mcaptcha::settings::check_url[−][src]

fn check_url(s: &Config)
\ No newline at end of file +check_url in mcaptcha::settings - Rust

Function mcaptcha::settings::check_url[−][src]

fn check_url(s: &Config)
+ + \ No newline at end of file diff --git a/mcaptcha/settings/fn.set_database_url.html b/mcaptcha/settings/fn.set_database_url.html index 2c40dd9e..2a08289b 100644 --- a/mcaptcha/settings/fn.set_database_url.html +++ b/mcaptcha/settings/fn.set_database_url.html @@ -1,3 +1,3 @@ -set_database_url in mcaptcha::settings - Rust - -

Function mcaptcha::settings::set_database_url[−][src]

fn set_database_url(s: &mut Config)
\ No newline at end of file +set_database_url in mcaptcha::settings - Rust

Function mcaptcha::settings::set_database_url[−][src]

fn set_database_url(s: &mut Config)
+ + \ No newline at end of file diff --git a/mcaptcha/settings/fn.set_from_database_url.html b/mcaptcha/settings/fn.set_from_database_url.html index 8c2831cb..68b6e0e6 100644 --- a/mcaptcha/settings/fn.set_from_database_url.html +++ b/mcaptcha/settings/fn.set_from_database_url.html @@ -1,3 +1,3 @@ -set_from_database_url in mcaptcha::settings - Rust - -

Function mcaptcha::settings::set_from_database_url[−][src]

fn set_from_database_url(s: &mut Config, database_conf: &DatabaseBuilder)
\ No newline at end of file +set_from_database_url in mcaptcha::settings - Rust

Function mcaptcha::settings::set_from_database_url[−][src]

fn set_from_database_url(s: &mut Config, database_conf: &DatabaseBuilder)
+ + \ No newline at end of file diff --git a/mcaptcha/settings/index.html b/mcaptcha/settings/index.html index ebb47d29..7d949694 100644 --- a/mcaptcha/settings/index.html +++ b/mcaptcha/settings/index.html @@ -1,5 +1,5 @@ -mcaptcha::settings - Rust - -

Module mcaptcha::settings[−][src]

Structs

-
Captcha
Database
DatabaseBuilder
Redis
Server
Settings
Smtp

Functions

-
check_url
set_database_url
set_from_database_url
\ No newline at end of file +mcaptcha::settings - Rust

Module mcaptcha::settings[−][src]

Structs

+
Captcha
Database
DatabaseBuilder
Redis
Server
Settings
Smtp

Functions

+
check_url
set_database_url
set_from_database_url
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Captcha.html b/mcaptcha/settings/struct.Captcha.html index 29a3f643..f78aaeb2 100644 --- a/mcaptcha/settings/struct.Captcha.html +++ b/mcaptcha/settings/struct.Captcha.html @@ -1,118 +1,117 @@ -Captcha in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Captcha[−][src]

pub struct Captcha {
-    pub salt: String,
-    pub gc: u64,
-}

- Fields

salt: Stringgc: u64

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Captcha in mcaptcha::settings - Rust

Struct mcaptcha::settings::Captcha[−][src]

pub struct Captcha {
+    pub salt: String,
+    pub gc: u64,
+}

Fields

salt: Stringgc: u64

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Database.html b/mcaptcha/settings/struct.Database.html index 7ef80c03..a55a16a6 100644 --- a/mcaptcha/settings/struct.Database.html +++ b/mcaptcha/settings/struct.Database.html @@ -1,118 +1,117 @@ -Database in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Database[−][src]

pub struct Database {
-    pub url: String,
-    pub pool: u32,
-}

- Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Database in mcaptcha::settings - Rust

Struct mcaptcha::settings::Database[−][src]

pub struct Database {
+    pub url: String,
+    pub pool: u32,
+}

Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.DatabaseBuilder.html b/mcaptcha/settings/struct.DatabaseBuilder.html index 1e4f23e3..85ae1664 100644 --- a/mcaptcha/settings/struct.DatabaseBuilder.html +++ b/mcaptcha/settings/struct.DatabaseBuilder.html @@ -1,122 +1,121 @@ -DatabaseBuilder in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::DatabaseBuilder[−][src]

struct DatabaseBuilder {
-    pub port: u32,
-    pub hostname: String,
-    pub username: String,
-    pub password: String,
-    pub name: String,
-    pub url: String,
-}

- Fields

port: u32hostname: Stringusername: Stringpassword: Stringname: Stringurl: String

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +DatabaseBuilder in mcaptcha::settings - Rust

Struct mcaptcha::settings::DatabaseBuilder[−][src]

struct DatabaseBuilder {
+    pub port: u32,
+    pub hostname: String,
+    pub username: String,
+    pub password: String,
+    pub name: String,
+    pub url: String,
+}

Fields

port: u32hostname: Stringusername: Stringpassword: Stringname: Stringurl: String

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Redis.html b/mcaptcha/settings/struct.Redis.html index 546656bd..40bb6f10 100644 --- a/mcaptcha/settings/struct.Redis.html +++ b/mcaptcha/settings/struct.Redis.html @@ -1,118 +1,117 @@ -Redis in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Redis[−][src]

pub struct Redis {
-    pub url: String,
-    pub pool: u32,
-}

- Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Redis in mcaptcha::settings - Rust

Struct mcaptcha::settings::Redis[−][src]

pub struct Redis {
+    pub url: String,
+    pub pool: u32,
+}

Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Server.html b/mcaptcha/settings/struct.Server.html index e5e584d0..79887dc9 100644 --- a/mcaptcha/settings/struct.Server.html +++ b/mcaptcha/settings/struct.Server.html @@ -1,122 +1,121 @@ -Server in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Server[−][src]

pub struct Server {
-    pub port: u32,
-    pub domain: String,
-    pub cookie_secret: String,
-    pub ip: String,
-    pub url_prefix: Option<String>,
-    pub proxy_has_tls: bool,
-}

- Fields

port: u32domain: Stringcookie_secret: Stringip: Stringurl_prefix: Option<String>proxy_has_tls: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Server in mcaptcha::settings - Rust

Struct mcaptcha::settings::Server[−][src]

pub struct Server {
+    pub port: u32,
+    pub domain: String,
+    pub cookie_secret: String,
+    pub ip: String,
+    pub url_prefix: Option<String>,
+    pub proxy_has_tls: bool,
+}

Fields

port: u32domain: Stringcookie_secret: Stringip: Stringurl_prefix: Option<String>proxy_has_tls: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Settings.html b/mcaptcha/settings/struct.Settings.html index 77dffb7d..cde52232 100644 --- a/mcaptcha/settings/struct.Settings.html +++ b/mcaptcha/settings/struct.Settings.html @@ -1,126 +1,125 @@ -Settings in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Settings[−][src]

pub struct Settings {
-    pub debug: bool,
-    pub commercial: bool,
+Settings in mcaptcha::settings - Rust
Struct mcaptcha::settings::Settings[−][src]
pub struct Settings {
+    pub debug: bool,
+    pub commercial: bool,
     pub database: Database,
-    pub redis: Option<Redis>,
+    pub redis: Option<Redis>,
     pub server: Server,
     pub pow: Captcha,
-    pub source_code: String,
-    pub smtp: Option<Smtp>,
-    pub allow_registration: bool,
-    pub allow_demo: bool,
-}

-                       Fields
debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub source_code: String,
+    pub smtp: Option<Smtp>,
+    pub allow_registration: bool,
+    pub allow_demo: bool,
+}

Fields

debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/settings/struct.Smtp.html b/mcaptcha/settings/struct.Smtp.html index eb39f84d..85f75acf 100644 --- a/mcaptcha/settings/struct.Smtp.html +++ b/mcaptcha/settings/struct.Smtp.html @@ -1,122 +1,121 @@ -Smtp in mcaptcha::settings - Rust - -

Struct mcaptcha::settings::Smtp[−][src]

pub struct Smtp {
-    pub from: String,
-    pub reply: String,
-    pub url: String,
-    pub username: String,
-    pub password: String,
-    pub port: u16,
-}

- Fields

from: Stringreply: Stringurl: Stringusername: Stringpassword: Stringport: u16

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Smtp in mcaptcha::settings - Rust

Struct mcaptcha::settings::Smtp[−][src]

pub struct Smtp {
+    pub from: String,
+    pub reply: String,
+    pub url: String,
+    pub username: String,
+    pub password: String,
+    pub port: u16,
+}

Fields

from: Stringreply: Stringurl: Stringusername: Stringpassword: Stringport: u16

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/filemap/index.html b/mcaptcha/static_assets/filemap/index.html index b15d4d74..a69d853a 100644 --- a/mcaptcha/static_assets/filemap/index.html +++ b/mcaptcha/static_assets/filemap/index.html @@ -1,4 +1,4 @@ -mcaptcha::static_assets::filemap - Rust - -

Module mcaptcha::static_assets::filemap[−][src]

Structs

-
FileMap
\ No newline at end of file +mcaptcha::static_assets::filemap - Rust

Module mcaptcha::static_assets::filemap[−][src]

Structs

+
FileMap
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/filemap/struct.FileMap.html b/mcaptcha/static_assets/filemap/struct.FileMap.html index 2cb7825a..1ca82049 100644 --- a/mcaptcha/static_assets/filemap/struct.FileMap.html +++ b/mcaptcha/static_assets/filemap/struct.FileMap.html @@ -1,109 +1,108 @@ -FileMap in mcaptcha::static_assets::filemap - Rust - -

Struct mcaptcha::static_assets::filemap::FileMap[−][src]

pub struct FileMap {
+FileMap in mcaptcha::static_assets::filemap - Rust
Struct mcaptcha::static_assets::filemap::FileMap[−][src]
pub struct FileMap {
     pub files: Files,
-}

-                       Fields
files: Files
Implementations
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+}

Fields

files: Files

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/fn.services.html b/mcaptcha/static_assets/fn.services.html index cad10bee..5e6b0355 100644 --- a/mcaptcha/static_assets/fn.services.html +++ b/mcaptcha/static_assets/fn.services.html @@ -1,3 +1,3 @@ -services in mcaptcha::static_assets - Rust - -

Function mcaptcha::static_assets::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
\ No newline at end of file +services in mcaptcha::static_assets - Rust

Function mcaptcha::static_assets::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/index.html b/mcaptcha/static_assets/index.html index 12a43f08..e18f9576 100644 --- a/mcaptcha/static_assets/index.html +++ b/mcaptcha/static_assets/index.html @@ -1,6 +1,6 @@ -mcaptcha::static_assets - Rust - -

Module mcaptcha::static_assets[−][src]

Re-exports

-
pub use filemap::FileMap;

Modules

-
filemap
static_files

Functions

-
services
\ No newline at end of file +mcaptcha::static_assets - Rust

Module mcaptcha::static_assets[−][src]

Re-exports

+
pub use filemap::FileMap;

Modules

+
filemap
static_files

Functions

+
services
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/index.html b/mcaptcha/static_assets/static_files/assets/index.html index b42a7b04..2f217b13 100644 --- a/mcaptcha/static_assets/static_files/assets/index.html +++ b/mcaptcha/static_assets/static_files/assets/index.html @@ -1,5 +1,5 @@ -mcaptcha::static_assets::static_files::assets - Rust - -

Module mcaptcha::static_assets::static_files::assets[−][src]

Structs

-
BAR_CHART
CREDIT_CARD
DOCS_ICON
GITHUB
HELP_CIRCLE
HOME
KEY
MCAPTCHA_TRANS_ICON
MESSAGE
SETTINGS_ICON

Type Definitions

-
Img
\ No newline at end of file +mcaptcha::static_assets::static_files::assets - Rust

Module mcaptcha::static_assets::static_files::assets[−][src]

Structs

+
BAR_CHART
CREDIT_CARD
DOCS_ICON
GITHUB
HELP_CIRCLE
HOME
KEY
MCAPTCHA_TRANS_ICON
MESSAGE
SETTINGS_ICON

Type Definitions

+
Img
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.BAR_CHART.html b/mcaptcha/static_assets/static_files/assets/struct.BAR_CHART.html index 5708913f..891af614 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.BAR_CHART.html +++ b/mcaptcha/static_assets/static_files/assets/struct.BAR_CHART.html @@ -1,111 +1,110 @@ -BAR_CHART in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::BAR_CHART[−][src]

pub struct BAR_CHART {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +BAR_CHART in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::BAR_CHART[−][src]

pub struct BAR_CHART {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.CREDIT_CARD.html b/mcaptcha/static_assets/static_files/assets/struct.CREDIT_CARD.html index 949d52b8..98926e3f 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.CREDIT_CARD.html +++ b/mcaptcha/static_assets/static_files/assets/struct.CREDIT_CARD.html @@ -1,111 +1,110 @@ -CREDIT_CARD in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::CREDIT_CARD[−][src]

pub struct CREDIT_CARD {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CREDIT_CARD in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::CREDIT_CARD[−][src]

pub struct CREDIT_CARD {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.DOCS_ICON.html b/mcaptcha/static_assets/static_files/assets/struct.DOCS_ICON.html index 5fba2560..3e059247 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.DOCS_ICON.html +++ b/mcaptcha/static_assets/static_files/assets/struct.DOCS_ICON.html @@ -1,111 +1,110 @@ -DOCS_ICON in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::DOCS_ICON[−][src]

pub struct DOCS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +DOCS_ICON in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::DOCS_ICON[−][src]

pub struct DOCS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.GITHUB.html b/mcaptcha/static_assets/static_files/assets/struct.GITHUB.html index f0552458..e16758d9 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.GITHUB.html +++ b/mcaptcha/static_assets/static_files/assets/struct.GITHUB.html @@ -1,111 +1,110 @@ -GITHUB in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::GITHUB[−][src]

pub struct GITHUB {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +GITHUB in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::GITHUB[−][src]

pub struct GITHUB {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.HELP_CIRCLE.html b/mcaptcha/static_assets/static_files/assets/struct.HELP_CIRCLE.html index f8416956..380cf61f 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.HELP_CIRCLE.html +++ b/mcaptcha/static_assets/static_files/assets/struct.HELP_CIRCLE.html @@ -1,111 +1,110 @@ -HELP_CIRCLE in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::HELP_CIRCLE[−][src]

pub struct HELP_CIRCLE {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +HELP_CIRCLE in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::HELP_CIRCLE[−][src]

pub struct HELP_CIRCLE {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.HOME.html b/mcaptcha/static_assets/static_files/assets/struct.HOME.html index 73808b11..a987f185 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.HOME.html +++ b/mcaptcha/static_assets/static_files/assets/struct.HOME.html @@ -1,111 +1,110 @@ -HOME in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::HOME[−][src]

pub struct HOME {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +HOME in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::HOME[−][src]

pub struct HOME {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.KEY.html b/mcaptcha/static_assets/static_files/assets/struct.KEY.html index eee7f2b0..facedb66 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.KEY.html +++ b/mcaptcha/static_assets/static_files/assets/struct.KEY.html @@ -1,111 +1,110 @@ -KEY in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::KEY[−][src]

pub struct KEY {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +KEY in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::KEY[−][src]

pub struct KEY {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.MCAPTCHA_TRANS_ICON.html b/mcaptcha/static_assets/static_files/assets/struct.MCAPTCHA_TRANS_ICON.html index 0652f62a..5dcb9fe8 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.MCAPTCHA_TRANS_ICON.html +++ b/mcaptcha/static_assets/static_files/assets/struct.MCAPTCHA_TRANS_ICON.html @@ -1,111 +1,110 @@ -MCAPTCHA_TRANS_ICON in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON[−][src]

pub struct MCAPTCHA_TRANS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MCAPTCHA_TRANS_ICON in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::MCAPTCHA_TRANS_ICON[−][src]

pub struct MCAPTCHA_TRANS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.MESSAGE.html b/mcaptcha/static_assets/static_files/assets/struct.MESSAGE.html index fa8fb3a3..fb075209 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.MESSAGE.html +++ b/mcaptcha/static_assets/static_files/assets/struct.MESSAGE.html @@ -1,111 +1,110 @@ -MESSAGE in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::MESSAGE[−][src]

pub struct MESSAGE {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MESSAGE in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::MESSAGE[−][src]

pub struct MESSAGE {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/struct.SETTINGS_ICON.html b/mcaptcha/static_assets/static_files/assets/struct.SETTINGS_ICON.html index 49c596aa..5f030aec 100644 --- a/mcaptcha/static_assets/static_files/assets/struct.SETTINGS_ICON.html +++ b/mcaptcha/static_assets/static_files/assets/struct.SETTINGS_ICON.html @@ -1,111 +1,110 @@ -SETTINGS_ICON in mcaptcha::static_assets::static_files::assets - Rust - -

Struct mcaptcha::static_assets::static_files::assets::SETTINGS_ICON[−][src]

pub struct SETTINGS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SETTINGS_ICON in mcaptcha::static_assets::static_files::assets - Rust

Struct mcaptcha::static_assets::static_files::assets::SETTINGS_ICON[−][src]

pub struct SETTINGS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/assets/type.Img.html b/mcaptcha/static_assets/static_files/assets/type.Img.html index 97fa46be..82c04587 100644 --- a/mcaptcha/static_assets/static_files/assets/type.Img.html +++ b/mcaptcha/static_assets/static_files/assets/type.Img.html @@ -1,3 +1,3 @@ -Img in mcaptcha::static_assets::static_files::assets - Rust - -

Type Definition mcaptcha::static_assets::static_files::assets::Img[−][src]

type Img = (&'static str, &'static str);
\ No newline at end of file +Img in mcaptcha::static_assets::static_files::assets - Rust

Type Definition mcaptcha::static_assets::static_files::assets::Img[−][src]

type Img = (&'static str, &'static str);
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/fn.handle_assets.html b/mcaptcha/static_assets/static_files/fn.handle_assets.html index da95721c..e0feb1cf 100644 --- a/mcaptcha/static_assets/static_files/fn.handle_assets.html +++ b/mcaptcha/static_assets/static_files/fn.handle_assets.html @@ -1,3 +1,3 @@ -handle_assets in mcaptcha::static_assets::static_files - Rust - -

Function mcaptcha::static_assets::static_files::handle_assets[−][src]

fn handle_assets(path: &str) -> HttpResponse
\ No newline at end of file +handle_assets in mcaptcha::static_assets::static_files - Rust

Function mcaptcha::static_assets::static_files::handle_assets[−][src]

fn handle_assets(path: &str) -> HttpResponse
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/fn.handle_favicons.html b/mcaptcha/static_assets/static_files/fn.handle_favicons.html index 666b6eb7..645889b7 100644 --- a/mcaptcha/static_assets/static_files/fn.handle_favicons.html +++ b/mcaptcha/static_assets/static_files/fn.handle_favicons.html @@ -1,3 +1,3 @@ -handle_favicons in mcaptcha::static_assets::static_files - Rust - -

Function mcaptcha::static_assets::static_files::handle_favicons[−][src]

fn handle_favicons(path: &str) -> HttpResponse
\ No newline at end of file +handle_favicons in mcaptcha::static_assets::static_files - Rust

Function mcaptcha::static_assets::static_files::handle_favicons[−][src]

fn handle_favicons(path: &str) -> HttpResponse
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/index.html b/mcaptcha/static_assets/static_files/index.html index 52f4ed08..0459b883 100644 --- a/mcaptcha/static_assets/static_files/index.html +++ b/mcaptcha/static_assets/static_files/index.html @@ -1,6 +1,6 @@ -mcaptcha::static_assets::static_files - Rust - -

Module mcaptcha::static_assets::static_files[−][src]

Modules

-
assets

Structs

-
Asset
Favicons
favicons
static_files

Functions

-
handle_assets
handle_favicons
\ No newline at end of file +mcaptcha::static_assets::static_files - Rust

Module mcaptcha::static_assets::static_files[−][src]

Modules

+
assets

Structs

+
Asset
Favicons
favicons
static_files

Functions

+
handle_assets
handle_favicons
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/struct.Asset.html b/mcaptcha/static_assets/static_files/struct.Asset.html index f7186262..c1077e60 100644 --- a/mcaptcha/static_assets/static_files/struct.Asset.html +++ b/mcaptcha/static_assets/static_files/struct.Asset.html @@ -1,108 +1,108 @@ -Asset in mcaptcha::static_assets::static_files - Rust - -

Struct mcaptcha::static_assets::static_files::Asset[−][src]

struct Asset;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

-

Iterates over the file paths in the folder. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Asset in mcaptcha::static_assets::static_files - Rust

Struct mcaptcha::static_assets::static_files::Asset[−][src]

struct Asset;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

+

Iterates over the file paths in the folder. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/struct.Favicons.html b/mcaptcha/static_assets/static_files/struct.Favicons.html index d53ff4f6..d696b9df 100644 --- a/mcaptcha/static_assets/static_files/struct.Favicons.html +++ b/mcaptcha/static_assets/static_files/struct.Favicons.html @@ -1,108 +1,108 @@ -Favicons in mcaptcha::static_assets::static_files - Rust - -

Struct mcaptcha::static_assets::static_files::Favicons[−][src]

struct Favicons;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

-

Iterates over the file paths in the folder. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Favicons in mcaptcha::static_assets::static_files - Rust

Struct mcaptcha::static_assets::static_files::Favicons[−][src]

struct Favicons;

Implementations

Trait Implementations

Get an embedded file and its metadata. Read more

+

Iterates over the file paths in the folder. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/struct.favicons.html b/mcaptcha/static_assets/static_files/struct.favicons.html index 82b04389..f0ea7fea 100644 --- a/mcaptcha/static_assets/static_files/struct.favicons.html +++ b/mcaptcha/static_assets/static_files/struct.favicons.html @@ -1,106 +1,106 @@ -favicons in mcaptcha::static_assets::static_files - Rust - -

Struct mcaptcha::static_assets::static_files::favicons[−][src]

pub struct favicons;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +favicons in mcaptcha::static_assets::static_files - Rust

Struct mcaptcha::static_assets::static_files::favicons[−][src]

pub struct favicons;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/static_assets/static_files/struct.static_files.html b/mcaptcha/static_assets/static_files/struct.static_files.html index cce5e8f2..232ac74e 100644 --- a/mcaptcha/static_assets/static_files/struct.static_files.html +++ b/mcaptcha/static_assets/static_files/struct.static_files.html @@ -1,106 +1,106 @@ -static_files in mcaptcha::static_assets::static_files - Rust - -

Struct mcaptcha::static_assets::static_files::static_files[−][src]

pub struct static_files;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +static_files in mcaptcha::static_assets::static_files - Rust

Struct mcaptcha::static_assets::static_files::static_files[−][src]

pub struct static_files;

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/index.html b/mcaptcha/stats/fetch/index.html index d0d308c8..ca7b35a6 100644 --- a/mcaptcha/stats/fetch/index.html +++ b/mcaptcha/stats/fetch/index.html @@ -1,5 +1,5 @@ -mcaptcha::stats::fetch - Rust - -

Module mcaptcha::stats::fetch[−][src]

Modules

-
runners

Structs

-
Stats
StatsPayload
StatsUnixTimestamp
\ No newline at end of file +mcaptcha::stats::fetch - Rust

Module mcaptcha::stats::fetch[−][src]

Modules

+
runners

Structs

+
Stats
StatsPayload
StatsUnixTimestamp
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/runners/fn.fetch_config_fetched.html b/mcaptcha/stats/fetch/runners/fn.fetch_config_fetched.html index e7ecd1c7..734549a6 100644 --- a/mcaptcha/stats/fetch/runners/fn.fetch_config_fetched.html +++ b/mcaptcha/stats/fetch/runners/fn.fetch_config_fetched.html @@ -1,4 +1,4 @@ -fetch_config_fetched in mcaptcha::stats::fetch::runners - Rust - -

Function mcaptcha::stats::fetch::runners::fetch_config_fetched[−][src]

pub async fn fetch_config_fetched(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig fetches

-
\ No newline at end of file +fetch_config_fetched in mcaptcha::stats::fetch::runners - Rust

Function mcaptcha::stats::fetch::runners::fetch_config_fetched[−][src]

pub async fn fetch_config_fetched(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig fetches

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/runners/fn.fetch_confirm.html b/mcaptcha/stats/fetch/runners/fn.fetch_confirm.html index 0f8cbf36..741e9f8f 100644 --- a/mcaptcha/stats/fetch/runners/fn.fetch_confirm.html +++ b/mcaptcha/stats/fetch/runners/fn.fetch_confirm.html @@ -1,4 +1,4 @@ -fetch_confirm in mcaptcha::stats::fetch::runners - Rust - -

Function mcaptcha::stats::fetch::runners::fetch_confirm[−][src]

pub async fn fetch_confirm(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig confirms

-
\ No newline at end of file +fetch_confirm in mcaptcha::stats::fetch::runners - Rust

Function mcaptcha::stats::fetch::runners::fetch_confirm[−][src]

pub async fn fetch_confirm(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig confirms

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/runners/fn.fetch_solve.html b/mcaptcha/stats/fetch/runners/fn.fetch_solve.html index acc5567c..f750817e 100644 --- a/mcaptcha/stats/fetch/runners/fn.fetch_solve.html +++ b/mcaptcha/stats/fetch/runners/fn.fetch_solve.html @@ -1,4 +1,4 @@ -fetch_solve in mcaptcha::stats::fetch::runners - Rust - -

Function mcaptcha::stats::fetch::runners::fetch_solve[−][src]

pub async fn fetch_solve(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig solves

-
\ No newline at end of file +fetch_solve in mcaptcha::stats::fetch::runners - Rust

Function mcaptcha::stats::fetch::runners::fetch_solve[−][src]

pub async fn fetch_solve(
    user: &str, 
    key: &str, 
    db: &PgPool
) -> Result<Vec<Date>, ServiceError>
Expand description

featch PoWConfig solves

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/runners/index.html b/mcaptcha/stats/fetch/runners/index.html index 1edb6dd8..a231aea4 100644 --- a/mcaptcha/stats/fetch/runners/index.html +++ b/mcaptcha/stats/fetch/runners/index.html @@ -1,7 +1,7 @@ -mcaptcha::stats::fetch::runners - Rust - -

Module mcaptcha::stats::fetch::runners[−][src]

Functions

-
fetch_config_fetched

featch PoWConfig fetches

-
fetch_confirm

featch PoWConfig confirms

-
fetch_solve

featch PoWConfig solves

-
\ No newline at end of file +mcaptcha::stats::fetch::runners - Rust

Module mcaptcha::stats::fetch::runners[−][src]

Functions

+
fetch_config_fetched

featch PoWConfig fetches

+
fetch_confirm

featch PoWConfig confirms

+
fetch_solve

featch PoWConfig solves

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/struct.Stats.html b/mcaptcha/stats/fetch/struct.Stats.html index 766b43a1..974a72a8 100644 --- a/mcaptcha/stats/fetch/struct.Stats.html +++ b/mcaptcha/stats/fetch/struct.Stats.html @@ -1,118 +1,117 @@ -Stats in mcaptcha::stats::fetch - Rust - -

Struct mcaptcha::stats::fetch::Stats[−][src]

pub struct Stats {
-    pub config_fetches: Vec<Date>,
-    pub solves: Vec<Date>,
-    pub confirms: Vec<Date>,
-}

- Fields

config_fetches: Vec<Date>solves: Vec<Date>confirms: Vec<Date>

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Stats in mcaptcha::stats::fetch - Rust

Struct mcaptcha::stats::fetch::Stats[−][src]

pub struct Stats {
+    pub config_fetches: Vec<Date>,
+    pub solves: Vec<Date>,
+    pub confirms: Vec<Date>,
+}

Fields

config_fetches: Vec<Date>solves: Vec<Date>confirms: Vec<Date>

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/struct.StatsPayload.html b/mcaptcha/stats/fetch/struct.StatsPayload.html index 5bafc4c8..cd916f76 100644 --- a/mcaptcha/stats/fetch/struct.StatsPayload.html +++ b/mcaptcha/stats/fetch/struct.StatsPayload.html @@ -1,118 +1,117 @@ -StatsPayload in mcaptcha::stats::fetch - Rust - -

Struct mcaptcha::stats::fetch::StatsPayload[−][src]

pub struct StatsPayload {
-    pub key: String,
-}

- Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +StatsPayload in mcaptcha::stats::fetch - Rust

Struct mcaptcha::stats::fetch::StatsPayload[−][src]

pub struct StatsPayload {
+    pub key: String,
+}

Fields

key: String

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/fetch/struct.StatsUnixTimestamp.html b/mcaptcha/stats/fetch/struct.StatsUnixTimestamp.html index 2f807687..e5a30144 100644 --- a/mcaptcha/stats/fetch/struct.StatsUnixTimestamp.html +++ b/mcaptcha/stats/fetch/struct.StatsUnixTimestamp.html @@ -1,121 +1,120 @@ -StatsUnixTimestamp in mcaptcha::stats::fetch - Rust - -

Struct mcaptcha::stats::fetch::StatsUnixTimestamp[−][src]

pub struct StatsUnixTimestamp {
-    pub config_fetches: Vec<i64>,
-    pub solves: Vec<i64>,
-    pub confirms: Vec<i64>,
-}

- Fields

config_fetches: Vec<i64>solves: Vec<i64>confirms: Vec<i64>

Implementations

featch PoWConfig confirms

-

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +StatsUnixTimestamp in mcaptcha::stats::fetch - Rust

Struct mcaptcha::stats::fetch::StatsUnixTimestamp[−][src]

pub struct StatsUnixTimestamp {
+    pub config_fetches: Vec<i64>,
+    pub solves: Vec<i64>,
+    pub confirms: Vec<i64>,
+}

Fields

config_fetches: Vec<i64>solves: Vec<i64>confirms: Vec<i64>

Implementations

featch PoWConfig confirms

+

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/index.html b/mcaptcha/stats/index.html index 96c8186b..63482fc4 100644 --- a/mcaptcha/stats/index.html +++ b/mcaptcha/stats/index.html @@ -1,4 +1,4 @@ -mcaptcha::stats - Rust - -

Module mcaptcha::stats[−][src]

Modules

-
fetch
record
\ No newline at end of file +mcaptcha::stats - Rust

Module mcaptcha::stats[−][src]

Modules

+
fetch
record
+ + \ No newline at end of file diff --git a/mcaptcha/stats/record/fn.record_confirm.html b/mcaptcha/stats/record/fn.record_confirm.html index 52a2fb24..f6273afd 100644 --- a/mcaptcha/stats/record/fn.record_confirm.html +++ b/mcaptcha/stats/record/fn.record_confirm.html @@ -1,4 +1,4 @@ -record_confirm in mcaptcha::stats::record - Rust - -

Function mcaptcha::stats::record::record_confirm[−][src]

pub async fn record_confirm(key: &str, db: &PgPool)
Expand description

record PoWConfig confirms

-
\ No newline at end of file +record_confirm in mcaptcha::stats::record - Rust

Function mcaptcha::stats::record::record_confirm[−][src]

pub async fn record_confirm(key: &str, db: &PgPool)
Expand description

record PoWConfig confirms

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/record/fn.record_fetch.html b/mcaptcha/stats/record/fn.record_fetch.html index b1e2e55a..4ffffb2e 100644 --- a/mcaptcha/stats/record/fn.record_fetch.html +++ b/mcaptcha/stats/record/fn.record_fetch.html @@ -1,4 +1,4 @@ -record_fetch in mcaptcha::stats::record - Rust - -

Function mcaptcha::stats::record::record_fetch[−][src]

pub async fn record_fetch(key: &str, db: &PgPool)
Expand description

record PoWConfig fetches

-
\ No newline at end of file +record_fetch in mcaptcha::stats::record - Rust

Function mcaptcha::stats::record::record_fetch[−][src]

pub async fn record_fetch(key: &str, db: &PgPool)
Expand description

record PoWConfig fetches

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/record/fn.record_solve.html b/mcaptcha/stats/record/fn.record_solve.html index 59d69a85..642a95c0 100644 --- a/mcaptcha/stats/record/fn.record_solve.html +++ b/mcaptcha/stats/record/fn.record_solve.html @@ -1,4 +1,4 @@ -record_solve in mcaptcha::stats::record - Rust - -

Function mcaptcha::stats::record::record_solve[−][src]

pub async fn record_solve(key: &str, db: &PgPool)
Expand description

record PoWConfig solves

-
\ No newline at end of file +record_solve in mcaptcha::stats::record - Rust

Function mcaptcha::stats::record::record_solve[−][src]

pub async fn record_solve(key: &str, db: &PgPool)
Expand description

record PoWConfig solves

+
+ + \ No newline at end of file diff --git a/mcaptcha/stats/record/index.html b/mcaptcha/stats/record/index.html index 046215a2..1629dc1a 100644 --- a/mcaptcha/stats/record/index.html +++ b/mcaptcha/stats/record/index.html @@ -1,7 +1,7 @@ -mcaptcha::stats::record - Rust - -

Module mcaptcha::stats::record[−][src]

Functions

-
record_confirm

record PoWConfig confirms

-
record_fetch

record PoWConfig fetches

-
record_solve

record PoWConfig solves

-
\ No newline at end of file +mcaptcha::stats::record - Rust

Module mcaptcha::stats::record[−][src]

Functions

+
record_confirm

record PoWConfig confirms

+
record_fetch

record PoWConfig fetches

+
record_solve

record PoWConfig solves

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.BAR_CHART.html b/mcaptcha/struct.BAR_CHART.html index 9018bec0..8b27dab3 100644 --- a/mcaptcha/struct.BAR_CHART.html +++ b/mcaptcha/struct.BAR_CHART.html @@ -1,111 +1,110 @@ -BAR_CHART in mcaptcha - Rust - -

Struct mcaptcha::BAR_CHART[−][src]

pub struct BAR_CHART {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +BAR_CHART in mcaptcha - Rust

Struct mcaptcha::BAR_CHART[−][src]

pub struct BAR_CHART {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.CREDIT_CARD.html b/mcaptcha/struct.CREDIT_CARD.html index 8727b867..0c58a9a3 100644 --- a/mcaptcha/struct.CREDIT_CARD.html +++ b/mcaptcha/struct.CREDIT_CARD.html @@ -1,111 +1,110 @@ -CREDIT_CARD in mcaptcha - Rust - -

Struct mcaptcha::CREDIT_CARD[−][src]

pub struct CREDIT_CARD {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CREDIT_CARD in mcaptcha - Rust

Struct mcaptcha::CREDIT_CARD[−][src]

pub struct CREDIT_CARD {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.CSS.html b/mcaptcha/struct.CSS.html index b5be8b37..7b687e10 100644 --- a/mcaptcha/struct.CSS.html +++ b/mcaptcha/struct.CSS.html @@ -1,111 +1,110 @@ -CSS in mcaptcha - Rust - -

Struct mcaptcha::CSS[−][src]

pub struct CSS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CSS in mcaptcha - Rust

Struct mcaptcha::CSS[−][src]

pub struct CSS {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.CheckLogin.html b/mcaptcha/struct.CheckLogin.html index 1b418e69..b2f44af3 100644 --- a/mcaptcha/struct.CheckLogin.html +++ b/mcaptcha/struct.CheckLogin.html @@ -1,112 +1,112 @@ -CheckLogin in mcaptcha - Rust - -

Struct mcaptcha::CheckLogin[−][src]

pub struct CheckLogin;

Trait Implementations

Responses produced by the service.

-

Errors produced by the service.

-

The TransformService value created by this factory

-

Errors produced while building a transform service.

-

The future response value.

-

Creates and returns a new Transform component, asynchronously

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +CheckLogin in mcaptcha - Rust

Struct mcaptcha::CheckLogin[−][src]

pub struct CheckLogin;

Trait Implementations

Responses produced by the service.

+

Errors produced by the service.

+

The TransformService value created by this factory

+

Errors produced while building a transform service.

+

The future response value.

+

Creates and returns a new Transform component, asynchronously

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.DOCS_ICON.html b/mcaptcha/struct.DOCS_ICON.html index 5987203b..c46be375 100644 --- a/mcaptcha/struct.DOCS_ICON.html +++ b/mcaptcha/struct.DOCS_ICON.html @@ -1,111 +1,110 @@ -DOCS_ICON in mcaptcha - Rust - -

Struct mcaptcha::DOCS_ICON[−][src]

pub struct DOCS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +DOCS_ICON in mcaptcha - Rust

Struct mcaptcha::DOCS_ICON[−][src]

pub struct DOCS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.Data.html b/mcaptcha/struct.Data.html index 3ec7a539..a3c9041e 100644 --- a/mcaptcha/struct.Data.html +++ b/mcaptcha/struct.Data.html @@ -1,118 +1,117 @@ -Data in mcaptcha - Rust - -

Struct mcaptcha::Data[−][src]

pub struct Data {
+Data in mcaptcha - Rust
Struct mcaptcha::Data[−][src]
pub struct Data {
     pub db: PgPool,
     pub creds: Config,
     pub captcha: SystemGroup,
-    pub mailer: Option<AsyncSmtpTransport<Tokio1Executor>>,
+    pub mailer: Option<AsyncSmtpTransport<Tokio1Executor>>,
 }
Expand description
App data

-

-                       Fields
db: PgPool
databse pool

+
Fields
db: PgPool
databse pool

 
creds: Config
credential management configuration

 
captcha: SystemGroup
mCaptcha system: Redis cache, etc.

-
mailer: Option<AsyncSmtpTransport<Tokio1Executor>>
email client

-
Implementations
create new instance of app data

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+
mailer: Option<AsyncSmtpTransport<Tokio1Executor>>
email client

+
Implementations
create new instance of app data

+
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

+
Immutably borrows from an owned value. Read more

+
Mutably borrows from an owned value. Read more

+
Converts self into T using Into<T>. Read more

+
Converts self into a target type. Read more

+
Causes self to use its Binary implementation when Debug-formatted.

+
Causes self to use its Display implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerExp implementation when
+
Causes self to use its LowerExp implementation when
 Debug-formatted. Read more

-
Causes self to use its LowerHex implementation when
+
Causes self to use its LowerHex implementation when
 Debug-formatted. Read more

-
Causes self to use its Octal implementation when Debug-formatted.

-
Causes self to use its Pointer implementation when
+
Causes self to use its Octal implementation when Debug-formatted.

+
Causes self to use its Pointer implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperExp implementation when
+
Causes self to use its UpperExp implementation when
 Debug-formatted. Read more

-
Causes self to use its UpperHex implementation when
+
Causes self to use its UpperHex implementation when
 Debug-formatted. Read more

-
Performs the conversion.

-
Instruments this type with the provided Span, returning an
+
Performs the conversion.

+
Instruments this type with the provided Span, returning an
 Instrumented wrapper. Read more

-
Instruments this type with the current Span, returning an
+
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more

-
Performs the conversion.

-
Pipes by value. This is generally the method you want to use. Read more

-
Borrows self and passes that borrow into the pipe function. Read more

-
Mutably borrows self and passes that borrow into the pipe function. Read more

-
Borrows self, then passes self.borrow() into the pipe function. Read more

-
Mutably borrows self, then passes self.borrow_mut() into the pipe
+
Performs the conversion.

+
Pipes by value. This is generally the method you want to use. Read more

+
Borrows self and passes that borrow into the pipe function. Read more

+
Mutably borrows self and passes that borrow into the pipe function. Read more

+
Borrows self, then passes self.borrow() into the pipe function. Read more

+
Mutably borrows self, then passes self.borrow_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.as_ref() into the pipe function.

-
Mutably borrows self, then passes self.as_mut() into the pipe
+
Borrows self, then passes self.as_ref() into the pipe function.

+
Mutably borrows self, then passes self.as_mut() into the pipe
 function. Read more

-
Borrows self, then passes self.deref() into the pipe function.

-
Mutably borrows self, then passes self.deref_mut() into the pipe
+
Borrows self, then passes self.deref() into the pipe function.

+
Mutably borrows self, then passes self.deref_mut() into the pipe
 function. Read more

-
Pipes a value into a function that cannot ordinarily be called in suffix
+
Pipes a value into a function that cannot ordinarily be called in suffix
 position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a trait borrow into a function that cannot normally be called in
+
Pipes a trait borrow into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a trait mutable borrow into a function that cannot normally be
+
Pipes a trait mutable borrow into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a dereference into a function that cannot normally be called in
+
Pipes a dereference into a function that cannot normally be called in
 suffix position. Read more

-
Pipes a mutable dereference into a function that cannot normally be
+
Pipes a mutable dereference into a function that cannot normally be
 called in suffix position. Read more

-
Pipes a reference into a function that cannot ordinarily be called in
+
Pipes a reference into a function that cannot ordinarily be called in
 suffix position. Read more

-
Pipes a mutable reference into a function that cannot ordinarily be
+
Pipes a mutable reference into a function that cannot ordinarily be
 called in suffix position. Read more

-
Should always be Self

-
Immutable access to a value. Read more

-
Mutable access to a value. Read more

-
Immutable access to the Borrow<B> of a value. Read more

-
Mutable access to the BorrowMut<B> of a value. Read more

-
Immutable access to the AsRef<R> view of a value. Read more

-
Mutable access to the AsMut<R> view of a value. Read more

-
Immutable access to the Deref::Target of a value. Read more

-
Mutable access to the Deref::Target of a value. Read more

-
Calls .tap() only in debug builds, and is erased in release builds.

-
Calls .tap_mut() only in debug builds, and is erased in release
+
Should always be Self

+
Immutable access to a value. Read more

+
Mutable access to a value. Read more

+
Immutable access to the Borrow<B> of a value. Read more

+
Mutable access to the BorrowMut<B> of a value. Read more

+
Immutable access to the AsRef<R> view of a value. Read more

+
Mutable access to the AsMut<R> view of a value. Read more

+
Immutable access to the Deref::Target of a value. Read more

+
Mutable access to the Deref::Target of a value. Read more

+
Calls .tap() only in debug builds, and is erased in release builds.

+
Calls .tap_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow() only in debug builds, and is erased in release
+
Calls .tap_borrow() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+
Calls .tap_borrow_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref() only in debug builds, and is erased in release
+
Calls .tap_ref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_ref_mut() only in debug builds, and is erased in release
+
Calls .tap_ref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref() only in debug builds, and is erased in release
+
Calls .tap_deref() only in debug builds, and is erased in release
 builds. Read more

-
Calls .tap_deref_mut() only in debug builds, and is erased in release
+
Calls .tap_deref_mut() only in debug builds, and is erased in release
 builds. Read more

-
Provides immutable access for inspection. Read more

-
Calls tap in debug builds, and does nothing in release builds.

-
Provides mutable access for modification. Read more

-
Calls tap_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the reference for inspection.

-
Calls tap_ref in debug builds, and does nothing in release builds.

-
Provides mutable access to the reference for modification.

-
Calls tap_ref_mut in debug builds, and does nothing in release builds.

-
Provides immutable access to the borrow for inspection. Read more

-
Calls tap_borrow in debug builds, and does nothing in release builds.

-
Provides mutable access to the borrow for modification.

-
Calls tap_borrow_mut in debug builds, and does nothing in release
+
Provides immutable access for inspection. Read more

+
Calls tap in debug builds, and does nothing in release builds.

+
Provides mutable access for modification. Read more

+
Calls tap_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the reference for inspection.

+
Calls tap_ref in debug builds, and does nothing in release builds.

+
Provides mutable access to the reference for modification.

+
Calls tap_ref_mut in debug builds, and does nothing in release builds.

+
Provides immutable access to the borrow for inspection. Read more

+
Calls tap_borrow in debug builds, and does nothing in release builds.

+
Provides mutable access to the borrow for modification.

+
Calls tap_borrow_mut in debug builds, and does nothing in release
 builds. Read more

-
Immutably dereferences self for inspection.

-
Calls tap_deref in debug builds, and does nothing in release builds.

-
Mutably dereferences self for modification.

-
Calls tap_deref_mut in debug builds, and does nothing in release
+
Immutably dereferences self for inspection.

+
Calls tap_deref in debug builds, and does nothing in release builds.

+
Mutably dereferences self for modification.

+
Calls tap_deref_mut in debug builds, and does nothing in release
 builds. Read more

-
Attempts to convert self into T using TryInto<T>. Read more

-
Attempts to convert self into a target type. Read more

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-
The type returned in the event of a conversion error.

-
Performs the conversion.

-

\ No newline at end of file
+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.FILES.html b/mcaptcha/struct.FILES.html index 44f1ba00..df3efd4f 100644 --- a/mcaptcha/struct.FILES.html +++ b/mcaptcha/struct.FILES.html @@ -1,111 +1,110 @@ -FILES in mcaptcha - Rust - -

Struct mcaptcha::FILES[−][src]

pub struct FILES {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = FileMap>

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +FILES in mcaptcha - Rust

Struct mcaptcha::FILES[−][src]

pub struct FILES {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = FileMap>

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.GITHUB.html b/mcaptcha/struct.GITHUB.html index afe4d742..8b15681f 100644 --- a/mcaptcha/struct.GITHUB.html +++ b/mcaptcha/struct.GITHUB.html @@ -1,111 +1,110 @@ -GITHUB in mcaptcha - Rust - -

Struct mcaptcha::GITHUB[−][src]

pub struct GITHUB {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +GITHUB in mcaptcha - Rust

Struct mcaptcha::GITHUB[−][src]

pub struct GITHUB {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.HELP_CIRCLE.html b/mcaptcha/struct.HELP_CIRCLE.html index 62a27a5d..2f90114b 100644 --- a/mcaptcha/struct.HELP_CIRCLE.html +++ b/mcaptcha/struct.HELP_CIRCLE.html @@ -1,111 +1,110 @@ -HELP_CIRCLE in mcaptcha - Rust - -

Struct mcaptcha::HELP_CIRCLE[−][src]

pub struct HELP_CIRCLE {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +HELP_CIRCLE in mcaptcha - Rust

Struct mcaptcha::HELP_CIRCLE[−][src]

pub struct HELP_CIRCLE {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.HOME.html b/mcaptcha/struct.HOME.html index 8aeb773f..e4665fff 100644 --- a/mcaptcha/struct.HOME.html +++ b/mcaptcha/struct.HOME.html @@ -1,111 +1,110 @@ -HOME in mcaptcha - Rust - -

Struct mcaptcha::HOME[−][src]

pub struct HOME {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +HOME in mcaptcha - Rust

Struct mcaptcha::HOME[−][src]

pub struct HOME {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.JS.html b/mcaptcha/struct.JS.html index 4e05d8c4..f19673bc 100644 --- a/mcaptcha/struct.JS.html +++ b/mcaptcha/struct.JS.html @@ -1,111 +1,110 @@ -JS in mcaptcha - Rust - -

Struct mcaptcha::JS[−][src]

pub struct JS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +JS in mcaptcha - Rust

Struct mcaptcha::JS[−][src]

pub struct JS {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.KEY.html b/mcaptcha/struct.KEY.html index ad9cea84..70977218 100644 --- a/mcaptcha/struct.KEY.html +++ b/mcaptcha/struct.KEY.html @@ -1,111 +1,110 @@ -KEY in mcaptcha - Rust - -

Struct mcaptcha::KEY[−][src]

pub struct KEY {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +KEY in mcaptcha - Rust

Struct mcaptcha::KEY[−][src]

pub struct KEY {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.MCAPTCHA_TRANS_ICON.html b/mcaptcha/struct.MCAPTCHA_TRANS_ICON.html index 02388d86..7af8bdc9 100644 --- a/mcaptcha/struct.MCAPTCHA_TRANS_ICON.html +++ b/mcaptcha/struct.MCAPTCHA_TRANS_ICON.html @@ -1,111 +1,110 @@ -MCAPTCHA_TRANS_ICON in mcaptcha - Rust - -

Struct mcaptcha::MCAPTCHA_TRANS_ICON[−][src]

pub struct MCAPTCHA_TRANS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MCAPTCHA_TRANS_ICON in mcaptcha - Rust

Struct mcaptcha::MCAPTCHA_TRANS_ICON[−][src]

pub struct MCAPTCHA_TRANS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.MESSAGE.html b/mcaptcha/struct.MESSAGE.html index e8e078bc..72f3adff 100644 --- a/mcaptcha/struct.MESSAGE.html +++ b/mcaptcha/struct.MESSAGE.html @@ -1,111 +1,110 @@ -MESSAGE in mcaptcha - Rust - -

Struct mcaptcha::MESSAGE[−][src]

pub struct MESSAGE {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MESSAGE in mcaptcha - Rust

Struct mcaptcha::MESSAGE[−][src]

pub struct MESSAGE {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.MOBILE_CSS.html b/mcaptcha/struct.MOBILE_CSS.html index 587da041..8cd85d16 100644 --- a/mcaptcha/struct.MOBILE_CSS.html +++ b/mcaptcha/struct.MOBILE_CSS.html @@ -1,111 +1,110 @@ -MOBILE_CSS in mcaptcha - Rust - -

Struct mcaptcha::MOBILE_CSS[−][src]

pub struct MOBILE_CSS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +MOBILE_CSS in mcaptcha - Rust

Struct mcaptcha::MOBILE_CSS[−][src]

pub struct MOBILE_CSS {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.SETTINGS.html b/mcaptcha/struct.SETTINGS.html index cdfb7600..40613fc6 100644 --- a/mcaptcha/struct.SETTINGS.html +++ b/mcaptcha/struct.SETTINGS.html @@ -1,111 +1,110 @@ -SETTINGS in mcaptcha - Rust - -

Struct mcaptcha::SETTINGS[−][src]

pub struct SETTINGS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = Settings>

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SETTINGS in mcaptcha - Rust

Struct mcaptcha::SETTINGS[−][src]

pub struct SETTINGS {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = Settings>

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.SETTINGS_ICON.html b/mcaptcha/struct.SETTINGS_ICON.html index 3c368326..d63b106c 100644 --- a/mcaptcha/struct.SETTINGS_ICON.html +++ b/mcaptcha/struct.SETTINGS_ICON.html @@ -1,111 +1,110 @@ -SETTINGS_ICON in mcaptcha - Rust - -

Struct mcaptcha::SETTINGS_ICON[−][src]

pub struct SETTINGS_ICON {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SETTINGS_ICON in mcaptcha - Rust

Struct mcaptcha::SETTINGS_ICON[−][src]

pub struct SETTINGS_ICON {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.SOURCE_FILES_OF_INSTANCE.html b/mcaptcha/struct.SOURCE_FILES_OF_INSTANCE.html index 8f3fb6bb..acdea79c 100644 --- a/mcaptcha/struct.SOURCE_FILES_OF_INSTANCE.html +++ b/mcaptcha/struct.SOURCE_FILES_OF_INSTANCE.html @@ -1,10 +1,7 @@ -SOURCE_FILES_OF_INSTANCE in mcaptcha - Rust - -

Struct mcaptcha::SOURCE_FILES_OF_INSTANCE[−][src]

pub struct SOURCE_FILES_OF_INSTANCE {
-    __private_field: (),
+SOURCE_FILES_OF_INSTANCE in mcaptcha - Rust
Struct mcaptcha::SOURCE_FILES_OF_INSTANCE[−][src]
pub struct SOURCE_FILES_OF_INSTANCE {
+    __private_field: (),
 }
Expand description
points to source files matching build commit

-

-                       Fields
__private_field: ()
Methods from Deref<Target = String>
Extracts a string slice containing the entire String.

+
Fields
__private_field: ()
Methods from Deref<Target = String>
Extracts a string slice containing the entire String.

 
Examples

 
Basic usage:

 
@@ -12,7 +9,7 @@
 let s = String::from("foo");
 
 assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -20,8 +17,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -29,7 +26,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -42,7 +39,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -52,109 +49,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.Settings.html b/mcaptcha/struct.Settings.html index 74027b6b..016f4e16 100644 --- a/mcaptcha/struct.Settings.html +++ b/mcaptcha/struct.Settings.html @@ -1,126 +1,125 @@ -Settings in mcaptcha - Rust - -

Struct mcaptcha::Settings[−][src]

pub struct Settings {
-    pub debug: bool,
-    pub commercial: bool,
+Settings in mcaptcha - Rust
Struct mcaptcha::Settings[−][src]
pub struct Settings {
+    pub debug: bool,
+    pub commercial: bool,
     pub database: Database,
-    pub redis: Option<Redis>,
+    pub redis: Option<Redis>,
     pub server: Server,
     pub pow: Captcha,
-    pub source_code: String,
-    pub smtp: Option<Smtp>,
-    pub allow_registration: bool,
-    pub allow_demo: bool,
-}

-                       Fields
debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub source_code: String,
+    pub smtp: Option<Smtp>,
+    pub allow_registration: bool,
+    pub allow_demo: bool,
+}

Fields

debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.VERIFICATIN_WIDGET_CSS.html b/mcaptcha/struct.VERIFICATIN_WIDGET_CSS.html index 1cd70576..d4f03baf 100644 --- a/mcaptcha/struct.VERIFICATIN_WIDGET_CSS.html +++ b/mcaptcha/struct.VERIFICATIN_WIDGET_CSS.html @@ -1,111 +1,110 @@ -VERIFICATIN_WIDGET_CSS in mcaptcha - Rust - -

Struct mcaptcha::VERIFICATIN_WIDGET_CSS[−][src]

pub struct VERIFICATIN_WIDGET_CSS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +VERIFICATIN_WIDGET_CSS in mcaptcha - Rust

Struct mcaptcha::VERIFICATIN_WIDGET_CSS[−][src]

pub struct VERIFICATIN_WIDGET_CSS {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/struct.VERIFICATIN_WIDGET_JS.html b/mcaptcha/struct.VERIFICATIN_WIDGET_JS.html index 3bb65177..58c10455 100644 --- a/mcaptcha/struct.VERIFICATIN_WIDGET_JS.html +++ b/mcaptcha/struct.VERIFICATIN_WIDGET_JS.html @@ -1,111 +1,110 @@ -VERIFICATIN_WIDGET_JS in mcaptcha - Rust - -

Struct mcaptcha::VERIFICATIN_WIDGET_JS[−][src]

pub struct VERIFICATIN_WIDGET_JS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +VERIFICATIN_WIDGET_JS in mcaptcha - Rust

Struct mcaptcha::VERIFICATIN_WIDGET_JS[−][src]

pub struct VERIFICATIN_WIDGET_JS {
+    __private_field: (),
+}

Fields

__private_field: ()

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/type.AppData.html b/mcaptcha/type.AppData.html index 3edd7d97..2e8896c9 100644 --- a/mcaptcha/type.AppData.html +++ b/mcaptcha/type.AppData.html @@ -1,3 +1,3 @@ -AppData in mcaptcha - Rust - -

Type Definition mcaptcha::AppData[−][src]

type AppData = Data<Arc<Data>>;
\ No newline at end of file +AppData in mcaptcha - Rust

Type Definition mcaptcha::AppData[−][src]

pub type AppData = Data<Arc<Data>>;
+ + \ No newline at end of file diff --git a/mcaptcha/widget/constant.PAGE.html b/mcaptcha/widget/constant.PAGE.html index 31db034b..306c9cba 100644 --- a/mcaptcha/widget/constant.PAGE.html +++ b/mcaptcha/widget/constant.PAGE.html @@ -1,3 +1,3 @@ -PAGE in mcaptcha::widget - Rust - -

Constant mcaptcha::widget::PAGE[−][src]

const PAGE: &str = "mCaptcha CAPTCHA verification";
\ No newline at end of file +PAGE in mcaptcha::widget - Rust

Constant mcaptcha::widget::PAGE[−][src]

const PAGE: &str = "mCaptcha CAPTCHA verification";
+ + \ No newline at end of file diff --git a/mcaptcha/widget/constant.WIDGET_ROUTES.html b/mcaptcha/widget/constant.WIDGET_ROUTES.html index 517c4cbc..017ea127 100644 --- a/mcaptcha/widget/constant.WIDGET_ROUTES.html +++ b/mcaptcha/widget/constant.WIDGET_ROUTES.html @@ -1,3 +1,3 @@ -WIDGET_ROUTES in mcaptcha::widget - Rust - -

Constant mcaptcha::widget::WIDGET_ROUTES[−][src]

pub const WIDGET_ROUTES: Widget;
\ No newline at end of file +WIDGET_ROUTES in mcaptcha::widget - Rust

Constant mcaptcha::widget::WIDGET_ROUTES[−][src]

pub const WIDGET_ROUTES: Widget;
+ + \ No newline at end of file diff --git a/mcaptcha/widget/fn.services.html b/mcaptcha/widget/fn.services.html index 8d32bb6d..e350ece0 100644 --- a/mcaptcha/widget/fn.services.html +++ b/mcaptcha/widget/fn.services.html @@ -1,4 +1,4 @@ -services in mcaptcha::widget - Rust - -

Function mcaptcha::widget::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
Expand description

widget services

-
\ No newline at end of file +services in mcaptcha::widget - Rust

Function mcaptcha::widget::services[−][src]

pub fn services(cfg: &mut ServiceConfig)
Expand description

widget services

+
+ + \ No newline at end of file diff --git a/mcaptcha/widget/index.html b/mcaptcha/widget/index.html index afcb4a55..c1ea3ebc 100644 --- a/mcaptcha/widget/index.html +++ b/mcaptcha/widget/index.html @@ -1,10 +1,10 @@ -mcaptcha::widget - Rust - -

Module mcaptcha::widget[−][src]

Expand description

User facing CAPTCHA widget

+mcaptcha::widget - Rust

Module mcaptcha::widget[−][src]

Expand description

User facing CAPTCHA widget

Modules

-
routes

Structs

-
INDEX_PAGE
IndexPage
show_widget

render a client side widget for CAPTCHA verification

-

Constants

-
PAGE
WIDGET_ROUTES

Functions

-
services

widget services

-
\ No newline at end of file +
routes

Structs

+
INDEX_PAGE
IndexPage
show_widget

render a client side widget for CAPTCHA verification

+

Constants

+
PAGE
WIDGET_ROUTES

Functions

+
services

widget services

+
+ + \ No newline at end of file diff --git a/mcaptcha/widget/routes/index.html b/mcaptcha/widget/routes/index.html index 149dbc29..7e42cf67 100644 --- a/mcaptcha/widget/routes/index.html +++ b/mcaptcha/widget/routes/index.html @@ -1,4 +1,4 @@ -mcaptcha::widget::routes - Rust - -

Module mcaptcha::widget::routes[−][src]

Structs

-
Widget
\ No newline at end of file +mcaptcha::widget::routes - Rust

Module mcaptcha::widget::routes[−][src]

Structs

+
Widget
+ + \ No newline at end of file diff --git a/mcaptcha/widget/routes/struct.Widget.html b/mcaptcha/widget/routes/struct.Widget.html index 283ebe7e..c78ee510 100644 --- a/mcaptcha/widget/routes/struct.Widget.html +++ b/mcaptcha/widget/routes/struct.Widget.html @@ -1,109 +1,108 @@ -Widget in mcaptcha::widget::routes - Rust - -

Struct mcaptcha::widget::routes::Widget[−][src]

pub struct Widget {
-    pub verification_widget: &'static str,
-}

- Fields

verification_widget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Widget in mcaptcha::widget::routes - Rust

Struct mcaptcha::widget::routes::Widget[−][src]

pub struct Widget {
+    pub verification_widget: &'static str,
+}

Fields

verification_widget: &'static str

Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/widget/struct.INDEX_PAGE.html b/mcaptcha/widget/struct.INDEX_PAGE.html index f03b19ae..38d2eaca 100644 --- a/mcaptcha/widget/struct.INDEX_PAGE.html +++ b/mcaptcha/widget/struct.INDEX_PAGE.html @@ -1,9 +1,6 @@ -INDEX_PAGE in mcaptcha::widget - Rust - -

Struct mcaptcha::widget::INDEX_PAGE[−][src]

struct INDEX_PAGE {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

+INDEX_PAGE in mcaptcha::widget - Rust

Struct mcaptcha::widget::INDEX_PAGE[−][src]

struct INDEX_PAGE {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = String>

Extracts a string slice containing the entire String.

Examples

Basic usage:

@@ -11,7 +8,7 @@ let s = String::from("foo"); assert_eq!("foo", s.as_str());
-

Returns this String’s capacity, in bytes.

+

Returns this String’s capacity, in bytes.

Examples

Basic usage:

@@ -19,8 +16,8 @@ let s = String::with_capacity(10); assert!(s.capacity() >= 10);
-

Returns a byte slice of this String’s contents.

-

The inverse of this method is from_utf8.

+

Returns a byte slice of this String’s contents.

+

The inverse of this method is from_utf8.

Examples

Basic usage:

@@ -28,7 +25,7 @@ let s = String::from("hello"); assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-

Returns the length of this String, in bytes, not chars or +

Returns the length of this String, in bytes, not chars or graphemes. In other words, it may not be what a human considers the length of the string.

Examples

@@ -41,7 +38,7 @@ length of the string.

let fancy_f = String::from("ƒoo"); assert_eq!(fancy_f.len(), 4); assert_eq!(fancy_f.chars().count(), 3);
-

Returns true if this String has a length of zero, and false otherwise.

+

Returns true if this String has a length of zero, and false otherwise.

Examples

Basic usage:

@@ -51,109 +48,111 @@ length of the string.

v.push('a'); assert!(!v.is_empty());
-

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/widget/struct.IndexPage.html b/mcaptcha/widget/struct.IndexPage.html index cf1623ca..e95b29fe 100644 --- a/mcaptcha/widget/struct.IndexPage.html +++ b/mcaptcha/widget/struct.IndexPage.html @@ -1,114 +1,114 @@ -IndexPage in mcaptcha::widget - Rust - -

Struct mcaptcha::widget::IndexPage[−][src]

pub struct IndexPage;

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Render the template and return the rendering result as RenderResult Read more

-

Render the template and append the result to buf. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +IndexPage in mcaptcha::widget - Rust

Struct mcaptcha::widget::IndexPage[−][src]

pub struct IndexPage;

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Render the template and return the rendering result as RenderResult Read more

+

Render the template and append the result to buf. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha/widget/struct.show_widget.html b/mcaptcha/widget/struct.show_widget.html index e63dfcc1..3211c25e 100644 --- a/mcaptcha/widget/struct.show_widget.html +++ b/mcaptcha/widget/struct.show_widget.html @@ -1,107 +1,107 @@ -show_widget in mcaptcha::widget - Rust - -

Struct mcaptcha::widget::show_widget[−][src]

pub struct show_widget;
Expand description

render a client side widget for CAPTCHA verification

-

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +show_widget in mcaptcha::widget - Rust

Struct mcaptcha::widget::show_widget[−][src]

pub struct show_widget;
Expand description

render a client side widget for CAPTCHA verification

+

Trait Implementations

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/mcaptcha_browser/all.html b/mcaptcha_browser/all.html index 48fc1ef6..bdcf8ddc 100644 --- a/mcaptcha_browser/all.html +++ b/mcaptcha_browser/all.html @@ -1,5 +1,5 @@ -List of all items in this crate - -

List of all items[−] +List of all items in this crate

List of all items[−] -

Structs

Functions

\ No newline at end of file +

Structs

Functions

+ + \ No newline at end of file diff --git a/mcaptcha_browser/fn.__wasm_bindgen_generated_gen_pow.html b/mcaptcha_browser/fn.__wasm_bindgen_generated_gen_pow.html index 0867e4f0..72bf7f52 100644 --- a/mcaptcha_browser/fn.__wasm_bindgen_generated_gen_pow.html +++ b/mcaptcha_browser/fn.__wasm_bindgen_generated_gen_pow.html @@ -1,6 +1,4 @@ -__wasm_bindgen_generated_gen_pow in mcaptcha_browser - Rust - -

Function mcaptcha_browser::__wasm_bindgen_generated_gen_pow[−][src]

pub extern "C" fn __wasm_bindgen_generated_gen_pow(
    arg0: <String as FromWasmAbi>::Abi, 
    arg1: <String as FromWasmAbi>::Abi, 
    arg2: <u32 as FromWasmAbi>::Abi
) -> <String as ReturnWasmAbi>::Abi
Expand description

generate proof-of-work

+__wasm_bindgen_generated_gen_pow in mcaptcha_browser - Rust

Function mcaptcha_browser::__wasm_bindgen_generated_gen_pow[−][src]

pub extern "C" fn __wasm_bindgen_generated_gen_pow(
    arg0: <String as FromWasmAbi>::Abi, 
    arg1: <String as FromWasmAbi>::Abi, 
    arg2: <u32 as FromWasmAbi>::Abi
) -> <String as ReturnWasmAbi>::Abi
Expand description

generate proof-of-work

 fn main() {
@@ -32,4 +30,6 @@
    assert!(config.is_valid_proof(&work, &PHRASE.to_string()));
    assert!(config.is_sufficient_difficulty(&work, DIFFICULTY));
 }
-
\ No newline at end of file +
+ + \ No newline at end of file diff --git a/mcaptcha_browser/fn.gen_pow.html b/mcaptcha_browser/fn.gen_pow.html index 4a749944..caa0aaf2 100644 --- a/mcaptcha_browser/fn.gen_pow.html +++ b/mcaptcha_browser/fn.gen_pow.html @@ -1,6 +1,4 @@ -gen_pow in mcaptcha_browser - Rust - -

Function mcaptcha_browser::gen_pow[−][src]

pub fn gen_pow(salt: String, phrase: String, difficulty_factor: u32) -> String
Expand description

generate proof-of-work

+gen_pow in mcaptcha_browser - Rust

Function mcaptcha_browser::gen_pow[−][src]

pub fn gen_pow(salt: String, phrase: String, difficulty_factor: u32) -> String
Expand description

generate proof-of-work

 fn main() {
@@ -32,4 +30,6 @@
    assert!(config.is_valid_proof(&work, &PHRASE.to_string()));
    assert!(config.is_sufficient_difficulty(&work, DIFFICULTY));
 }
-
\ No newline at end of file +
+ + \ No newline at end of file diff --git a/mcaptcha_browser/index.html b/mcaptcha_browser/index.html index e4251b50..cdbe0489 100644 --- a/mcaptcha_browser/index.html +++ b/mcaptcha_browser/index.html @@ -1,6 +1,4 @@ -mcaptcha_browser - Rust - -

Crate mcaptcha_browser[−][src]

Expand description

mCaptcha is a proof of work based Denaial-of-Service attack protection system. +mcaptcha_browser - Rust

Crate mcaptcha_browser[−][src]

Expand description

mCaptcha is a proof of work based Denaial-of-Service attack protection system. This is is a WASM library that you can embed in your frontend code to protect your service.

A commercial managed solution is in the works but I’d much rather prefer @@ -47,7 +45,9 @@ folks host their own instances as it will make the more decentralized and free.< assert!(config.is_valid_proof(&work, &PHRASE.to_string())); assert!(config.is_sufficient_difficulty(&work, DIFFICULTY));

Structs

-
Work

Functions

-
__wasm_bindgen_generated_gen_pow

generate proof-of-work

-
gen_pow

generate proof-of-work

-
\ No newline at end of file +
Work

Functions

+
__wasm_bindgen_generated_gen_pow

generate proof-of-work

+
gen_pow

generate proof-of-work

+
+ + \ No newline at end of file diff --git a/mcaptcha_browser/struct.Work.html b/mcaptcha_browser/struct.Work.html index 2c2b6f30..a8cd02e5 100644 --- a/mcaptcha_browser/struct.Work.html +++ b/mcaptcha_browser/struct.Work.html @@ -1,20 +1,19 @@ -Work in mcaptcha_browser - Rust - -

Struct mcaptcha_browser::Work[−][src]

pub struct Work {
-    pub result: String,
-    pub nonce: u64,
-}

- Fields

result: Stringnonce: u64

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

-

Performs the conversion.

-

Serialize this value into the given Serde serializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Performs the conversion.

-

Performs the conversion.

-

Should always be Self

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +Work in mcaptcha_browser - Rust

Struct mcaptcha_browser::Work[−][src]

pub struct Work {
+    pub result: String,
+    pub nonce: u64,
+}

Fields

result: Stringnonce: u64

Trait Implementations

Deserialize this value from the given Serde deserializer. Read more

+

Performs the conversion.

+

Serialize this value into the given Serde serializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Performs the conversion.

+

Performs the conversion.

+

Should always be Self

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/normalize.css b/normalize.css index 6d692b50..469959f1 100644 --- a/normalize.css +++ b/normalize.css @@ -1,2 +1,2 @@ - /*! normalize.css v3.0.0 | MIT License | git.io/normalize */ -html{font-family:sans-serif;-ms-text-size-adjust:100%;-webkit-text-size-adjust:100%}body{margin:0}article,aside,details,figcaption,figure,footer,header,hgroup,main,nav,section,summary{display:block}audio,canvas,progress,video{display:inline-block;vertical-align:baseline}audio:not([controls]){display:none;height:0}[hidden],template{display:none}a{background:transparent}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:bold}dfn{font-style:italic}h1{font-size:2em;margin:.67em 0}mark{background:#ff0;color:#000}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{border:0}svg:not(:root){overflow:hidden}figure{margin:1em 40px}hr{-moz-box-sizing:content-box;box-sizing:content-box;height:0}pre{overflow:auto}code,kbd,pre,samp{font-family:monospace,monospace;font-size:1em}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0}button{overflow:visible}button,select{text-transform:none}button,html input[type="button"],input[type="reset"],input[type="submit"]{-webkit-appearance:button;cursor:pointer}button[disabled],html input[disabled]{cursor:default}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}input{line-height:normal}input[type="checkbox"],input[type="radio"]{box-sizing:border-box;padding:0}input[type="number"]::-webkit-inner-spin-button,input[type="number"]::-webkit-outer-spin-button{height:auto}input[type="search"]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}input[type="search"]::-webkit-search-cancel-button,input[type="search"]::-webkit-search-decoration{-webkit-appearance:none}fieldset{border:1px solid silver;margin:0 2px;padding:.35em .625em .75em}legend{border:0;padding:0}textarea{overflow:auto}optgroup{font-weight:bold}table{border-collapse:collapse;border-spacing:0}td,th{padding:0} \ No newline at end of file + /*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */ +html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:0.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace,monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-0.25em}sup{top:-0.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type="button"],[type="reset"],[type="submit"],button{-webkit-appearance:button}[type="button"]::-moz-focus-inner,[type="reset"]::-moz-focus-inner,[type="submit"]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type="button"]:-moz-focusring,[type="reset"]:-moz-focusring,[type="submit"]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:0.35em 0.75em 0.625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type="checkbox"],[type="radio"]{box-sizing:border-box;padding:0}[type="number"]::-webkit-inner-spin-button,[type="number"]::-webkit-outer-spin-button{height:auto}[type="search"]{-webkit-appearance:textfield;outline-offset:-2px}[type="search"]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none} \ No newline at end of file diff --git a/rustdoc.css b/rustdoc.css index 9b9be798..651e73c6 100644 --- a/rustdoc.css +++ b/rustdoc.css @@ -1 +1 @@ - @font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular.woff2") format("woff2"),url("FiraSans-Regular.woff") format('woff');font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium.woff2") format("woff2"),url("FiraSans-Medium.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:400;src:local('Source Serif 4'),url("SourceSerif4-Regular.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:italic;font-weight:400;src:local('Source Serif 4 Italic'),url("SourceSerif4-It.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:700;src:local('Source Serif 4 Bold'),url("SourceSerif4-Bold.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:italic;font-weight:400;src:url("SourceCodePro-It.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold.ttf.woff") format('woff');font-display:swap;}@font-face {font-family:'Noto Sans KR';src:url("noto-sans-kr-v13-korean-regular.woff") format("woff");font-display:swap;unicode-range:U+A960-A97F,U+AC00-D7AF,U+D7B0-D7FF;}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}html{content:"";}@media (prefers-color-scheme:light){html{content:"light";}}@media (prefers-color-scheme:dark){html{content:"dark";}}body{font:16px/1.4 "Source Serif 4","Noto Sans KR",serif;margin:0;position:relative;padding:10px 15px 20px 15px;-webkit-font-feature-settings:"kern","liga";-moz-font-feature-settings:"kern","liga";font-feature-settings:"kern","liga";}h1{font-size:1.5em;}h2{font-size:1.4em;}h3{font-size:1.3em;}h1,h2,h3,h4{font-weight:500;margin:20px 0 15px 0;padding-bottom:6px;}h1.fqn{display:flex;border-bottom:1px dashed;margin-top:0;padding-left:1px;}h1.fqn>.in-band>a:hover{text-decoration:underline;}#main>h2,#main>h3,#main>h4{border-bottom:1px solid;}h3.code-header,h4.code-header{font-size:1em;font-weight:600;border:none;padding:0;margin:0;}.impl,.impl-items .method,.methods .method,.impl-items .type,.methods .type,.impl-items .associatedconstant,.methods .associatedconstant,.impl-items .associatedtype,.methods .associatedtype{flex-basis:100%;font-weight:600;margin-top:16px;margin-bottom:10px;position:relative;}.impl,.method.trait-impl,.type.trait-impl,.associatedconstant.trait-impl,.associatedtype.trait-impl{padding-left:15px;}div.impl-items>div{padding-left:0;}h1,h2,h3,h4,.sidebar,a.source,.search-input,.search-results .result-name,.content table td:first-child>a,div.item-list .out-of-band,span.since,#source-sidebar,#sidebar-toggle,details.rustdoc-toggle>summary::before,details.undocumented>summary::before,div.impl-items>div:not(.docblock):not(.item-info),.content ul.crate a.crate,a.srclink,#main>ul.docblock>li>a{font-family:"Fira Sans",Arial,sans-serif;}.content ul.crate a.crate{font-size:16px/1.6;}ol,ul{padding-left:25px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.6em;}p{margin:0 0 .6em 0;}summary{outline:none;}td,th{padding:0;}table{border-collapse:collapse;}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0;}details:not(.rustdoc-toggle) summary{margin-bottom:.6em;}code,pre,a.test-arrow,.code-header{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.1em;}.docblock pre code,.docblock-short pre code{padding:0;padding-right:1ex;}pre{padding:14px;}.source .content pre{padding:20px;}img{max-width:100%;}li{position:relative;}.source .content{margin-top:50px;max-width:none;overflow:visible;margin-left:0px;}nav.sub{font-size:16px;text-transform:uppercase;}.sidebar{width:200px;position:fixed;left:0;top:0;bottom:0;overflow:auto;}*{scrollbar-width:initial;}.sidebar{scrollbar-width:thin;}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;}.sidebar .block>ul>li{margin-right:-10px;}.content,nav{max-width:960px;}.hidden{display:none !important;}.logo-container{height:100px;width:100px;position:relative;margin:20px auto;display:block;margin-top:10px;}.logo-container>img{max-width:100px;max-height:100px;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);display:block;}.sidebar .location{border:1px solid;font-size:17px;margin:30px 10px 20px 10px;text-align:center;word-wrap:break-word;font-weight:inherit;padding:0;}.sidebar .version{font-size:15px;text-align:center;border-bottom:1px solid;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;}.location:empty{border:none;}.location a:first-of-type{font-weight:500;}.location a:hover{text-decoration:underline;}.block{padding:0;margin-bottom:14px;}.block h2,.block h3{text-align:center;}.block ul,.block li{margin:0 10px;padding:0;list-style:none;}.block a{display:block;text-overflow:ellipsis;overflow:hidden;line-height:15px;padding:7px 5px;font-size:14px;font-weight:300;transition:border 500ms ease-out;}.sidebar-title{border-top:1px solid;border-bottom:1px solid;text-align:center;font-size:17px;margin-bottom:5px;font-weight:inherit;padding:0;}.sidebar-links{margin-bottom:15px;}.sidebar-links>a{padding-left:10px;width:100%;}.sidebar-menu{display:none;}.content{padding:15px 0;}.source .content pre.rust{white-space:pre;overflow:auto;padding-left:0;}.rustdoc .example-wrap{display:inline-flex;margin-bottom:10px;}.example-wrap{position:relative;width:100%;}.example-wrap>pre.line-number{overflow:initial;border:1px solid;padding:13px 8px;text-align:right;border-top-left-radius:5px;border-bottom-left-radius:5px;}.rustdoc:not(.source) .example-wrap>pre.rust{width:100%;overflow-x:auto;}.rustdoc .example-wrap>pre{margin:0;}#search{margin-left:230px;position:relative;}#results>table{width:100%;table-layout:fixed;}.content>.example-wrap pre.line-numbers{position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}.line-numbers span{cursor:pointer;}.docblock-short{overflow-wrap:anywhere;}.docblock-short p{display:inline;}.docblock-short p{overflow:hidden;text-overflow:ellipsis;margin:0;}.docblock>:not(pre)>code,.docblock-short>:not(pre)>code{white-space:pre-wrap;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom:1px solid;}.top-doc .docblock h1{font-size:1.3em;}.top-doc .docblock h2{font-size:1.15em;}.top-doc .docblock h3,.top-doc .docblock h4,.top-doc .docblock h5{font-size:1em;}.docblock h1{font-size:1em;}.docblock h2{font-size:0.95em;}.docblock h3,.docblock h4,.docblock h5{font-size:0.9em;}.docblock{margin-left:24px;position:relative;}.content .out-of-band{flex-grow:0;text-align:right;font-size:23px;margin:0px;padding:0 0 0 12px;font-weight:normal;}.method>.code-header,.trait-impl>.code-header,.invisible>.code-header{max-width:calc(100% - 41px);display:block;flex-grow:1;}.invisible{width:100%;display:inline-block;}.content .in-band{flex-grow:1;margin:0px;padding:0px;}.in-band>code,.in-band>.code-header{display:inline-block;}#main{position:relative;}#main>.since{top:inherit;font-family:"Fira Sans",Arial,sans-serif;}.content table:not(.table-display){border-spacing:0 5px;}.content td{vertical-align:top;}.content td:first-child{padding-right:20px;}.content td p:first-child{margin-top:0;}.content td h1,.content td h2{margin-left:0;font-size:1.1em;}.content tr:first-child td{border-top:0;}.docblock table{margin:.5em 0;width:calc(100% - 2px);border:1px dashed;}.docblock table td{padding:.5em;border:1px dashed;}.docblock table th{padding:.5em;text-align:left;border:1px solid;}.fields+table{margin-bottom:1em;}.content .item-list{list-style-type:none;padding:0;}.content .multi-column{-moz-column-count:5;-moz-column-gap:2.5em;-webkit-column-count:5;-webkit-column-gap:2.5em;column-count:5;column-gap:2.5em;}.content .multi-column li{width:100%;display:inline-block;}.content>.methods>.method{font-size:1em;position:relative;}.content .method .where,.content .fn .where,.content .where.fmt-newline{display:block;font-size:0.8em;}.content .methods>div:not(.notable-traits):not(.method){margin-left:40px;margin-bottom:15px;}.content .docblock>.impl-items{margin-left:20px;margin-top:-34px;}.content .docblock>.impl-items .table-display{margin:0;}.content .docblock>.impl-items table td{padding:0;}.content .docblock>.impl-items .table-display,.impl-items table td{border:none;}.content .item-info code{font-size:90%;}.content .item-info{position:relative;margin-left:33px;margin-top:-6px;}.sub-variant>div>.item-info{margin-top:initial;}.content .item-info::before{content:'⬑';font-size:25px;position:absolute;top:0px;left:-19px;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant,.impl-items>.associatedtype,.content .impl-items details>summary>.type,.impl-items details>summary>.associatedconstant,.impl-items details>summary>.associatedtype{margin-left:20px;}.content .impl-items .docblock,.content .impl-items .item-info{margin-bottom:.6em;}.content .impl-items>.item-info{margin-left:40px;}.methods>.item-info,.content .impl-items>.item-info{margin-top:-8px;}.impl-items{flex-basis:100%;}#main>.item-info{margin-top:0;}nav:not(.sidebar){border-bottom:1px solid;padding-bottom:10px;margin-bottom:10px;}nav.main{padding:20px 0;text-align:center;}nav.main .current{border-top:1px solid;border-bottom:1px solid;}nav.main .separator{border:1px solid;display:inline-block;height:23px;margin:0 20px;}nav.sum{text-align:right;}nav.sub form{display:inline;}nav.sub,.content{margin-left:230px;}a{text-decoration:none;background:transparent;}.small-section-header:hover>.anchor{display:initial;}.in-band:hover>.anchor,.impl:hover>.anchor,.method.trait-impl:hover>.anchor,.type.trait-impl:hover>.anchor,.associatedconstant.trait-impl:hover>.anchor,.associatedtype.trait-impl:hover>.anchor{display:inline-block;position:absolute;}.anchor{display:none;position:absolute;left:-7px;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-28px;padding-right:10px;}.anchor:before{content:'\2002\00a7\2002';}.docblock a:not(.srclink):not(.test-arrow):hover,.docblock-short a:not(.srclink):not(.test-arrow):hover,.item-info a{text-decoration:underline;}.invisible>.srclink,.method>.code-header+.srclink{position:absolute;top:0;right:0;font-size:17px;font-weight:normal;}.block a.current.crate{font-weight:500;}.search-container{position:relative;}.search-container>div{display:inline-flex;width:calc(100% - 63px);}#crate-search{min-width:115px;margin-top:5px;padding:6px;padding-right:19px;flex:none;border:0;border-right:0;border-radius:4px 0 0 4px;outline:none;cursor:pointer;border-right:1px solid;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;text-overflow:"";background-repeat:no-repeat;background-color:transparent;background-size:20px;background-position:calc(100% - 1px) 56%;}.search-container>.top-button{position:absolute;right:0;top:10px;}.search-input{-moz-box-sizing:border-box !important;box-sizing:border-box !important;outline:none;border:none;border-radius:1px;margin-top:5px;padding:10px 16px;font-size:17px;transition:border-color 300ms ease;transition:border-radius 300ms ease-in-out;transition:box-shadow 300ms ease-in-out;width:100%;}#crate-search+.search-input{border-radius:0 1px 1px 0;width:calc(100% - 32px);}.search-input:focus{border-radius:2px;border:0;outline:0;}.search-results{display:none;padding-bottom:2em;}.search-results.active{display:block;clear:both;}.search-results .desc>span{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block;}.search-results>a{display:block;width:100%;margin-left:2px;margin-right:2px;border-bottom:1px solid #aaa3;}.search-results>a>div{display:flex;flex-flow:row wrap;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:50%;}.search-results .result-name{padding-right:1em;}.search-results .result-name>span{display:inline-block;margin:0;font-weight:normal;}body.blur>:not(#help){filter:blur(8px);-webkit-filter:blur(8px);opacity:.7;}#help{width:100%;height:100vh;position:fixed;top:0;left:0;display:flex;justify-content:center;align-items:center;}#help>div{flex:0 0 auto;box-shadow:0 0 6px rgba(0,0,0,.2);width:550px;height:auto;border:1px solid;}#help dt{float:left;clear:left;display:block;margin-right:0.5rem;}#help>div>span{text-align:center;display:block;margin:10px 0;font-size:18px;border-bottom:1px solid #ccc;padding-bottom:4px;margin-bottom:6px;}#help dd{margin:5px 35px;}#help .infos{padding-left:0;}#help h1,#help h2{margin-top:0;}#help>div div{width:50%;float:left;padding:0 20px 20px 17px;;}.stab{display:table;border-width:1px;border-style:solid;padding:3px;margin-bottom:5px;font-size:90%;}.stab p{display:inline;}.stab summary{display:list-item;}.stab .emoji{font-size:1.5em;}.emoji{text-shadow:1px 0 0 black,-1px 0 0 black,0 1px 0 black,0 -1px 0 black;}.module-item .stab,.import-item .stab{border-radius:3px;display:inline-block;font-size:80%;line-height:1.2;margin-bottom:0;margin-right:.3em;padding:2px;vertical-align:text-bottom;}.module-item.unstable,.import-item.unstable{opacity:0.65;}.since{font-weight:normal;font-size:initial;position:absolute;right:0;top:0;}.impl-items .since,.impl .since,.methods .since{flex-grow:0;padding-left:12px;padding-right:6px;position:initial;}.impl-items .srclink,.impl .srclink,.methods .srclink{flex-grow:0;font-size:17px;font-weight:normal;}.impl-items code,.impl code,.methods code{flex-grow:1;}.has-srclink{display:flex;flex-basis:100%;font-size:16px;margin-bottom:12px;justify-content:space-between;}.variants_table{width:100%;}.variants_table tbody tr td:first-child{width:1%;}td.summary-column{width:100%;}.summary{padding-right:0px;}pre.rust .question-mark{font-weight:bold;}a.test-arrow{display:inline-block;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:130%;top:5px;right:5px;z-index:1;}a.test-arrow:hover{text-decoration:none;}.section-header:hover a:before{position:absolute;left:-25px;padding-right:10px;content:'\2002\00a7\2002';}.section-header:hover a{text-decoration:none;}.section-header a{color:inherit;}.code-attribute{font-weight:300;}.since+.srclink{display:table-cell;padding-left:10px;}.item-spacer{width:100%;height:12px;}.out-of-band>span.since{position:initial;font-size:20px;margin-right:5px;}.sub-variant,.sub-variant>h3{margin-top:0px !important;padding-top:1px;}#main>details>.sub-variant>h3{font-size:15px;margin-left:25px;margin-bottom:5px;}.sub-variant>div{margin-left:20px;margin-bottom:10px;}.sub-variant>div>span{display:block;position:relative;}.toggle-label{display:inline-block;margin-left:4px;margin-top:3px;}.docblock>.section-header:first-child{margin-left:15px;margin-top:0;}.docblock>.section-header:first-child:hover>a:before{left:-10px;}#main>.variant,#main>.structfield{display:block;}:target>code,:target>.code-header{opacity:1;}.information{position:absolute;left:-25px;margin-top:7px;z-index:1;}.tooltip{position:relative;display:inline-block;cursor:pointer;}.tooltip::after{display:none;text-align:center;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;font-size:16px;}.tooltip.ignore::after{content:"This example is not tested";}.tooltip.compile_fail::after{content:"This example deliberately fails to compile";}.tooltip.should_panic::after{content:"This example panics";}.tooltip.edition::after{content:"This code runs with edition " attr(data-edition);}.tooltip::before{content:" ";position:absolute;top:50%;left:16px;margin-top:-5px;border-width:5px;border-style:solid;display:none;}.tooltip:hover::before,.tooltip:hover::after{display:inline;}.tooltip.compile_fail,.tooltip.should_panic,.tooltip.ignore{font-weight:bold;font-size:20px;}.notable-traits-tooltip{display:inline-block;cursor:pointer;}.notable-traits:hover .notable-traits-tooltiptext,.notable-traits .notable-traits-tooltiptext.force-tooltip{display:inline-block;}.notable-traits .notable-traits-tooltiptext{display:none;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;z-index:10;font-size:16px;cursor:default;position:absolute;border:1px solid;}.notable-traits-tooltip::after{content:"\00a0\00a0\00a0";}.notable-traits .notable,.notable-traits .docblock{margin:0;}.notable-traits .notable{margin:0;margin-bottom:13px;font-size:19px;font-weight:600;}.notable-traits .docblock code.content{margin:0;padding:0;font-size:20px;}pre.rust.rust-example-rendered{position:relative;}pre.rust{tab-size:4;-moz-tab-size:4;}.search-failed{text-align:center;margin-top:20px;display:none;}.search-failed.active{display:block;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#titles{height:35px;}#titles>button{float:left;width:33.3%;text-align:center;font-size:18px;cursor:pointer;border:0;border-top:2px solid;}#titles>button:not(:last-child){margin-right:1px;width:calc(33.3% - 1px);}#titles>button>div.count{display:inline-block;font-size:16px;}.notable-traits{cursor:pointer;z-index:2;margin-left:5px;}#all-types{text-align:center;border:1px solid;margin:0 10px;margin-bottom:10px;display:block;border-radius:7px;}#all-types>p{margin:5px 0;}#sidebar-toggle{position:fixed;top:30px;left:300px;z-index:10;padding:3px;border-top-right-radius:3px;border-bottom-right-radius:3px;cursor:pointer;font-weight:bold;transition:left .5s;font-size:1.2em;border:1px solid;border-left:0;}#source-sidebar{position:fixed;top:0;bottom:0;left:0;width:300px;z-index:1;overflow:auto;transition:left .5s;border-right:1px solid;}#source-sidebar>.title{font-size:1.5em;text-align:center;border-bottom:1px solid;margin-bottom:6px;}.theme-picker{position:absolute;left:211px;top:19px;}.theme-picker button{outline:none;}#settings-menu,#help-button{position:absolute;top:10px;}#settings-menu{right:0;outline:none;}#theme-picker,#settings-menu,#help-button,#copy-path{padding:4px;width:27px;height:29px;border:1px solid;border-radius:3px;cursor:pointer;}#help-button{right:30px;font-family:"Fira Sans",Arial,sans-serif;text-align:center;font-size:17px;padding-top:2px;}#copy-path{background:initial;margin-left:10px;padding:0;padding-left:2px;border:0;}#theme-choices{display:none;position:absolute;left:0;top:28px;border:1px solid;border-radius:3px;z-index:1;cursor:pointer;}#theme-choices>button{border:none;width:100%;padding:4px 8px;text-align:center;background:rgba(0,0,0,0);}#theme-choices>button:not(:first-child){border-top:1px solid;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px;border-radius:3px;box-shadow:inset 0 -1px 0;cursor:default;}.hidden-by-impl-hider,.hidden-by-usual-hider{display:none !important;}#implementations-list>h3>span.in-band{width:100%;}.table-display{width:100%;border:0;border-collapse:collapse;border-spacing:0;font-size:16px;}.table-display tr td:first-child{padding-right:0;}.table-display tr td:last-child{float:right;}.table-display .out-of-band{position:relative;font-size:19px;display:block;}#implementors-list>.impl-items .table-display .out-of-band{font-size:17px;}.table-display td:hover .anchor{display:block;top:2px;left:-5px;}#main>ul{padding-left:10px;}#main>ul>li{list-style:none;}.non-exhaustive{margin-bottom:1em;}div.children{padding-left:27px;display:none;}div.name{cursor:pointer;position:relative;margin-left:16px;}div.files>a{display:block;padding:0 3px;}div.files>a:hover,div.name:hover{background-color:#a14b4b;}div.name.expand+.children{display:block;}div.name::before{content:"\25B6";padding-left:4px;font-size:0.7em;position:absolute;left:-16px;top:4px;}div.name.expand::before{transform:rotate(90deg);left:-15px;top:2px;}details.rustdoc-toggle>summary.hideme{cursor:pointer;}details.rustdoc-toggle>summary,details.undocumented>summary{list-style:none;}details.rustdoc-toggle>summary::-webkit-details-marker,details.rustdoc-toggle>summary::marker,details.undocumented>summary::-webkit-details-marker,details.undocumented>summary::marker{display:none;}details.rustdoc-toggle>summary.hideme>span{margin-left:9px;}details.rustdoc-toggle>summary::before{content:"[+]";font-weight:300;font-size:0.8em;letter-spacing:1px;cursor:pointer;}details.rustdoc-toggle.top-doc>summary,details.rustdoc-toggle.top-doc>summary::before,details.rustdoc-toggle.non-exhaustive>summary,details.rustdoc-toggle.non-exhaustive>summary::before{font-family:'Fira Sans';font-size:16px;}details.non-exhaustive{margin-bottom:8px;}details.rustdoc-toggle>summary.hideme::before{position:relative;}details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-23px;top:3px;}.impl-items>details.rustdoc-toggle>summary:not(.hideme)::before,.undocumented>details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-2px;}details.rustdoc-toggle[open] >summary.hideme{position:absolute;}details.rustdoc-toggle,details.undocumented{position:relative;}details.rustdoc-toggle[open] >summary.hideme>span{display:none;}details.rustdoc-toggle[open] >summary::before{content:"[−]";display:inline;}details.undocumented>summary::before{content:"[+] Show hidden undocumented items";cursor:pointer;font-size:16px;font-weight:300;}details.undocumented[open] >summary::before{content:"[−] Hide undocumented items";}@media (min-width:701px){.docblock>.information:first-child>.tooltip{margin-top:16px;}}@media (max-width:700px){body{padding-top:0px;}.rustdoc>.sidebar{height:45px;min-height:40px;margin:0;margin-left:-15px;padding:0 15px;position:static;z-index:11;}.sidebar>.location{float:right;margin:0px;margin-top:2px;padding:3px 10px 1px 10px;min-height:39px;background:inherit;text-align:left;font-size:24px;}.sidebar .location:empty{padding:0;}.sidebar .logo-container{width:35px;height:35px;margin-top:5px;margin-bottom:5px;float:left;margin-left:50px;}.sidebar .logo-container>img{max-width:35px;max-height:35px;}.sidebar-menu{position:fixed;z-index:10;font-size:2rem;cursor:pointer;width:45px;left:0;text-align:center;display:block;border-bottom:1px solid;border-right:1px solid;height:45px;}.rustdoc.source>.sidebar>.sidebar-menu{display:none;}.sidebar-elems{position:fixed;z-index:1;top:45px;bottom:0;width:246px;left:-246px;overflow-y:auto;border-right:1px solid;}.sidebar>.block.version{border-bottom:none;margin-top:12px;margin-bottom:0;}nav.sub{width:calc(100% - 32px);float:right;}.content{margin-left:0px;}#main,#search{margin-top:45px;padding:0;}#search{margin-left:0;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant,.impl-items>.associatedtype{display:flex;}.anchor{display:none !important;}.theme-picker{left:10px;top:54px;z-index:1;}.notable-traits{position:absolute;left:-22px;top:24px;}#titles>button>div.count{float:left;width:100%;}#titles{height:50px;}.sidebar.mobile{position:fixed;width:100%;margin-left:0;background-color:rgba(0,0,0,0);height:100%;}.sidebar.mobile>div.version{overflow:hidden;max-height:33px;}.sidebar{width:calc(100% + 30px);}.show-it{left:0;}.show-it>.block.items{margin:8px 0;}.show-it>.block.items>ul{margin:0;}.show-it>.block.items>ul>li{text-align:center;margin:2px 0;}.show-it>.block.items>ul>li>a{font-size:21px;}#sidebar-filler{position:fixed;left:45px;width:calc(100% - 45px);top:0;height:45px;z-index:-1;border-bottom:1px solid;}#main>details.rustdoc-toggle>summary::before,#main>div>details.rustdoc-toggle>summary::before{left:-11px;}#all-types{margin:10px;}#sidebar-toggle{top:100px;width:30px;font-size:1.5rem;text-align:center;padding:0;}#source-sidebar{z-index:11;}#main>.line-numbers{margin-top:0;}.notable-traits .notable-traits-tooltiptext{left:0;top:100%;}#help-button{display:none;}.search-container>div{width:calc(100% - 32px);}.search-results>a{border-bottom:1px solid #aaa9;padding:5px 0px;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:100%;}.search-results div.desc,.search-results .result-description{padding-left:2em;}}@media print{nav.sub,.content .out-of-band{display:none;}}@media (max-width:464px){#titles,#titles>button{height:73px;}#main,#search{margin-top:100px;}#main>table:not(.table-display) td{word-break:break-word;width:50%;}.search-container>div{display:block;width:calc(100% - 37px);}#crate-search{width:100%;border-radius:4px;border:0;}#crate-search+.search-input{width:calc(100% + 71px);margin-left:-36px;}#theme-picker,#settings-menu{padding:5px;width:31px;height:31px;}#theme-picker{margin-top:-2px;}#settings-menu{top:7px;}.docblock{margin-left:12px;}} \ No newline at end of file + @font-face {font-family:'Fira Sans';font-style:normal;font-weight:400;src:local('Fira Sans'),url("FiraSans-Regular.woff2") format("woff2"),url("FiraSans-Regular.woff") format('woff');font-display:swap;}@font-face {font-family:'Fira Sans';font-style:normal;font-weight:500;src:local('Fira Sans Medium'),url("FiraSans-Medium.woff2") format("woff2"),url("FiraSans-Medium.woff") format('woff');font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:400;src:local('Source Serif 4'),url("SourceSerif4-Regular.ttf.woff2") format("woff2"),url("SourceSerif4-Regular.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:italic;font-weight:400;src:local('Source Serif 4 Italic'),url("SourceSerif4-It.ttf.woff2") format("woff2"),url("SourceSerif4-It.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Source Serif 4';font-style:normal;font-weight:700;src:local('Source Serif 4 Bold'),url("SourceSerif4-Bold.ttf.woff2") format("woff2"),url("SourceSerif4-Bold.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:400;src:url("SourceCodePro-Regular.ttf.woff2") format("woff2"),url("SourceCodePro-Regular.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:italic;font-weight:400;src:url("SourceCodePro-It.ttf.woff2") format("woff2"),url("SourceCodePro-It.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Source Code Pro';font-style:normal;font-weight:600;src:url("SourceCodePro-Semibold.ttf.woff2") format("woff2"),url("SourceCodePro-Semibold.ttf.woff") format("woff");font-display:swap;}@font-face {font-family:'Noto Sans KR';src:url("noto-sans-kr-v13-korean-regular.woff") format("woff");font-display:swap;unicode-range:U+A960-A97F,U+AC00-D7AF,U+D7B0-D7FF;}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;}html{content:"";}@media (prefers-color-scheme:light){html{content:"light";}}@media (prefers-color-scheme:dark){html{content:"dark";}}body{font:16px/1.4 "Source Serif 4","Noto Sans KR",serif;margin:0;position:relative;padding:10px 15px 20px 15px;-webkit-font-feature-settings:"kern","liga";-moz-font-feature-settings:"kern","liga";font-feature-settings:"kern","liga";}h1{font-size:1.5em;}h2{font-size:1.4em;}h3{font-size:1.3em;}h1,h2,h3,h4{font-weight:500;margin:20px 0 15px 0;padding-bottom:6px;}h1.fqn{display:flex;border-bottom:1px dashed;margin-top:0;padding-left:1px;}h1.fqn>.in-band>a:hover{text-decoration:underline;}h2,h3,h4{border-bottom:1px solid;}h3.code-header,h4.code-header{font-size:1em;font-weight:600;border:none;padding:0;margin:0;}.impl,.impl-items .method,.methods .method,.impl-items .type,.methods .type,.impl-items .associatedconstant,.methods .associatedconstant,.impl-items .associatedtype,.methods .associatedtype{flex-basis:100%;font-weight:600;margin-top:16px;margin-bottom:10px;position:relative;}.impl,.method.trait-impl,.type.trait-impl,.associatedconstant.trait-impl,.associatedtype.trait-impl{padding-left:15px;}div.impl-items>div{padding-left:0;}h1,h2,h3,h4,.sidebar,a.source,.search-input,.search-results .result-name,.content table td:first-child>a,.item-left>a,div.item-list .out-of-band,span.since,#source-sidebar,#sidebar-toggle,details.rustdoc-toggle>summary::before,details.undocumented>summary::before,div.impl-items>div:not(.docblock):not(.item-info),.content ul.crate a.crate,a.srclink,#main>ul.docblock>li>a{font-family:"Fira Sans",Arial,sans-serif;}.content ul.crate a.crate{font-size:16px/1.6;}ol,ul{padding-left:25px;}ul ul,ol ul,ul ol,ol ol{margin-bottom:.6em;}p{margin:0 0 .6em 0;}summary{outline:none;}td,th{padding:0;}table{border-collapse:collapse;}button,input,optgroup,select,textarea{color:inherit;font:inherit;margin:0;}details:not(.rustdoc-toggle) summary{margin-bottom:.6em;}code,pre,a.test-arrow,.code-header{font-family:"Source Code Pro",monospace;}.docblock code,.docblock-short code{border-radius:3px;padding:0 0.1em;}.docblock pre code,.docblock-short pre code{padding:0;padding-right:1ex;}pre{padding:14px;}.type-decl pre{overflow-x:auto;}.source .content pre{padding:20px;}img{max-width:100%;}li{position:relative;}.source .content{margin-top:50px;max-width:none;overflow:visible;margin-left:0px;}nav.sub{font-size:16px;text-transform:uppercase;}.sidebar{width:200px;position:fixed;left:0;top:0;bottom:0;overflow:auto;}*{scrollbar-width:initial;}.sidebar{scrollbar-width:thin;}::-webkit-scrollbar{width:12px;}.sidebar::-webkit-scrollbar{width:8px;}::-webkit-scrollbar-track{-webkit-box-shadow:inset 0;}.sidebar .block>ul>li{margin-right:-10px;}.content,nav{max-width:960px;}.hidden{display:none !important;}.logo-container{height:100px;width:100px;position:relative;margin:20px auto;display:block;margin-top:10px;}.logo-container>img{max-width:100px;max-height:100px;height:100%;position:absolute;left:50%;top:50%;transform:translate(-50%,-50%);display:block;}.sidebar .location{border:1px solid;font-size:17px;margin:30px 10px 20px 10px;text-align:center;word-wrap:break-word;font-weight:inherit;padding:0;}.sidebar .version{font-size:15px;text-align:center;border-bottom:1px solid;overflow-wrap:break-word;word-wrap:break-word;word-break:break-word;}.location:empty{border:none;}.location a:first-of-type{font-weight:500;}.location a:hover{text-decoration:underline;}.block{padding:0;margin-bottom:14px;}.block h2,.block h3{text-align:center;}.block ul,.block li{margin:0 10px;padding:0;list-style:none;}.block a{display:block;text-overflow:ellipsis;overflow:hidden;line-height:15px;padding:7px 5px;font-size:14px;font-weight:300;transition:border 500ms ease-out;}.sidebar-title{border-top:1px solid;border-bottom:1px solid;text-align:center;font-size:17px;margin-bottom:5px;font-weight:inherit;padding:0;}.sidebar-links{margin-bottom:15px;}.sidebar-links>a{padding-left:10px;width:100%;}.sidebar-menu{display:none;}.content{padding:15px 0;}.source .content pre.rust{white-space:pre;overflow:auto;padding-left:0;}.rustdoc .example-wrap{display:inline-flex;margin-bottom:10px;}.example-wrap{position:relative;width:100%;}.example-wrap>pre.line-number{overflow:initial;border:1px solid;padding:13px 8px;text-align:right;border-top-left-radius:5px;border-bottom-left-radius:5px;}.rustdoc:not(.source) .example-wrap>pre:not(.line-number){width:100%;overflow-x:auto;}.rustdoc .example-wrap>pre{margin:0;}#search{margin-left:230px;position:relative;}#results>table{width:100%;table-layout:fixed;}.content>.example-wrap pre.line-numbers{position:relative;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;}.line-numbers span{cursor:pointer;}.docblock-short{overflow-wrap:anywhere;}.docblock-short p{display:inline;}.docblock-short p{overflow:hidden;text-overflow:ellipsis;margin:0;}.docblock>:not(pre)>code,.docblock-short>:not(pre)>code{white-space:pre-wrap;}.docblock h1,.docblock h2,.docblock h3,.docblock h4,.docblock h5{border-bottom:1px solid;}.top-doc .docblock h1{font-size:1.3em;}.top-doc .docblock h2{font-size:1.15em;}.top-doc .docblock h3,.top-doc .docblock h4,.top-doc .docblock h5{font-size:1em;}.docblock h1{font-size:1em;}.docblock h2{font-size:0.95em;}.docblock h3,.docblock h4,.docblock h5{font-size:0.9em;}.docblock{margin-left:24px;position:relative;}.content .out-of-band{flex-grow:0;text-align:right;font-size:23px;margin:0px;padding:0 0 0 12px;font-weight:normal;}.method>.code-header,.trait-impl>.code-header,.invisible>.code-header{max-width:calc(100% - 41px);display:block;}.invisible{width:100%;display:inline-block;}.content .in-band{flex-grow:1;margin:0px;padding:0px;}.in-band>code,.in-band>.code-header{display:inline-block;}#main{position:relative;}#main>.since{top:inherit;font-family:"Fira Sans",Arial,sans-serif;}.content table:not(.table-display){border-spacing:0 5px;}.content td{vertical-align:top;}.content td:first-child{padding-right:20px;}.content td p:first-child{margin-top:0;}.content td h1,.content td h2{margin-left:0;font-size:1.1em;}.content tr:first-child td{border-top:0;}.docblock table{margin:.5em 0;width:calc(100% - 2px);overflow-x:auto;display:block;}.docblock table td{padding:.5em;border:1px dashed;}.docblock table th{padding:.5em;text-align:left;border:1px solid;}.fields+table{margin-bottom:1em;}.content .item-list{list-style-type:none;padding:0;}.content .multi-column{-moz-column-count:5;-moz-column-gap:2.5em;-webkit-column-count:5;-webkit-column-gap:2.5em;column-count:5;column-gap:2.5em;}.content .multi-column li{width:100%;display:inline-block;}.content>.methods>.method{font-size:1em;position:relative;}.content .method .where,.content .fn .where,.content .where.fmt-newline{display:block;font-size:0.8em;}.content .methods>div:not(.notable-traits):not(.method){margin-left:40px;margin-bottom:15px;}.content .docblock>.impl-items{margin-left:20px;margin-top:-34px;}.content .docblock>.impl-items .table-display{margin:0;}.content .docblock>.impl-items table td{padding:0;}.content .docblock>.impl-items .table-display,.impl-items table td{border:none;}.content .item-info code{font-size:90%;}.content .item-info{position:relative;margin-left:33px;}.sub-variant>div>.item-info{margin-top:initial;}.content .item-info::before{content:'⬑';font-size:25px;position:absolute;top:-6px;left:-19px;}.content .impl-items .method,.content .impl-items>.type,.impl-items>.associatedconstant,.impl-items>.associatedtype,.content .impl-items details>summary>.type,.impl-items details>summary>.associatedconstant,.impl-items details>summary>.associatedtype{margin-left:20px;}.content .impl-items .docblock,.content .impl-items .item-info{margin-bottom:.6em;}.content .impl-items>.item-info{margin-left:40px;}.methods>.item-info,.content .impl-items>.item-info{margin-top:-8px;}.impl-items{flex-basis:100%;}#main>.item-info{margin-top:0;}nav:not(.sidebar){border-bottom:1px solid;padding-bottom:10px;margin-bottom:10px;}nav.main{padding:20px 0;text-align:center;}nav.main .current{border-top:1px solid;border-bottom:1px solid;}nav.main .separator{border:1px solid;display:inline-block;height:23px;margin:0 20px;}nav.sum{text-align:right;}nav.sub form{display:inline;}nav.sub,.content{margin-left:230px;}a{text-decoration:none;background:transparent;}.small-section-header{display:flex;justify-content:space-between;position:relative;}.small-section-header:hover>.anchor{display:initial;}.in-band:hover>.anchor,.impl:hover>.anchor,.method.trait-impl:hover>.anchor,.type.trait-impl:hover>.anchor,.associatedconstant.trait-impl:hover>.anchor,.associatedtype.trait-impl:hover>.anchor{display:inline-block;position:absolute;}.anchor{display:none;position:absolute;left:-7px;}.anchor.field{left:-5px;}.small-section-header>.anchor{left:-28px;padding-right:10px;}.anchor:before{content:'\2002\00a7\2002';}.docblock a:not(.srclink):not(.test-arrow):hover,.docblock-short a:not(.srclink):not(.test-arrow):hover,.item-info a{text-decoration:underline;}.invisible>.srclink,.method>.code-header+.srclink{position:absolute;top:0;right:0;font-size:17px;font-weight:normal;}.block a.current.crate{font-weight:500;}.item-table{display:grid;column-gap:1.2rem;row-gap:0.0rem;grid-template-columns:auto 1fr;justify-items:start;}.item-left,.item-right{display:block;}.item-left{grid-column:1;}.item-right{grid-column:2;}.search-container{position:relative;}.search-container>div{display:inline-flex;width:calc(100% - 63px);}#crate-search{min-width:115px;margin-top:5px;padding:6px;padding-right:19px;flex:none;border:0;border-right:0;border-radius:4px 0 0 4px;outline:none;cursor:pointer;border-right:1px solid;-moz-appearance:none;-webkit-appearance:none;text-indent:0.01px;text-overflow:"";background-repeat:no-repeat;background-color:transparent;background-size:20px;background-position:calc(100% - 1px) 56%;}.search-container>.top-button{position:absolute;right:0;top:10px;}.search-input{-moz-box-sizing:border-box !important;box-sizing:border-box !important;outline:none;border:none;border-radius:1px;margin-top:5px;padding:10px 16px;font-size:17px;transition:border-color 300ms ease;transition:border-radius 300ms ease-in-out;transition:box-shadow 300ms ease-in-out;width:100%;}#crate-search+.search-input{border-radius:0 1px 1px 0;width:calc(100% - 32px);}.search-input:focus{border-radius:2px;border:0;outline:0;}.search-results{display:none;padding-bottom:2em;}.search-results.active{display:block;clear:both;}.search-results .desc>span{white-space:nowrap;text-overflow:ellipsis;overflow:hidden;display:block;}.search-results>a{display:block;width:100%;margin-left:2px;margin-right:2px;border-bottom:1px solid #aaa3;}.search-results>a>div{display:flex;flex-flow:row wrap;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:50%;}.search-results .result-name{padding-right:1em;}.search-results .result-name>span{display:inline-block;margin:0;font-weight:normal;}body.blur>:not(#help){filter:blur(8px);-webkit-filter:blur(8px);opacity:.7;}#help{width:100%;height:100vh;position:fixed;top:0;left:0;display:flex;justify-content:center;align-items:center;}#help>div{flex:0 0 auto;box-shadow:0 0 6px rgba(0,0,0,.2);width:550px;height:auto;border:1px solid;}#help dt{float:left;clear:left;display:block;margin-right:0.5rem;}#help>div>span{text-align:center;display:block;margin:10px 0;font-size:18px;border-bottom:1px solid #ccc;padding-bottom:4px;margin-bottom:6px;}#help dd{margin:5px 35px;}#help .infos{padding-left:0;}#help h1,#help h2{margin-top:0;}#help>div div{width:50%;float:left;padding:0 20px 20px 17px;;}.item-info .stab{display:table;}.stab{border-width:1px;border-style:solid;padding:3px;margin-bottom:5px;font-size:90%;font-weight:normal;}.stab p{display:inline;}.stab .emoji{font-size:1.5em;}.emoji{text-shadow:1px 0 0 black,-1px 0 0 black,0 1px 0 black,0 -1px 0 black;}.module-item .stab,.import-item .stab{border-radius:3px;display:inline-block;font-size:80%;line-height:1.2;margin-bottom:0;margin-left:.3em;padding:2px;vertical-align:text-bottom;}.module-item.unstable,.import-item.unstable{opacity:0.65;}.since{font-weight:normal;font-size:initial;}.impl-items .since,.impl .since,.methods .since{padding-left:12px;padding-right:2px;position:initial;}.impl-items .srclink,.impl .srclink,.methods .srclink{font-size:17px;font-weight:normal;}.rightside{float:right;}.has-srclink{font-size:16px;margin-bottom:12px;justify-content:space-between;}.variants_table{width:100%;}.variants_table tbody tr td:first-child{width:1%;}td.summary-column{width:100%;}.summary{padding-right:0px;}pre.rust .question-mark{font-weight:bold;}a.test-arrow{display:inline-block;position:absolute;padding:5px 10px 5px 10px;border-radius:5px;font-size:130%;top:5px;right:5px;z-index:1;}a.test-arrow:hover{text-decoration:none;}.section-header:hover a:before{position:absolute;left:-25px;padding-right:10px;content:'\2002\00a7\2002';}.section-header:hover a{text-decoration:none;}.section-header a{color:inherit;}.code-attribute{font-weight:300;}.since+.srclink{padding-left:10px;}.item-spacer{width:100%;height:12px;}.out-of-band>span.since{position:initial;font-size:20px;margin-right:5px;}.sub-variant,.sub-variant>h3{margin-top:0px !important;padding-top:1px;}#main .sub-variant>h3{font-size:15px;margin-left:25px;margin-bottom:5px;}.sub-variant>div{margin-left:20px;margin-bottom:10px;}.sub-variant>div>span{display:block;position:relative;}.toggle-label{display:inline-block;margin-left:4px;margin-top:3px;}.docblock>.section-header:first-child{margin-left:15px;margin-top:0;}.docblock>.section-header:first-child:hover>a:before{left:-10px;}:target>code,:target>.code-header{opacity:1;}:target{padding-right:3px;}.information{position:absolute;left:-25px;margin-top:7px;z-index:1;}.tooltip{position:relative;display:inline-block;cursor:pointer;}.tooltip::after{display:none;text-align:center;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;font-size:16px;}.tooltip.ignore::after{content:"This example is not tested";}.tooltip.compile_fail::after{content:"This example deliberately fails to compile";}.tooltip.should_panic::after{content:"This example panics";}.tooltip.edition::after{content:"This code runs with edition " attr(data-edition);}.tooltip::before{content:" ";position:absolute;top:50%;left:16px;margin-top:-5px;border-width:5px;border-style:solid;display:none;}.tooltip:hover::before,.tooltip:hover::after{display:inline;}.tooltip.compile_fail,.tooltip.should_panic,.tooltip.ignore{font-weight:bold;font-size:20px;}.notable-traits-tooltip{display:inline-block;cursor:pointer;}.notable-traits:hover .notable-traits-tooltiptext,.notable-traits .notable-traits-tooltiptext.force-tooltip{display:inline-block;}.notable-traits .notable-traits-tooltiptext{display:none;padding:5px 3px 3px 3px;border-radius:6px;margin-left:5px;z-index:10;font-size:16px;cursor:default;position:absolute;border:1px solid;}.notable-traits-tooltip::after{content:"\00a0\00a0\00a0";}.notable-traits .notable,.notable-traits .docblock{margin:0;}.notable-traits .notable{margin:0;margin-bottom:13px;font-size:19px;font-weight:600;}.notable-traits .docblock code.content{margin:0;padding:0;font-size:20px;}pre.rust.rust-example-rendered{position:relative;}pre.rust{tab-size:4;-moz-tab-size:4;}.search-failed{text-align:center;margin-top:20px;display:none;}.search-failed.active{display:block;}.search-failed>ul{text-align:left;max-width:570px;margin-left:auto;margin-right:auto;}#titles{height:35px;}#titles>button{float:left;width:33.3%;text-align:center;font-size:18px;cursor:pointer;border:0;border-top:2px solid;}#titles>button:not(:last-child){margin-right:1px;width:calc(33.3% - 1px);}#titles>button>div.count{display:inline-block;font-size:16px;}.notable-traits{cursor:pointer;z-index:2;margin-left:5px;}#all-types{text-align:center;border:1px solid;margin:0 10px;margin-bottom:10px;display:block;border-radius:7px;}#all-types>p{margin:5px 0;}#sidebar-toggle{position:fixed;top:30px;left:300px;z-index:10;padding:3px;border-top-right-radius:3px;border-bottom-right-radius:3px;cursor:pointer;font-weight:bold;transition:left .5s;font-size:1.2em;border:1px solid;border-left:0;}#source-sidebar{position:fixed;top:0;bottom:0;left:0;width:300px;z-index:1;overflow:auto;transition:left .5s;border-right:1px solid;}#source-sidebar>.title{font-size:1.5em;text-align:center;border-bottom:1px solid;margin-bottom:6px;}.theme-picker{position:absolute;left:211px;top:19px;}.theme-picker button{outline:none;}#settings-menu,#help-button{position:absolute;top:10px;}#settings-menu{right:0;outline:none;}#theme-picker,#settings-menu,#help-button,#copy-path{padding:4px;width:27px;height:29px;border:1px solid;border-radius:3px;cursor:pointer;}#help-button{right:30px;font-family:"Fira Sans",Arial,sans-serif;text-align:center;font-size:17px;padding-top:2px;}#copy-path{background:initial;margin-left:10px;padding:0;padding-left:2px;border:0;}#theme-choices{display:none;position:absolute;left:0;top:28px;border:1px solid;border-radius:3px;z-index:1;cursor:pointer;}#theme-choices>button{border:none;width:100%;padding:4px 8px;text-align:center;background:rgba(0,0,0,0);}#theme-choices>button:not(:first-child){border-top:1px solid;}kbd{display:inline-block;padding:3px 5px;font:15px monospace;line-height:10px;vertical-align:middle;border:solid 1px;border-radius:3px;box-shadow:inset 0 -1px 0;cursor:default;}.hidden-by-impl-hider,.hidden-by-usual-hider{display:none !important;}#implementations-list>h3>span.in-band{width:100%;}.table-display{width:100%;border:0;border-collapse:collapse;border-spacing:0;font-size:16px;}.table-display tr td:first-child{padding-right:0;}.table-display tr td:last-child{float:right;}.table-display .out-of-band{position:relative;font-size:19px;display:block;}#implementors-list>.impl-items .table-display .out-of-band{font-size:17px;}.table-display td:hover .anchor{display:block;top:2px;left:-5px;}#main>ul{padding-left:10px;}#main>ul>li{list-style:none;}.non-exhaustive{margin-bottom:1em;}div.children{padding-left:27px;display:none;}div.name{cursor:pointer;position:relative;margin-left:16px;}div.files>a{display:block;padding:0 3px;}div.files>a:hover,div.name:hover{background-color:#a14b4b;}div.name.expand+.children{display:block;}div.name::before{content:"\25B6";padding-left:4px;font-size:0.7em;position:absolute;left:-16px;top:4px;}div.name.expand::before{transform:rotate(90deg);left:-15px;top:2px;}details.rustdoc-toggle>summary.hideme{cursor:pointer;}details.rustdoc-toggle>summary,details.undocumented>summary{list-style:none;}details.rustdoc-toggle>summary::-webkit-details-marker,details.rustdoc-toggle>summary::marker,details.undocumented>summary::-webkit-details-marker,details.undocumented>summary::marker{display:none;}details.rustdoc-toggle>summary.hideme>span{margin-left:9px;}details.rustdoc-toggle>summary::before{content:"[+]";font-weight:300;font-size:0.8em;letter-spacing:1px;cursor:pointer;}details.rustdoc-toggle.top-doc>summary,details.rustdoc-toggle.top-doc>summary::before,details.rustdoc-toggle.non-exhaustive>summary,details.rustdoc-toggle.non-exhaustive>summary::before{font-family:'Fira Sans';font-size:16px;}details.non-exhaustive{margin-bottom:8px;}details.rustdoc-toggle>summary.hideme::before{position:relative;}details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-23px;top:3px;}.impl-items>details.rustdoc-toggle>summary:not(.hideme)::before,.undocumented>details.rustdoc-toggle>summary:not(.hideme)::before{position:absolute;left:-2px;}details.rustdoc-toggle[open] >summary.hideme{position:absolute;}details.rustdoc-toggle,details.undocumented{position:relative;}details.rustdoc-toggle[open] >summary.hideme>span{display:none;}details.rustdoc-toggle[open] >summary::before{content:"[−]";display:inline;}details.undocumented>summary::before{content:"[+] Show hidden undocumented items";cursor:pointer;font-size:16px;font-weight:300;}details.undocumented[open] >summary::before{content:"[−] Hide undocumented items";}@media (min-width:701px){.docblock>.information:first-child>.tooltip{margin-top:16px;}}@media (max-width:700px){body{padding-top:0px;}.rustdoc>.sidebar{height:45px;min-height:40px;margin:0;margin-left:-15px;padding:0 15px;position:static;z-index:11;}.sidebar>.location{float:right;margin:0px;margin-top:2px;padding:3px 10px 1px 10px;min-height:39px;background:inherit;text-align:left;font-size:24px;}.sidebar .location:empty{padding:0;}.sidebar .logo-container{width:35px;height:35px;margin-top:5px;margin-bottom:5px;float:left;margin-left:50px;}.sidebar .logo-container>img{max-width:35px;max-height:35px;}.sidebar-menu{position:fixed;z-index:10;font-size:2rem;cursor:pointer;width:45px;left:0;text-align:center;display:block;border-bottom:1px solid;border-right:1px solid;height:45px;}.rustdoc.source>.sidebar>.sidebar-menu{display:none;}.sidebar-elems{position:fixed;z-index:1;top:45px;bottom:0;width:246px;left:-246px;overflow-y:auto;border-right:1px solid;}.sidebar>.block.version{overflow:hidden;border-bottom:none;margin-bottom:0;height:100%;padding-left:12px;}.sidebar>.block.version>div.narrow-helper{float:left;width:1px;height:100%;}.sidebar>.block.version>p{margin:0;min-width:55px;display:flex;align-items:center;height:100%;}nav.sub{width:calc(100% - 32px);float:right;}.content{margin-left:0px;}#main,#search{margin-top:45px;padding:0;}#search{margin-left:0;}.anchor{display:none !important;}.theme-picker{left:10px;top:54px;z-index:1;}.notable-traits{position:absolute;left:-22px;top:24px;}#titles>button>div.count{float:left;width:100%;}#titles{height:50px;}.sidebar.mobile{position:fixed;width:100%;margin-left:0;background-color:rgba(0,0,0,0);height:100%;}.sidebar.mobile>div.version{overflow:hidden;max-height:33px;}.sidebar{width:calc(100% + 30px);}.show-it,.sidebar-elems:focus-within{z-index:2;left:0;}.show-it>.block.items{margin:8px 0;}.show-it>.block.items>ul{margin:0;}.show-it>.block.items>ul>li{text-align:center;margin:2px 0;}.show-it>.block.items>ul>li>a{font-size:21px;}#sidebar-filler{position:fixed;left:45px;width:calc(100% - 45px);top:0;height:45px;z-index:-1;border-bottom:1px solid;}#main>details.rustdoc-toggle>summary::before,#main>div>details.rustdoc-toggle>summary::before{left:-11px;}#all-types{margin:10px;}#sidebar-toggle{top:100px;width:30px;font-size:1.5rem;text-align:center;padding:0;}#source-sidebar{z-index:11;}#main>.line-numbers{margin-top:0;}.notable-traits .notable-traits-tooltiptext{left:0;top:100%;}#help-button{display:none;}.item-table{display:flex;flex-flow:column wrap;}.item-left,.item-right{width:100%;}.search-container>div{width:calc(100% - 32px);}.search-results>a{border-bottom:1px solid #aaa9;padding:5px 0px;}.search-results .result-name,.search-results div.desc,.search-results .result-description{width:100%;}.search-results div.desc,.search-results .result-description,.item-right{padding-left:2em;}}@media print{nav.sub,.content .out-of-band{display:none;}}@media (max-width:464px){#titles,#titles>button{height:73px;}#main,#search{margin-top:100px;}#main>table:not(.table-display) td{word-break:break-word;width:50%;}.search-container>div{display:block;width:calc(100% - 37px);}#crate-search{width:100%;border-radius:4px;border:0;}#crate-search+.search-input{width:calc(100% + 71px);margin-left:-36px;}#theme-picker,#settings-menu{padding:5px;width:31px;height:31px;}#theme-picker{margin-top:-2px;}#settings-menu{top:7px;}.docblock{margin-left:12px;}} \ No newline at end of file diff --git a/search-index.js b/search-index.js index 8c6ad22f..067f830d 100644 --- a/search-index.js +++ b/search-index.js @@ -1,6 +1,6 @@ var searchIndex = JSON.parse('{\ -"mcaptcha":{"doc":"","t":[6,3,17,17,3,3,3,17,3,3,3,3,17,3,3,3,3,3,3,3,17,17,17,17,17,3,3,3,3,17,3,3,17,17,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,0,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,0,12,0,12,12,14,0,11,11,11,11,11,11,11,11,0,0,0,11,11,11,11,11,11,11,11,5,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,5,0,0,12,12,0,12,0,12,12,0,0,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,0,0,0,0,0,0,0,0,5,3,3,11,11,11,11,11,11,11,11,0,11,11,0,12,11,11,11,11,11,11,0,0,0,11,11,5,11,11,11,11,11,11,11,11,0,12,11,11,11,11,3,11,11,11,0,5,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,12,3,11,11,11,11,11,11,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,12,12,12,11,11,5,11,11,11,11,11,11,11,11,11,11,5,3,11,11,11,3,11,11,12,12,11,12,11,11,11,11,11,12,12,12,12,12,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,12,11,5,11,11,11,11,11,11,11,11,11,11,3,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,11,5,3,11,11,11,11,11,11,11,11,11,11,12,3,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,3,3,11,11,11,0,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,12,12,11,12,11,11,11,11,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,12,11,11,11,11,11,11,11,11,11,12,5,12,12,12,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,0,0,5,0,5,3,3,3,3,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,12,12,12,12,12,12,11,11,11,0,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,5,11,11,11,11,11,11,11,3,11,11,12,11,11,11,12,11,11,11,12,11,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,3,11,11,11,11,11,12,11,11,0,11,11,11,5,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,3,11,11,11,12,11,11,11,11,11,12,11,3,3,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,12,12,12,11,11,11,11,11,11,11,11,11,3,5,11,11,11,11,11,11,11,12,12,12,12,11,11,11,0,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,11,11,11,3,12,11,11,11,12,11,11,11,11,11,12,11,3,3,4,3,3,4,13,13,13,13,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,3,11,11,11,11,11,11,11,11,11,11,12,12,11,11,0,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,3,11,11,12,11,12,11,11,11,11,11,11,0,0,0,0,5,3,3,11,11,11,11,11,11,11,12,11,11,12,11,11,12,11,11,11,11,11,11,11,11,3,3,11,11,11,11,11,11,11,11,11,11,11,3,12,12,12,12,11,11,11,12,12,12,12,12,12,11,0,11,11,11,11,11,11,11,11,11,11,11,11,11,5,3,3,11,11,11,11,11,11,11,11,11,11,11,12,12,12,11,11,11,3,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,12,11,12,11,11,11,11,11,0,0,5,0,0,3,11,11,11,11,11,11,11,11,11,11,3,5,11,11,12,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,12,11,11,12,11,11,11,12,12,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,3,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,3,11,11,17,3,12,12,11,11,12,11,11,12,12,12,11,12,12,11,11,11,11,3,13,6,13,4,11,11,11,11,11,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,17,3,17,17,17,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,17,17,5,5,5,3,17,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,12,11,11,12,11,11,11,11,0,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,5,12,11,12,13,13,13,13,13,3,13,13,13,13,4,6,13,13,13,13,4,13,6,3,13,13,13,13,13,13,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,17,0,0,0,0,5,0,0,0,0,5,0,3,3,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,12,12,11,11,11,11,11,17,3,11,11,11,11,12,11,11,11,11,11,11,11,11,11,12,11,17,3,3,17,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,0,5,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,12,11,11,11,11,11,12,11,3,17,11,11,11,11,11,11,11,11,11,11,11,0,3,11,11,11,0,5,0,0,12,11,11,11,11,11,11,11,11,11,3,3,17,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,12,12,12,11,3,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,12,11,11,12,12,12,11,11,11,11,3,17,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,11,11,11,11,11,11,11,11,11,0,12,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,3,11,11,12,11,11,12,11,11,11,11,11,12,11,0,0,0,0,0,5,0,3,3,17,12,3,11,11,11,11,11,11,11,11,11,11,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,3,3,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,3,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,3,17,6,11,11,11,11,11,11,11,11,5,11,11,3,11,11,11,11,12,11,11,11,11,11,11,11,11,11,3,12,11,11,12,12,11,11,11,12,11,11,11,11,12,11,3,3,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,17,3,12,12,11,11,12,12,11,11,12,11,11,12,12,12,12,12,11,11,11,11,3,3,12,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,12,11,11,11,13,4,13,13,13,11,11,11,11,11,11,11,11,3,3,3,3,3,3,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,12,11,11,11,11,11,11,11,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,5,5,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,11,11,11,11,11,11,11,0,5,0,3,11,11,12,11,11,11,11,11,11,11,11,3,3,0,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,5,5,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,3,3,3,3,6,3,3,3,3,12,12,12,12,12,12,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,0,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,12,11,0,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,5,5,5,5,5,3,3,17,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,12,11],"n":["AppData","BAR_CHART","CACHE_AGE","COMPILED_DATE","CREDIT_CARD","CSS","CheckLogin","DOCS","DOCS_ICON","Data","FILES","GITHUB","GIT_COMMIT_HASH","HELP_CIRCLE","HOME","JS","KEY","MCAPTCHA_TRANS_ICON","MESSAGE","MOBILE_CSS","OPEN_API_DOC","PAGES","PKG_DESCRIPTION","PKG_HOMEPAGE","PKG_NAME","SETTINGS","SETTINGS_ICON","SOURCE_FILES_OF_INSTANCE","Settings","V1_API_ROUTES","VERIFICATIN_WIDGET_CSS","VERIFICATIN_WIDGET_JS","VERSION","WIDGET_ROUTES","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","allow_demo","allow_registration","api","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","captcha","commercial","creds","data","database","date","db","debug","define_resource","demo","deref","deref","deref","deref","deref","deref","deref","deref","docs","email","errors","from","from","from","from","from","from","from","from","get_identity_service","get_json_err","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","into","into","into","into","into","into","into","into","mailer","main","middleware","pages","pow","redis","routes","server","settings","smtp","source_code","static_assets","stats","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","widget","v1","account","auth","mcaptcha","meta","notifications","pow","routes","services","AccountCheckPayload","AccountCheckResp","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","delete","deserialize","deserialize","email","exists","fmt","fmt","from","from","into","into","password","routes","secret","serialize","serialize","services","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","username","val","vzip","vzip","borrow","borrow_mut","delete_account","from","into","register","runners","services","try_from","try_into","type_id","vzip","delete_user","Email","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","email","email_exists","fmt","from","from","from","into","into","into","register","register","serialize","services","set_email","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","ChangePasswordReqest","UpdatePassword","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","confirm_new_password","confirm_new_password","deserialize","fmt","from","from","from","from","into","into","into","new_password","new_password","password","register","serialize","services","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_password_runner","update_user_password","vzip","vzip","vzip","Account","borrow","borrow_mut","delete","email_exists","from","get_secret","into","new","try_from","try_into","type_id","update_email","update_password","update_secret","update_username","username_exists","vzip","Secret","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","from","get_secret","into","into","into","register","register","secret","serialize","services","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_user_secret","vzip","vzip","vzip","Username","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","from","into","into","into","register","register","runners","serialize","services","set_username","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","username","username_exists","vzip","vzip","vzip","username_exists","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","from","from","from","into","into","into","login","register","register","register","register","routes","runners","services","signout","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Auth","borrow","borrow_mut","from","into","login","logout","new","register","try_from","try_into","type_id","vzip","Login","Password","Register","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","confirm_password","deserialize","deserialize","deserialize","email","fmt","fmt","fmt","from","from","from","into","into","into","login","login_runner","password","password","password","register_runner","serialize","serialize","serialize","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","username","vzip","vzip","vzip","captcha","duration","get_random","levels","services","DeleteCaptcha","MCaptchaDetails","MCaptchaID","StatsPayload","add_mcaptcha_util","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","delete_mcaptcha","deserialize","deserialize","deserialize","deserialize","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get_stats","into","into","into","into","into","into","into","key","key","key","name","name","password","register","register","register","routes","serialize","serialize","serialize","serialize","services","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_token","update_token_helper","vzip","vzip","vzip","vzip","vzip","vzip","vzip","MCaptcha","borrow","borrow_mut","delete","from","into","new","stats","try_from","try_into","type_id","update_key","vzip","GetDuration","GetDurationResp","UpdateDuration","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deserialize","deserialize","deserialize","duration","duration","from","from","from","from","from","get_duration","into","into","into","into","into","key","register","register","routes","serialize","serialize","serialize","services","token","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","update_duration","vzip","vzip","vzip","vzip","vzip","Duration","borrow","borrow_mut","from","get","into","new","try_from","try_into","type_id","update","vzip","AddLevels","I32Levels","Levels","UpdateLevels","add_levels","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","description","description","deserialize","deserialize","deserialize","deserialize","difficulty_factor","duration","duration","fmt","fmt","from","from","from","from","from","from","from","get_levels","get_levels_util","into","into","into","into","into","into","into","key","levels","levels","levels","register","register","register","routes","serialize","serialize","serialize","serialize","services","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_levels","visitor_threshold","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Levels","add","borrow","borrow_mut","from","get","into","new","try_from","try_into","type_id","update","vzip","BuildDetails","BuildDetailsBuilder","BuildDetailsBuilderError","Health","HealthBuilder","HealthBuilderError","UninitializedField","UninitializedField","ValidationError","ValidationError","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","build_details","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","db","db","db","default","default","deserialize","deserialize","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","git_commit_hash","git_commit_hash","git_commit_hash","health","into","into","into","into","into","into","into","into","is_redis","redis","redis","redis","register","register","routes","serialize","serialize","services","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","version","version","version","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Meta","borrow","borrow_mut","build_details","from","health","into","new","try_from","try_into","type_id","vzip","add","get","mark_read","routes","services","AddNotification","add_notification","borrow","borrow","borrow_mut","borrow_mut","deserialize","from","from","heading","into","into","message","register","serialize","to","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Notification","NotificationResp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deserialize","from","from","from","from","get_notification","heading","heading","id","id","into","into","into","message","message","name","name","received","received","register","runner","serialize","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","get_notification","MarkReadReq","NotificationResp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deserialize","deserialize","from","from","from","heading","id","id","into","into","into","mark_read","message","name","received","register","serialize","serialize","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Notifications","add","borrow","borrow_mut","from","get","into","mark_read","new","try_from","try_into","type_id","vzip","get_config","routes","services","verify_pow","verify_token","GetConfigPayload","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","get_config","init_mcaptcha","into","into","key","register","serialize","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","PoW","borrow","borrow_mut","from","get_config","into","new","scope","try_from","try_into","type_id","validate_captcha_token","verify_pow","vzip","ValidationToken","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","into","into","register","serialize","to_owned","token","try_from","try_from","try_into","try_into","type_id","type_id","verify_pow","vzip","vzip","CaptchaValidateResp","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","into","into","register","serialize","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","valid","validate_captcha_token","vzip","vzip","ROUTES","Routes","account","auth","borrow","borrow_mut","duration","from","into","levels","mcaptcha","meta","new","notifications","pow","try_from","try_into","type_id","vzip","Data","Embedded","Mailer","Redis","SystemGroup","add_site","borrow","borrow","borrow_mut","borrow_mut","captcha","creds","db","from","from","get_creds","get_mailer","get_pow","into","into","mailer","new","new","new_system","remove","rename","try_from","try_from","try_into","try_into","type_id","type_id","validate_verification_tokens","verify_pow","vzip","vzip","DAY","Date","HOUR","MINUTE","WEEK","borrow","borrow_mut","clone","clone_into","date","fmt","format","from","into","print_date","time","to_owned","try_from","try_into","type_id","vzip","DEMO_PASSWORD","DEMO_USER","delete_demo_user","register_demo_user","run","Asset","DOCS","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","dist","from","from","from","from","get","get","handle_embedded_file","index","into","into","into","into","iter","iter","register","register","register","routes","services","spec","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","Docs","assets","borrow","borrow_mut","from","home","into","new","spec","try_from","try_into","type_id","vzip","verification","IndexPage","PAGE","borrow","borrow_mut","clone","clone_into","from","into","new","render_once","render_once_to","to_owned","try_from","try_into","type_id","verification","verification_link","vzip","0","AccountNotFound","BlacklistError","CaptchaError","ClosedForRegistration","EmailTaken","ErrorToResponse","InternalServerError","InternalServerError","NotAUrl","NotAnEmail","PageError","PageResult","PasswordTooLong","PasswordTooShort","PasswordsDontMatch","ProfainityError","ServiceError","ServiceError","ServiceResult","SmtpErrorWrapper","TokenNotFound","UnableToSendEmail","UsernameCaseMappedError","UsernameNotFound","UsernameTaken","WrongPassword","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deserialize","eq","eq","eq","error","error_response","error_response","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","ne","ne","serialize","source","source","source","status_code","status_code","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","auth","CheckLogin","CheckLoginMiddleware","borrow","borrow","borrow_mut","borrow_mut","call","from","from","into","into","into_service","new_transform","poll_ready","service","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","NAME","auth","errors","panel","routes","services","sitemap","login","register","routes","services","sudo","INDEX","IndexPage","PAGE","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","from","from","from","initialize","into","into","into","login","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","INDEX","IndexPage","PAGE","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","from","from","from","initialize","into","into","into","join","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Auth","borrow","borrow_mut","from","get_sitemap","into","join","login","new","try_from","try_into","type_id","vzip","PAGE","SudoPage","borrow","borrow_mut","clone","clone_into","data","from","into","new","render_once","render_once_to","to_owned","try_from","try_into","type_id","url","vzip","ERROR_ROUTE","ErrorPage","INTERNAL_SERVER_ERROR_BODY","PAGE","UNKNOWN_ERROR_BODY","__private_field","__private_field","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deref","deref","error","from","from","from","from","initialize","initialize","into","into","into","into","message","new","register","render_once","render_once_to","routes","services","title","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","Errors","borrow","borrow_mut","from","internal_server_error","into","new","try_from","try_into","type_id","unknown_error","vzip","IndexPage","PAGE","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","from","from","into","into","new","notifications","panel","register","render_once","render_once_to","routes","services","settings","sitekey","sitekeys","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","IndexPage","Notification","PAGE","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","from","from","from","from","heading","id","into","into","into","message","n","name","new","notifications","print_date","received","register","render_once","render_once_to","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Panel","borrow","borrow_mut","from","get_sitemap","home","into","new","notifications","settings","sitekey","try_from","try_into","type_id","vzip","IndexPage","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","delete_account","email","from","from","from","from","into","into","into","into","register","register","register","render_once","render_once_to","routes","secret","services","settings","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","update_secret","username","vzip","vzip","vzip","vzip","Settings","borrow","borrow_mut","delete_account","from","get_sitemap","home","into","new","try_from","try_into","type_id","update_secret","vzip","add","delete","edit","list","routes","services","view","INDEX","IndexPage","PAGE","__private_field","add_sitekey","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","form_description","form_duration","form_title","from","from","from","initialize","into","into","into","levels","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","borrow","borrow_mut","delete_sitekey","from","into","register","try_from","try_into","type_id","vzip","IndexPage","Level","McaptchaConfig","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_id","difficulty_factor","duration","duration","edit_sitekey","from","from","from","from","into","into","into","into","key","levels","name","name","new","register","render_once","render_once_to","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","visitor_threshold","vzip","vzip","vzip","vzip","IndexPage","PAGE","SiteKeys","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","from","from","get_list_sitekeys","into","into","list_sitekeys","new","register","render_once","render_once_to","sitekeys","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Sitekey","add","borrow","borrow_mut","delete","edit","from","get_sitemap","into","list","new","try_from","try_into","type_id","view","vzip","IndexPage","Level","McaptchaConfig","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_id","difficulty_factor","duration","duration","from","from","from","from","into","into","into","into","key","levels","name","name","new","register","render_once","render_once_to","stats","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","view_sitekey","visitor_threshold","vzip","vzip","vzip","vzip","ROUTES","Routes","about","auth","borrow","borrow_mut","donate","errors","from","get_sitemap","home","into","new","panel","privacy","security","sitemap","thanks","try_from","try_into","type_id","vzip","INDEX","IndexPage","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","domain","from","from","from","initialize","into","into","into","register","render_once","render_once_to","sitemap","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","urls","vzip","vzip","vzip","Get","Methods","Post","ProtectGet","ProtectPost","borrow","borrow_mut","from","into","try_from","try_into","type_id","vzip","Captcha","Database","DatabaseBuilder","Redis","Server","Settings","Smtp","allow_demo","allow_registration","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","check_url","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","commercial","cookie_secret","database","debug","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","domain","extract_database_url","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","gc","get_ip","hostname","into","into","into","into","into","into","into","ip","name","new","password","password","pool","pool","port","port","port","pow","proxy_has_tls","redis","reply","salt","server","set_database_url","set_from_database_url","smtp","source_code","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","url","url","url","url","url_prefix","username","username","vzip","vzip","vzip","vzip","vzip","vzip","vzip","filemap","services","static_files","FileMap","borrow","borrow_mut","files","from","get","into","new","try_from","try_into","type_id","vzip","Asset","Favicons","assets","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","favicons","from","from","from","from","get","get","get","get","handle_assets","handle_favicons","into","into","into","into","iter","iter","iter","iter","register","register","static_files","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","BAR_CHART","CREDIT_CARD","DOCS_ICON","GITHUB","HELP_CIRCLE","HOME","Img","KEY","MCAPTCHA_TRANS_ICON","MESSAGE","SETTINGS_ICON","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","from","from","from","from","from","from","from","from","from","from","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","into","into","into","into","into","into","into","into","into","into","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","fetch","record","Stats","StatsPayload","StatsUnixTimestamp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_fetches","config_fetches","confirms","confirms","deserialize","deserialize","fmt","fmt","fmt","from","from","from","from_stats","into","into","into","key","new","runners","serialize","serialize","solves","solves","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","unix_timestamp","vzip","vzip","vzip","fetch_config_fetched","fetch_confirm","fetch_solve","record_confirm","record_fetch","record_solve","INDEX_PAGE","IndexPage","PAGE","WIDGET_ROUTES","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deref","from","from","from","initialize","into","into","into","new","register","render_once","render_once_to","routes","services","show_widget","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Widget","borrow","borrow_mut","from","into","new","try_from","try_into","type_id","verification_widget","vzip"],"q":["mcaptcha","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api","mcaptcha::api::v1","","","","","","","","mcaptcha::api::v1::account","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::delete","","","","","","","","","","","","mcaptcha::api::v1::account::delete::runners","mcaptcha::api::v1::account::email","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::password","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::routes","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::secret","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::username","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::username::runners","mcaptcha::api::v1::auth","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::auth::routes","","","","","","","","","","","","","mcaptcha::api::v1::auth::runners","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha","","","","","mcaptcha::api::v1::mcaptcha::captcha","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::captcha::routes","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::duration","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::duration::routes","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::levels","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::levels::routes","","","","","","","","","","","","","mcaptcha::api::v1::meta","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::meta::routes","","","","","","","","","","","","mcaptcha::api::v1::notifications","","","","","mcaptcha::api::v1::notifications::add","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::get","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::get::runner","mcaptcha::api::v1::notifications::mark_read","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::routes","","","","","","","","","","","","","mcaptcha::api::v1::pow","","","","","mcaptcha::api::v1::pow::get_config","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::pow::routes","","","","","","","","","","","","","","mcaptcha::api::v1::pow::verify_pow","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::pow::verify_token","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::routes","","","","","","","","","","","","","","","","","","","mcaptcha::data","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::date","","","","","","","","","","","","","","","","","","","","","mcaptcha::demo","","","","","mcaptcha::docs","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::docs::routes","","","","","","","","","","","","","mcaptcha::email","mcaptcha::email::verification","","","","","","","","","","","","","","","","","","mcaptcha::errors","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::middleware","mcaptcha::middleware::auth","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages","","","","","","","mcaptcha::pages::auth","","","","","mcaptcha::pages::auth::login","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::auth::register","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::auth::routes","","","","","","","","","","","","","mcaptcha::pages::auth::sudo","","","","","","","","","","","","","","","","","","mcaptcha::pages::errors","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::errors::routes","","","","","","","","","","","","mcaptcha::pages::panel","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::routes","","","","","","","","","","","","","","","mcaptcha::pages::panel::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::settings::routes","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey","","","","","","","mcaptcha::pages::panel::sitekey::add","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::delete","","","","","","","","","","mcaptcha::pages::panel::sitekey::edit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::list","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::routes","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::view","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::routes","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::sitemap","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::routes","","","","","","","","","","","","","mcaptcha::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::static_assets","","","mcaptcha::static_assets::filemap","","","","","","","","","","","","mcaptcha::static_assets::static_files","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::static_assets::static_files::assets","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::stats","","mcaptcha::stats::fetch","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::stats::fetch::runners","","","mcaptcha::stats::record","","","mcaptcha::widget","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::widget::routes","","","","","","","","","",""],"d":["","","","","","","","","","App data","","","","","","","","","","","","","","","","","","points to source files matching build commit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mCaptcha system: Redis cache, etc.","","credential management configuration","App data: redis cache, database connections, etc.","","","databse pool","","Defines resoures for [Methods]","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","email client","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","User facing CAPTCHA widget","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","update email","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","update username","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","returns Ok(()) when everything checks out and the user is …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Builder for BuildDetails.","Error type for BuildDetailsBuilder","Health check return datatype","Builder for Health.","Error type for HealthBuilder","Uninitialized field","Uninitialized field","Custom validation error","Custom validation error","","","","","","","","","","","","","","","","","Builds a new BuildDetails.","Builds a new Health.","emmits build details of the bninary","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","checks all components of the system","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that adds a notification message","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that gets all unread notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that marks a notification read","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","PoW Verification module","PoW success token module","","","","","","","","","","","","get PoW configuration for an mcaptcha key","Call this when [MCaptcha][libmcaptcha::MCaptcha] is not …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","validation token that clients receive as proof for …","","","","","","","","","","","","","","","","","","","","","","","route handler that verifies PoW and issues a solution …","","","","","","","","","","","","","","","","","","","","","","","","","","route hander that validates a PoW solution token","","","","","","","","","","","","","","","","","","","","","","App data","","Mailer data type AsyncSmtpTransport","","Represents mCaptcha cache and master system. When Redis …","","","","","","mCaptcha system: Redis cache, etc.","credential management configuration","databse pool","","","","","","","","email client","","create new instance of app data","","","","","","","","","","","","","","","","","","","","","","","print date","","","","","print relative time from date","","","","","","","Demo password","Demo username","","register demo user runner","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Email operations: verification, notification, etc","","","","","","","","","","","","","","","","","","","","","when the value passed contains blacklisted words see …","","","email is already taken","","","","","","","","","","","when the value passed contains profainity","","","","","when the a token name is already taken token not found","Unable to send email","when the value passed contains characters not present in …","","when the a username is already taken","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that renders individual views for sitekeys","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","utility function to get a list of all sitekeys that a …","","","render a list of all sitekeys that a user has","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that renders individual views for sitekeys","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","GET hander","","POST handler","Protected GET handler","Protected POST handler","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","featch PoWConfig confirms","","","","featch PoWConfig fetches","featch PoWConfig confirms","featch PoWConfig solves","record PoWConfig confirms","record PoWConfig fetches","record PoWConfig solves","","","","","","","","","","","","","","","","","","","","","","","","","","","widget services","render a client side widget for CAPTCHA verification","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,19,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,20,19,20,0,19,0,20,19,0,0,11,12,13,14,15,16,17,18,0,0,0,11,12,13,14,15,16,17,18,0,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,20,0,0,0,19,19,0,19,0,19,19,0,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,0,0,0,0,0,0,0,0,0,0,0,0,21,22,21,22,21,22,21,22,0,21,22,0,22,21,22,21,22,21,22,0,0,0,21,22,0,21,22,21,22,21,22,21,22,0,21,21,22,23,23,0,23,23,23,0,0,23,23,23,23,0,0,24,25,26,24,25,26,24,24,24,24,0,24,24,25,26,24,25,26,25,26,24,0,0,24,24,25,26,24,25,26,24,25,26,24,25,26,0,0,27,28,29,27,28,29,28,28,27,28,28,28,27,27,28,29,27,28,29,27,28,28,29,28,0,28,27,28,29,27,28,29,27,28,29,0,0,27,28,29,0,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,0,31,32,33,31,32,33,31,31,31,31,31,32,33,0,31,32,33,32,33,31,31,0,31,31,32,33,31,32,33,31,32,33,0,31,32,33,0,34,35,36,34,35,36,35,35,35,35,34,35,36,34,35,36,34,36,0,35,0,0,35,34,35,36,34,35,36,34,35,36,35,0,34,35,36,0,37,38,39,37,38,39,37,38,39,37,38,39,0,0,37,38,39,0,0,0,0,37,38,39,37,38,39,37,38,39,37,38,39,0,40,40,40,40,40,40,40,40,40,40,40,40,0,0,0,41,42,43,41,42,43,41,42,43,41,42,43,41,41,42,43,41,41,42,43,41,42,43,41,42,43,42,0,41,42,43,0,41,42,43,41,42,43,41,42,43,41,42,43,41,42,43,41,41,42,43,0,0,0,0,0,0,0,0,0,0,44,45,46,47,48,49,50,44,45,46,47,48,49,50,44,45,47,49,44,45,47,49,0,44,45,47,49,44,45,47,49,44,45,46,47,48,49,50,0,44,45,46,47,48,49,50,45,47,49,44,45,47,46,48,50,0,44,45,47,49,0,44,45,47,49,44,45,46,47,48,49,50,44,45,46,47,48,49,50,44,45,46,47,48,49,50,0,0,44,45,46,47,48,49,50,0,51,51,51,51,51,51,51,51,51,51,51,51,0,0,0,52,53,54,55,56,52,53,54,55,56,52,54,55,52,54,52,53,54,55,56,0,52,53,54,55,56,52,53,56,0,52,54,55,0,55,52,53,54,55,56,52,53,54,55,56,52,53,54,55,56,0,52,53,54,55,56,0,57,57,57,57,57,57,57,57,57,57,57,0,0,0,0,0,58,59,60,61,62,63,64,58,59,60,61,62,63,64,63,64,63,64,58,60,58,60,63,64,64,58,60,63,64,58,59,60,61,62,63,64,0,0,58,59,60,61,62,63,64,60,58,60,63,59,61,62,0,58,60,63,64,0,63,64,58,59,60,61,62,63,64,58,59,60,61,62,63,64,58,59,60,61,62,63,64,0,64,58,59,60,61,62,63,64,0,65,65,65,65,65,65,65,65,65,65,65,65,0,0,0,0,0,0,66,67,66,67,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,69,72,0,68,69,71,72,68,69,71,72,72,71,72,69,72,68,71,68,66,66,71,67,67,68,69,66,66,66,70,71,72,67,67,67,73,69,68,69,0,68,69,66,70,71,72,67,73,71,72,71,72,70,73,0,68,71,0,68,69,71,72,66,67,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,69,68,69,68,69,66,70,71,72,67,73,0,74,74,74,74,74,74,74,74,74,74,74,0,0,0,0,0,0,0,75,76,75,76,75,75,76,75,75,76,75,76,75,75,75,76,75,76,75,76,75,76,0,0,77,78,79,77,78,79,78,77,78,78,79,0,77,78,77,78,77,78,79,77,78,77,78,77,78,79,0,78,77,78,79,77,78,79,77,78,79,77,78,79,0,0,0,80,81,82,80,81,82,80,81,80,81,82,81,80,81,80,81,82,0,81,81,81,82,80,81,80,81,82,80,81,82,80,81,82,80,81,82,0,83,83,83,83,83,83,83,83,83,83,83,83,0,0,0,0,0,0,84,85,84,85,84,84,84,84,84,85,0,0,84,85,84,85,84,84,84,85,84,85,84,85,84,85,0,86,86,86,86,86,86,86,86,86,86,86,86,86,0,87,88,87,88,87,87,87,87,87,88,87,88,88,87,87,87,87,88,87,88,87,88,0,87,88,0,89,90,89,90,89,89,89,89,89,90,89,90,90,89,89,89,90,89,90,89,90,89,0,89,90,0,0,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,0,92,0,92,0,92,92,20,92,20,20,20,20,92,20,20,20,92,92,20,20,92,20,92,92,92,92,20,92,20,92,20,92,92,92,20,0,0,0,0,0,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,0,0,0,0,0,0,0,94,95,96,97,94,95,96,97,0,94,95,96,97,94,94,0,0,94,95,96,97,94,94,95,96,97,0,0,0,94,95,96,97,94,95,96,97,94,95,96,97,94,95,96,97,0,98,98,98,98,98,98,98,98,98,98,98,98,0,0,0,99,99,99,99,99,99,99,99,99,99,99,99,99,0,99,99,100,101,101,101,101,101,0,101,102,101,101,0,0,101,101,101,101,0,102,0,0,101,101,101,101,101,101,100,101,103,102,100,101,103,102,103,100,101,102,103,101,102,100,100,101,101,102,102,100,101,101,101,101,101,101,101,101,101,103,102,102,102,100,101,103,102,101,102,103,100,101,102,101,102,100,101,102,100,101,103,102,100,101,103,102,100,101,103,102,100,101,103,102,0,0,0,104,105,104,105,105,104,105,104,105,105,104,105,105,104,105,104,105,104,105,104,105,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,107,106,108,107,106,108,107,107,107,106,107,106,108,106,107,106,108,0,108,107,107,107,107,106,108,107,106,108,107,106,108,107,106,108,0,0,0,109,110,109,111,110,109,111,110,110,110,109,110,109,111,109,110,109,111,0,111,110,110,110,110,109,111,110,109,111,110,109,111,110,109,111,0,112,112,112,112,112,112,112,112,112,112,112,112,0,0,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,0,0,0,0,0,114,115,116,114,115,117,116,114,115,117,116,116,114,115,0,116,114,115,117,114,115,116,114,115,117,116,116,117,116,116,0,0,116,116,116,114,115,117,116,114,115,117,116,114,115,117,116,114,115,117,0,118,118,118,118,118,118,118,118,118,118,118,0,0,119,120,119,120,119,119,119,120,119,120,119,0,0,120,119,119,0,0,0,0,119,119,119,120,119,120,119,120,119,120,0,0,0,121,122,123,121,122,123,121,121,122,123,121,121,121,122,123,121,122,121,122,0,121,121,123,122,122,121,122,123,121,122,123,121,122,123,121,122,123,0,124,124,124,124,124,124,124,124,124,124,124,124,124,124,0,0,125,126,127,128,125,126,127,128,125,125,0,125,125,126,127,128,125,126,127,128,126,127,128,125,125,0,125,0,0,125,125,126,127,128,125,126,127,128,125,126,127,128,0,125,125,126,127,128,0,129,129,129,129,129,129,129,129,129,129,129,129,129,0,0,0,0,0,0,0,0,0,0,130,0,130,131,132,130,131,132,131,131,131,130,131,131,131,130,131,132,130,130,131,132,131,132,131,131,131,130,131,132,130,131,132,130,131,132,130,131,132,133,133,0,133,133,133,133,133,133,133,0,0,0,0,134,135,136,137,134,135,136,137,134,135,136,134,135,136,134,135,134,136,0,134,135,136,137,134,135,136,137,136,136,134,136,136,137,136,136,134,135,136,134,135,136,137,134,135,136,137,134,135,136,137,135,134,135,136,137,0,0,0,138,139,138,139,138,138,138,139,0,138,139,0,138,139,138,138,138,138,138,139,138,139,138,139,138,139,0,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,0,0,0,0,141,142,143,144,141,142,143,144,141,142,143,141,142,143,141,142,141,143,141,142,143,144,141,142,143,144,143,143,141,143,143,144,143,143,143,141,142,143,141,142,143,144,141,142,143,144,141,142,143,144,0,142,141,142,143,144,0,0,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,0,0,146,147,146,148,147,146,148,147,147,147,146,147,147,146,148,146,147,146,148,148,147,147,0,147,147,146,148,147,146,148,147,146,148,147,147,146,148,149,0,149,149,149,149,149,149,149,149,149,149,149,0,0,0,0,0,0,0,19,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,0,150,151,152,153,154,155,19,150,151,152,153,154,155,19,19,150,19,19,150,151,152,153,154,155,19,150,153,150,151,152,153,154,155,19,150,151,152,153,154,155,19,152,151,150,153,150,151,152,153,154,155,19,150,153,19,152,153,154,155,150,152,153,19,150,19,152,151,19,0,0,19,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,152,153,154,155,150,152,153,150,151,152,153,154,155,19,0,0,0,0,156,156,156,156,156,156,156,156,156,156,156,0,0,0,157,158,159,160,157,158,159,160,0,157,158,159,160,157,157,159,159,0,0,157,158,159,160,157,157,159,159,158,160,0,157,158,159,160,157,158,159,160,157,158,159,160,157,158,159,160,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,0,0,0,0,0,161,162,163,161,162,163,161,162,163,161,162,163,161,162,161,162,161,163,161,162,163,161,162,163,161,161,162,163,163,162,0,161,163,161,162,161,162,163,161,162,163,161,162,163,161,162,163,161,161,162,163,0,0,0,0,0,0,0,0,0,0,164,165,164,166,165,164,166,165,165,164,165,164,166,164,165,164,166,165,166,165,165,0,0,0,165,165,164,166,165,164,166,165,164,166,165,164,166,0,167,167,167,167,167,167,167,167,167,167],"f":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,null,[[],["settings",3]],[[],["filemap",3]],[[]],[[]],[[]],[[]],[[]],[[],["string",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],[["identityservice",3],["cookieidentitypolicy",3]]],[[],["jsonconfig",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[],["result",6]],null,null,null,null,null,null,null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,[[["serviceconfig",3]]],null,null,[[]],[[]],[[]],[[]],[[],["accountcheckpayload",3]],[[],["accountcheckresp",3]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],null,null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],null,null,null,[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,[[]],[[]],[[["appservice",3]]],null,[[["serviceconfig",3]]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[["appdata",6],["str",15]]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["email",3]],[[]],[[],["result",4]],null,null,[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],[[],["result",4]],[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["changepasswordreqest",3]],[[]],null,null,[[],["result",4]],[[["formatter",3]],["result",6]],[[["changepasswordreqest",3]]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,[[["appservice",3]]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[["data",3],["updatepassword",3],["str",15]]],null,[[]],[[]],[[]],null,[[]],[[]],null,null,[[]],null,[[]],[[],["account",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,null,null,null,null,[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["secret",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[["serviceconfig",3]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["username",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[["appdata",6],["accountcheckpayload",3]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,null,[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],null,null,[[],["auth",3]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["register",3]],[[],["login",3]],[[],["password",3]],[[]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["login",3],["appdata",6]]],null,null,null,[[["register",3],["appdata",6]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,null,[[["usize",15]],["string",3]],null,[[["serviceconfig",3]]],null,null,null,null,[[["identity",3],["str",15],["u32",15],["appdata",6]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaid",3]],[[],["mcaptchadetails",3]],[[],["deletecaptcha",3]],[[],["statspayload",3]],[[]],[[]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[["appdata",6],["str",15]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],[[]],[[],["mcaptcha",3]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,null,[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[],["duration",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["levels",3]],[[],["i32levels",3]],[[]],[[]],null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,null,null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appdata",6],["str",15]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[],["levels",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],[["builddetailsbuildererror",4],["result",4],["builddetails",3]]],[[],[["health",3],["healthbuildererror",4],["result",4]]],null,[[],["builddetails",3]],[[],["builddetailsbuilder",3]],[[],["health",3]],[[],["healthbuilder",3]],[[]],[[]],[[]],[[]],[[["bool",15]]],null,null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[["string",3]]],[[["uninitializedfielderror",3]]],[[]],[[]],[[]],[[]],[[["string",3]]],[[]],[[["uninitializedfielderror",3]]],[[]],[[["str",15]]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["option",4]],["bool",15]],[[["bool",15],["option",4]]],null,null,[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[]],[[]],[[],["string",3]],[[],["string",3]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[["str",15]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,[[["serviceconfig",3]]],null,null,[[]],[[]],[[]],[[]],[[],["result",4]],[[]],[[]],null,[[]],[[]],null,[[["appservice",3]]],[[],["result",4]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[]],[[]],[[["notification",3]]],[[]],null,null,null,null,null,[[]],[[]],[[]],null,null,null,null,null,null,[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[["appdata",6],["str",15]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],null,null,null,null,[[["appservice",3]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],null,[[],["notifications",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[["serviceconfig",3]]],null,null,null,[[]],[[]],[[]],[[]],[[],["getconfigpayload",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],null,[[["appdata",6],["str",15]]],[[]],[[]],null,[[["appservice",3]]],[[],["result",4]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,null,[[]],null,[[]],[[]],[[]],[[]],[[],["validationtoken",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],null,[[]],[[]],[[]],[[]],[[],["captchavalidateresp",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],null,null,null,null,[[]],[[]],null,[[]],[[]],null,null,null,[[],["routes",3]],null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,[[["addsite",3]]],[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[],["config",3]],[[],[["option",4],["asyncsmtptransport",3]]],[[["string",3]]],[[]],[[]],null,[[]],[[]],[[["mastertrait",8],["addr",3],["addr",3],["save",8]],[["save",8],["mastertrait",8],["system",3]]],[[["removecaptcha",3]]],[[["rename",3]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[["verifycaptcharesult",3]]],[[["work",3]]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[],["date",3]],[[]],[[],["string",3]],[[["formatter",3]],["result",6]],[[["offsetdatetime",3]],["string",3]],[[]],[[]],[[],["string",3]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[["appdata",6]]],[[["appdata",6]]],[[["duration",3],["appdata",6]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],["httpresponse",3]],null,[[]],[[]],[[]],[[]],[[]],[[],["filenames",4]],[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[["str",15]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[["data",3],["str",15]]],null,[[]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["bool",15]],[[["serviceerror",4]],["bool",15]],[[["pageerror",4]],["bool",15]],null,[[],["httpresponse",3]],[[],["httpresponse",3]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[["validationerrors",3]],["serviceerror",4]],[[["credserror",4]],["serviceerror",4]],[[["mailboxerror",4]]],[[["smtperror",3]]],[[["recverror",3]]],[[]],[[["error",4]]],[[["captchaerror",4]],["serviceerror",4]],[[["parseerror",4]],["serviceerror",4]],[[]],[[]],[[["serviceerror",4]]],[[["error",4]]],[[]],[[]],[[]],[[]],[[["serviceerror",4]],["bool",15]],[[["pageerror",4]],["bool",15]],[[],["result",4]],[[],[["error",8],["option",4]]],[[],[["error",8],["option",4]]],[[],[["error",8],["option",4]]],[[],["statuscode",3]],[[],["statuscode",3]],[[],["string",3]],[[],["string",3]],[[],["string",3]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[["servicerequest",3]]],[[]],[[]],[[]],[[]],[[]],[[]],[[["context",3]],[["result",4],["poll",4]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],null,null,[[],["auth",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[]],[[]],[[],["sudopage",3]],[[]],null,[[]],[[]],[[["str",15],["vec",3],["option",4]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["errorpage",3]],[[]],[[],["string",3]],[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["str",15]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[]],[[]],[[["mcaptchadetails",3],["vec",3]]],null,null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[["serviceconfig",3]]],null,null,null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[["notification",3]]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,null,null,[[["vec",3],["notification",3]]],null,[[],["string",3]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],null,[[]],[[]],null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaconfig",3]],[[],["level",3]],[[],["indexpage",3]],[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["mcaptchaconfig",3],["vec",3],["level",3],["string",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[["identity",3],["appdata",6]]],[[]],[[]],null,[[["mcaptchadetails",3],["vec",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaconfig",3]],[[],["level",3]],[[],["indexpage",3]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["level",3],["stats",3],["mcaptchaconfig",3],["vec",3],["string",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],null,null,[[]],[[]],null,[[]],[[],["routes",3]],null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["config",3]]],[[],["server",3]],[[],["captcha",3]],[[],["smtp",3]],[[],["databasebuilder",3]],[[],["database",3]],[[],["redis",3]],[[],["settings",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["url",3]]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],[["result",4],["configerror",4]]],null,null,null,null,null,null,null,null,null,null,null,null,null,[[["config",3]]],[[["databasebuilder",3],["config",3]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["serviceconfig",3]]],null,null,[[]],[[]],null,[[]],[[["str",15]],[["str",15],["option",4]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],[["embeddedfile",3],["option",4]]],[[["str",15]],["httpresponse",3]],[[["str",15]],["httpresponse",3]],[[]],[[]],[[]],[[]],[[]],[[],["filenames",4]],[[],["filenames",4]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["statsunixtimestamp",3]],[[],["stats",3]],[[],["statspayload",3]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[["stats",3]]],[[]],[[]],[[]],null,[[["str",15],["pgpool",6]]],null,[[],["result",4]],[[],["result",4]],null,null,[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],[["i64",15],["vec",3]]],[[]],[[]],[[]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4],["rendererror",4]]],null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]]],"p":[[3,"KEY"],[3,"GITHUB"],[3,"HOME"],[3,"SETTINGS_ICON"],[3,"CREDIT_CARD"],[3,"HELP_CIRCLE"],[3,"MESSAGE"],[3,"DOCS_ICON"],[3,"MCAPTCHA_TRANS_ICON"],[3,"BAR_CHART"],[3,"SETTINGS"],[3,"FILES"],[3,"JS"],[3,"CSS"],[3,"MOBILE_CSS"],[3,"VERIFICATIN_WIDGET_JS"],[3,"VERIFICATIN_WIDGET_CSS"],[3,"SOURCE_FILES_OF_INSTANCE"],[3,"Settings"],[3,"Data"],[3,"AccountCheckPayload"],[3,"AccountCheckResp"],[3,"delete_account"],[3,"Email"],[3,"email_exists"],[3,"set_email"],[3,"UpdatePassword"],[3,"ChangePasswordReqest"],[3,"update_user_password"],[3,"Account"],[3,"Secret"],[3,"get_secret"],[3,"update_user_secret"],[3,"username_exists"],[3,"Username"],[3,"set_username"],[3,"register"],[3,"login"],[3,"signout"],[3,"Auth"],[3,"Register"],[3,"Login"],[3,"Password"],[3,"MCaptchaID"],[3,"MCaptchaDetails"],[3,"update_token"],[3,"DeleteCaptcha"],[3,"delete_mcaptcha"],[3,"StatsPayload"],[3,"get_stats"],[3,"MCaptcha"],[3,"UpdateDuration"],[3,"update_duration"],[3,"GetDurationResp"],[3,"GetDuration"],[3,"get_duration"],[3,"Duration"],[3,"AddLevels"],[3,"add_levels"],[3,"UpdateLevels"],[3,"update_levels"],[3,"get_levels"],[3,"Levels"],[3,"I32Levels"],[3,"Levels"],[4,"BuildDetailsBuilderError"],[4,"HealthBuilderError"],[3,"BuildDetails"],[3,"BuildDetailsBuilder"],[3,"build_details"],[3,"Health"],[3,"HealthBuilder"],[3,"health"],[3,"Meta"],[3,"AddNotification"],[3,"add_notification"],[3,"Notification"],[3,"NotificationResp"],[3,"get_notification"],[3,"MarkReadReq"],[3,"NotificationResp"],[3,"mark_read"],[3,"Notifications"],[3,"GetConfigPayload"],[3,"get_config"],[3,"PoW"],[3,"ValidationToken"],[3,"verify_pow"],[3,"CaptchaValidateResp"],[3,"validate_captcha_token"],[3,"Routes"],[4,"SystemGroup"],[3,"Date"],[3,"Asset"],[3,"dist"],[3,"spec"],[3,"index"],[3,"Docs"],[3,"IndexPage"],[3,"SmtpErrorWrapper"],[4,"ServiceError"],[4,"PageError"],[3,"ErrorToResponse"],[3,"CheckLogin"],[3,"CheckLoginMiddleware"],[3,"INDEX"],[3,"IndexPage"],[3,"login"],[3,"INDEX"],[3,"IndexPage"],[3,"join"],[3,"Auth"],[3,"SudoPage"],[3,"INTERNAL_SERVER_ERROR_BODY"],[3,"UNKNOWN_ERROR_BODY"],[3,"ErrorPage"],[3,"error"],[3,"Errors"],[3,"IndexPage"],[3,"panel"],[3,"Notification"],[3,"IndexPage"],[3,"notifications"],[3,"Panel"],[3,"IndexPage"],[3,"settings"],[3,"delete_account"],[3,"update_secret"],[3,"Settings"],[3,"INDEX"],[3,"IndexPage"],[3,"add_sitekey"],[3,"delete_sitekey"],[3,"McaptchaConfig"],[3,"Level"],[3,"IndexPage"],[3,"edit_sitekey"],[3,"IndexPage"],[3,"list_sitekeys"],[3,"Sitekey"],[3,"McaptchaConfig"],[3,"Level"],[3,"IndexPage"],[3,"view_sitekey"],[3,"Routes"],[3,"INDEX"],[3,"IndexPage"],[3,"sitemap"],[4,"Methods"],[3,"Server"],[3,"Captcha"],[3,"Smtp"],[3,"DatabaseBuilder"],[3,"Database"],[3,"Redis"],[3,"FileMap"],[3,"Asset"],[3,"static_files"],[3,"Favicons"],[3,"favicons"],[3,"StatsUnixTimestamp"],[3,"Stats"],[3,"StatsPayload"],[3,"INDEX_PAGE"],[3,"IndexPage"],[3,"show_widget"],[3,"Widget"]]},\ -"mcaptcha_browser":{"doc":"mCaptcha is a proof of work based Denaial-of-Service …","t":[3,5,11,11,11,11,11,5,11,12,12,11,11,11,11],"n":["Work","__wasm_bindgen_generated_gen_pow","borrow","borrow_mut","deserialize","from","from","gen_pow","into","nonce","result","serialize","try_from","try_into","type_id"],"q":["mcaptcha_browser","","","","","","","","","","","","","",""],"d":["","generate proof-of-work","","","","","","generate proof-of-work","","","","","","",""],"i":[0,0,1,1,1,1,1,0,1,1,1,1,1,1,1],"f":[null,[[]],[[]],[[]],[[],["result",4]],[[]],[[["pow",3],["string",3]]],[[["u32",15],["string",3]],["string",3]],[[]],null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]]],"p":[[3,"Work"]]},\ -"tests_migrate":{"doc":"","t":[3,3,12,12,12,11,11,5,5,12,12,12,11,11,11,11,5,12,12,12,0,12,12,11,11,11,11,3,3,3,3,3,3,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,12,11,11,11,11,11,11,11,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,5,5,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,11,11,11,11,11,11,11],"n":["SETTINGS","Settings","__private_field","allow_demo","allow_registration","borrow","borrow_mut","build","cache_bust","commercial","database","debug","deref","from","initialize","into","main","pow","redis","server","settings","smtp","source_code","try_from","try_into","type_id","vzip","Captcha","Database","DatabaseBuilder","Redis","Server","Settings","Smtp","allow_demo","allow_registration","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","check_url","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","commercial","cookie_secret","database","debug","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","domain","extract_database_url","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","gc","get_ip","hostname","into","into","into","into","into","into","into","ip","name","new","password","password","pool","pool","port","port","port","pow","proxy_has_tls","redis","reply","salt","server","set_database_url","set_from_database_url","smtp","source_code","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","url","url","url","url","url_prefix","username","username","vzip","vzip","vzip","vzip","vzip","vzip","vzip"],"q":["tests_migrate","","","","","","","","","","","","","","","","","","","","","","","","","","","tests_migrate::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"d":["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,1,2,2,1,1,0,0,2,2,2,1,1,1,1,0,2,2,2,0,2,2,1,1,1,1,0,0,0,0,0,0,0,2,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,0,3,4,5,6,7,8,2,3,4,5,6,7,8,2,2,3,2,2,3,4,5,6,7,8,2,3,6,3,4,5,6,7,8,2,3,4,5,6,7,8,2,5,4,3,6,3,4,5,6,7,8,2,3,6,2,5,6,7,8,3,5,6,2,3,2,5,4,2,0,0,2,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,5,6,7,8,3,5,6,3,4,5,6,7,8,2],"f":[null,null,null,null,null,[[]],[[]],[[]],[[]],null,null,null,[[],["settings",3]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["config",3]]],[[],["server",3]],[[],["captcha",3]],[[],["smtp",3]],[[],["databasebuilder",3]],[[],["database",3]],[[],["redis",3]],[[],["settings",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["url",3]]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],[["result",4],["configerror",4]]],null,null,null,null,null,null,null,null,null,null,null,null,null,[[["config",3]]],[[["databasebuilder",3],["config",3]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]]],"p":[[3,"SETTINGS"],[3,"Settings"],[3,"Server"],[3,"Captcha"],[3,"Smtp"],[3,"DatabaseBuilder"],[3,"Database"],[3,"Redis"]]}\ +"mcaptcha":{"doc":"","t":[6,3,17,17,3,3,3,17,3,3,3,3,17,3,3,3,3,3,3,3,17,17,17,17,17,3,3,3,3,17,3,3,17,17,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,12,0,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,0,12,0,12,12,14,0,11,11,11,11,11,11,11,11,0,0,0,11,11,11,11,11,11,11,11,5,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,5,0,0,12,12,0,12,0,12,12,0,0,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,0,0,0,0,0,0,0,0,5,3,3,11,11,11,11,11,11,11,11,0,11,11,0,12,11,11,11,11,11,11,0,0,0,11,11,5,11,11,11,11,11,11,11,11,0,12,11,11,11,11,3,11,11,11,0,5,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,12,3,11,11,11,11,11,11,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,12,12,12,11,11,5,11,11,11,11,11,11,11,11,11,11,5,3,11,11,11,3,11,11,12,12,11,12,11,11,11,11,11,12,12,12,12,12,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,12,11,5,11,11,11,11,11,11,11,11,11,11,3,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,11,5,3,11,11,11,11,11,11,11,11,11,11,12,3,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,3,3,11,11,11,0,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,12,12,11,12,11,11,11,11,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,12,11,11,11,11,11,11,11,11,11,12,5,12,12,12,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,0,0,5,0,5,3,3,3,3,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,12,12,12,12,12,12,11,11,11,0,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,5,11,11,11,11,11,11,11,3,11,11,12,11,11,11,12,11,11,11,12,11,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,3,11,11,11,11,11,12,11,11,0,11,11,11,5,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,3,11,11,11,12,11,11,11,11,11,12,11,3,3,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,12,12,12,11,11,11,11,11,11,11,11,11,3,5,11,11,11,11,11,11,11,12,12,12,12,11,11,11,0,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,11,11,11,3,12,11,11,11,12,11,11,11,11,11,12,11,3,3,4,3,3,4,13,13,13,13,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,3,11,11,11,11,11,11,11,11,11,11,12,12,11,11,0,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,11,11,11,11,11,3,11,11,12,11,12,11,11,11,11,11,11,0,0,0,0,5,3,3,11,11,11,11,11,11,11,12,11,11,12,11,11,12,11,11,11,11,11,11,11,11,3,3,11,11,11,11,11,11,11,11,11,11,11,3,12,12,12,12,11,11,11,12,12,12,12,12,12,11,0,11,11,11,11,11,11,11,11,11,11,11,11,11,5,3,3,11,11,11,11,11,11,11,11,11,11,11,12,12,12,11,11,11,3,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,12,11,12,11,11,11,11,11,0,0,5,0,0,3,11,11,11,11,11,11,11,11,11,11,3,5,11,11,12,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,12,11,11,12,11,11,11,12,12,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,3,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,3,11,11,17,3,12,12,11,11,12,11,11,12,12,12,11,12,12,11,11,11,11,3,13,6,13,4,11,11,11,11,11,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,17,3,17,17,17,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,17,17,5,5,5,3,17,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,5,3,11,11,11,11,11,11,11,11,11,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,12,11,11,12,11,11,11,11,0,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,5,12,11,12,13,13,13,13,13,3,13,13,13,13,4,6,13,13,13,13,4,13,6,3,13,13,13,13,13,13,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,17,0,0,0,0,5,0,0,0,0,5,0,3,3,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,12,12,11,11,11,11,11,17,3,11,11,11,11,12,11,11,11,11,11,11,11,11,11,12,11,17,3,3,17,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,0,5,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,12,11,11,11,11,11,12,11,3,17,11,11,11,11,11,11,11,11,11,11,11,0,3,11,11,11,0,5,0,0,12,11,11,11,11,11,11,11,11,11,3,3,17,11,11,11,11,11,11,11,11,11,11,12,12,11,11,11,12,12,12,11,3,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,12,11,11,12,12,12,11,11,11,11,3,17,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,11,11,11,11,11,11,11,11,11,0,12,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,3,11,11,12,11,11,12,11,11,11,11,11,12,11,0,0,0,0,0,5,0,3,3,17,12,3,11,11,11,11,11,11,11,11,11,11,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,3,3,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,3,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,3,17,6,11,11,11,11,11,11,11,11,5,11,11,3,11,11,11,11,12,11,11,11,11,11,11,11,11,11,3,12,11,11,12,12,11,11,11,12,11,11,11,11,12,11,3,3,3,17,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,12,11,11,11,11,17,3,12,12,11,11,12,12,11,11,12,11,11,12,12,12,12,12,11,11,11,11,3,3,12,11,11,11,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,12,11,11,11,13,4,13,13,13,11,11,11,11,11,11,11,11,3,3,3,3,3,3,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,12,11,11,11,11,11,11,11,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,5,5,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,11,11,11,11,11,11,11,0,5,0,3,11,11,12,11,11,11,11,11,11,11,11,3,3,0,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,5,5,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,3,3,3,3,3,3,6,3,3,3,3,12,12,12,12,12,12,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,0,3,3,3,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,11,11,11,11,11,12,11,0,11,11,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,5,5,5,5,5,3,3,17,17,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,0,5,3,11,11,11,11,11,11,11,11,11,11,11,11,11,3,11,11,11,11,11,11,11,11,12,11],"n":["AppData","BAR_CHART","CACHE_AGE","COMPILED_DATE","CREDIT_CARD","CSS","CheckLogin","DOCS","DOCS_ICON","Data","FILES","GITHUB","GIT_COMMIT_HASH","HELP_CIRCLE","HOME","JS","KEY","MCAPTCHA_TRANS_ICON","MESSAGE","MOBILE_CSS","OPEN_API_DOC","PAGES","PKG_DESCRIPTION","PKG_HOMEPAGE","PKG_NAME","SETTINGS","SETTINGS_ICON","SOURCE_FILES_OF_INSTANCE","Settings","V1_API_ROUTES","VERIFICATIN_WIDGET_CSS","VERIFICATIN_WIDGET_JS","VERSION","WIDGET_ROUTES","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","allow_demo","allow_registration","api","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","captcha","commercial","creds","data","database","date","db","debug","define_resource","demo","deref","deref","deref","deref","deref","deref","deref","deref","docs","email","errors","from","from","from","from","from","from","from","from","get_identity_service","get_json_err","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","into","into","into","into","into","into","into","into","mailer","main","middleware","pages","pow","redis","routes","server","settings","smtp","source_code","static_assets","stats","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","widget","v1","account","auth","mcaptcha","meta","notifications","pow","routes","services","AccountCheckPayload","AccountCheckResp","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","delete","deserialize","deserialize","email","exists","fmt","fmt","from","from","into","into","password","routes","secret","serialize","serialize","services","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","username","val","vzip","vzip","borrow","borrow_mut","delete_account","from","into","register","runners","services","try_from","try_into","type_id","vzip","delete_user","Email","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","email","email_exists","fmt","from","from","from","into","into","into","register","register","serialize","services","set_email","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","ChangePasswordReqest","UpdatePassword","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","confirm_new_password","confirm_new_password","deserialize","fmt","from","from","from","from","into","into","into","new_password","new_password","password","register","serialize","services","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_password_runner","update_user_password","vzip","vzip","vzip","Account","borrow","borrow_mut","delete","email_exists","from","get_secret","into","new","try_from","try_into","type_id","update_email","update_password","update_secret","update_username","username_exists","vzip","Secret","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","from","get_secret","into","into","into","register","register","secret","serialize","services","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","update_user_secret","vzip","vzip","vzip","Username","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","from","into","into","into","register","register","runners","serialize","services","set_username","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","username","username_exists","vzip","vzip","vzip","username_exists","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","from","from","from","into","into","into","login","register","register","register","register","routes","runners","services","signout","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Auth","borrow","borrow_mut","from","into","login","logout","new","register","try_from","try_into","type_id","vzip","Login","Password","Register","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","confirm_password","deserialize","deserialize","deserialize","email","fmt","fmt","fmt","from","from","from","into","into","into","login","login_runner","password","password","password","register_runner","serialize","serialize","serialize","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","username","vzip","vzip","vzip","captcha","duration","get_random","levels","services","DeleteCaptcha","MCaptchaDetails","MCaptchaID","StatsPayload","add_mcaptcha_util","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","delete_mcaptcha","deserialize","deserialize","deserialize","deserialize","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get_stats","into","into","into","into","into","into","into","key","key","key","name","name","password","register","register","register","routes","serialize","serialize","serialize","serialize","services","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_token","update_token_helper","vzip","vzip","vzip","vzip","vzip","vzip","vzip","MCaptcha","borrow","borrow_mut","delete","from","into","new","stats","try_from","try_into","type_id","update_key","vzip","GetDuration","GetDurationResp","UpdateDuration","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deserialize","deserialize","deserialize","duration","duration","from","from","from","from","from","get_duration","into","into","into","into","into","key","register","register","routes","serialize","serialize","serialize","services","token","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","update_duration","vzip","vzip","vzip","vzip","vzip","Duration","borrow","borrow_mut","from","get","into","new","try_from","try_into","type_id","update","vzip","AddLevels","I32Levels","Levels","UpdateLevels","add_levels","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","description","description","deserialize","deserialize","deserialize","deserialize","difficulty_factor","duration","duration","fmt","fmt","from","from","from","from","from","from","from","get_levels","get_levels_util","into","into","into","into","into","into","into","key","levels","levels","levels","register","register","register","routes","serialize","serialize","serialize","serialize","services","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","update_levels","visitor_threshold","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Levels","add","borrow","borrow_mut","from","get","into","new","try_from","try_into","type_id","update","vzip","BuildDetails","BuildDetailsBuilder","BuildDetailsBuilderError","Health","HealthBuilder","HealthBuilderError","UninitializedField","UninitializedField","ValidationError","ValidationError","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","build","build","build_details","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","db","db","db","default","default","deserialize","deserialize","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","git_commit_hash","git_commit_hash","git_commit_hash","health","into","into","into","into","into","into","into","into","is_redis","redis","redis","redis","register","register","routes","serialize","serialize","services","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","version","version","version","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","Meta","borrow","borrow_mut","build_details","from","health","into","new","try_from","try_into","type_id","vzip","add","get","mark_read","routes","services","AddNotification","add_notification","borrow","borrow","borrow_mut","borrow_mut","deserialize","from","from","heading","into","into","message","register","serialize","to","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Notification","NotificationResp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deserialize","from","from","from","from","get_notification","heading","heading","id","id","into","into","into","message","message","name","name","received","received","register","runner","serialize","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","get_notification","MarkReadReq","NotificationResp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","deserialize","deserialize","from","from","from","heading","id","id","into","into","into","mark_read","message","name","received","register","serialize","serialize","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Notifications","add","borrow","borrow_mut","from","get","into","mark_read","new","try_from","try_into","type_id","vzip","get_config","routes","services","verify_pow","verify_token","GetConfigPayload","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","get_config","init_mcaptcha","into","into","key","register","serialize","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","PoW","borrow","borrow_mut","from","get_config","into","new","scope","try_from","try_into","type_id","validate_captcha_token","verify_pow","vzip","ValidationToken","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","into","into","register","serialize","to_owned","token","try_from","try_from","try_into","try_into","type_id","type_id","verify_pow","vzip","vzip","CaptchaValidateResp","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deserialize","fmt","from","from","into","into","register","serialize","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","valid","validate_captcha_token","vzip","vzip","ROUTES","Routes","account","auth","borrow","borrow_mut","duration","from","into","levels","mcaptcha","meta","new","notifications","pow","try_from","try_into","type_id","vzip","Data","Embedded","Mailer","Redis","SystemGroup","add_site","borrow","borrow","borrow_mut","borrow_mut","captcha","creds","db","from","from","get_creds","get_mailer","get_pow","into","into","mailer","new","new","new_system","remove","rename","try_from","try_from","try_into","try_into","type_id","type_id","validate_verification_tokens","verify_pow","vzip","vzip","DAY","Date","HOUR","MINUTE","WEEK","borrow","borrow_mut","clone","clone_into","date","fmt","format","from","into","print_date","time","to_owned","try_from","try_into","type_id","vzip","DEMO_PASSWORD","DEMO_USER","delete_demo_user","register_demo_user","run","Asset","DOCS","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","dist","from","from","from","from","get","get","handle_embedded_file","index","into","into","into","into","iter","iter","register","register","register","routes","services","spec","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","Docs","assets","borrow","borrow_mut","from","home","into","new","spec","try_from","try_into","type_id","vzip","verification","IndexPage","PAGE","borrow","borrow_mut","clone","clone_into","from","into","new","render_once","render_once_to","to_owned","try_from","try_into","type_id","verification","verification_link","vzip","0","AccountNotFound","BlacklistError","CaptchaError","ClosedForRegistration","EmailTaken","ErrorToResponse","InternalServerError","InternalServerError","NotAUrl","NotAnEmail","PageError","PageResult","PasswordTooLong","PasswordTooShort","PasswordsDontMatch","ProfainityError","ServiceError","ServiceError","ServiceResult","SmtpErrorWrapper","TokenNotFound","UnableToSendEmail","UsernameCaseMappedError","UsernameNotFound","UsernameTaken","WrongPassword","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deserialize","eq","eq","eq","error","error_response","error_response","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","into","into","into","into","ne","ne","serialize","source","source","source","status_code","status_code","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","auth","CheckLogin","CheckLoginMiddleware","borrow","borrow","borrow_mut","borrow_mut","call","from","from","into","into","into_service","new_transform","poll_ready","service","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","NAME","auth","errors","panel","routes","services","sitemap","login","register","routes","services","sudo","INDEX","IndexPage","PAGE","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","from","from","from","initialize","into","into","into","login","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","INDEX","IndexPage","PAGE","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","from","from","from","initialize","into","into","into","join","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Auth","borrow","borrow_mut","from","get_sitemap","into","join","login","new","try_from","try_into","type_id","vzip","PAGE","SudoPage","borrow","borrow_mut","clone","clone_into","data","from","into","new","render_once","render_once_to","to_owned","try_from","try_into","type_id","url","vzip","ERROR_ROUTE","ErrorPage","INTERNAL_SERVER_ERROR_BODY","PAGE","UNKNOWN_ERROR_BODY","__private_field","__private_field","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deref","deref","error","from","from","from","from","initialize","initialize","into","into","into","into","message","new","register","render_once","render_once_to","routes","services","title","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","Errors","borrow","borrow_mut","from","internal_server_error","into","new","try_from","try_into","type_id","unknown_error","vzip","IndexPage","PAGE","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","from","from","into","into","new","notifications","panel","register","render_once","render_once_to","routes","services","settings","sitekey","sitekeys","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","IndexPage","Notification","PAGE","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","from","from","from","from","heading","id","into","into","into","message","n","name","new","notifications","print_date","received","register","render_once","render_once_to","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Panel","borrow","borrow_mut","from","get_sitemap","home","into","new","notifications","settings","sitekey","try_from","try_into","type_id","vzip","IndexPage","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","delete_account","email","from","from","from","from","into","into","into","into","register","register","register","render_once","render_once_to","routes","secret","services","settings","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","update_secret","username","vzip","vzip","vzip","vzip","Settings","borrow","borrow_mut","delete_account","from","get_sitemap","home","into","new","try_from","try_into","type_id","update_secret","vzip","add","delete","edit","list","routes","services","view","INDEX","IndexPage","PAGE","__private_field","add_sitekey","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","form_description","form_duration","form_title","from","from","from","initialize","into","into","into","levels","register","render_once","render_once_to","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","borrow","borrow_mut","delete_sitekey","from","into","register","try_from","try_into","type_id","vzip","IndexPage","Level","McaptchaConfig","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_id","difficulty_factor","duration","duration","edit_sitekey","from","from","from","from","into","into","into","into","key","levels","name","name","new","register","render_once","render_once_to","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","visitor_threshold","vzip","vzip","vzip","vzip","IndexPage","PAGE","SiteKeys","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","from","from","get_list_sitekeys","into","into","list_sitekeys","new","register","render_once","render_once_to","sitekeys","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip","Sitekey","add","borrow","borrow_mut","delete","edit","from","get_sitemap","into","list","new","try_from","try_into","type_id","view","vzip","IndexPage","Level","McaptchaConfig","PAGE","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_id","difficulty_factor","duration","duration","from","from","from","from","into","into","into","into","key","levels","name","name","new","register","render_once","render_once_to","stats","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","view_sitekey","visitor_threshold","vzip","vzip","vzip","vzip","ROUTES","Routes","about","auth","borrow","borrow_mut","donate","errors","from","get_sitemap","home","into","new","panel","privacy","security","sitemap","thanks","try_from","try_into","type_id","vzip","INDEX","IndexPage","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","domain","from","from","from","initialize","into","into","into","register","render_once","render_once_to","sitemap","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","urls","vzip","vzip","vzip","Get","Methods","Post","ProtectGet","ProtectPost","borrow","borrow_mut","from","into","try_from","try_into","type_id","vzip","Captcha","Database","DatabaseBuilder","Redis","Server","Settings","Smtp","allow_demo","allow_registration","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","check_url","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","commercial","cookie_secret","database","debug","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","domain","extract_database_url","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","gc","get_ip","hostname","into","into","into","into","into","into","into","ip","name","new","password","password","pool","pool","port","port","port","pow","proxy_has_tls","redis","reply","salt","server","set_database_url","set_from_database_url","smtp","source_code","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","url","url","url","url","url_prefix","username","username","vzip","vzip","vzip","vzip","vzip","vzip","vzip","filemap","services","static_files","FileMap","borrow","borrow_mut","files","from","get","into","new","try_from","try_into","type_id","vzip","Asset","Favicons","assets","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","favicons","from","from","from","from","get","get","get","get","handle_assets","handle_favicons","into","into","into","into","iter","iter","iter","iter","register","register","static_files","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","BAR_CHART","CREDIT_CARD","DOCS_ICON","GITHUB","HELP_CIRCLE","HOME","Img","KEY","MCAPTCHA_TRANS_ICON","MESSAGE","SETTINGS_ICON","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","__private_field","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","from","from","from","from","from","from","from","from","from","from","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","initialize","into","into","into","into","into","into","into","into","into","into","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","fetch","record","Stats","StatsPayload","StatsUnixTimestamp","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","config_fetches","config_fetches","confirms","confirms","deserialize","deserialize","fmt","fmt","fmt","from","from","from","from_stats","into","into","into","key","new","runners","serialize","serialize","solves","solves","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","unix_timestamp","vzip","vzip","vzip","fetch_config_fetched","fetch_confirm","fetch_solve","record_confirm","record_fetch","record_solve","INDEX_PAGE","IndexPage","PAGE","WIDGET_ROUTES","__private_field","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deref","from","from","from","initialize","into","into","into","new","register","render_once","render_once_to","routes","services","show_widget","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","vzip","vzip","vzip","Widget","borrow","borrow_mut","from","into","new","try_from","try_into","type_id","verification_widget","vzip"],"q":["mcaptcha","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api","mcaptcha::api::v1","","","","","","","","mcaptcha::api::v1::account","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::delete","","","","","","","","","","","","mcaptcha::api::v1::account::delete::runners","mcaptcha::api::v1::account::email","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::password","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::routes","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::secret","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::username","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::account::username::runners","mcaptcha::api::v1::auth","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::auth::routes","","","","","","","","","","","","","mcaptcha::api::v1::auth::runners","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha","","","","","mcaptcha::api::v1::mcaptcha::captcha","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::captcha::routes","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::duration","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::duration::routes","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::levels","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::mcaptcha::levels::routes","","","","","","","","","","","","","mcaptcha::api::v1::meta","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::meta::routes","","","","","","","","","","","","mcaptcha::api::v1::notifications","","","","","mcaptcha::api::v1::notifications::add","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::get","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::get::runner","mcaptcha::api::v1::notifications::mark_read","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::notifications::routes","","","","","","","","","","","","","mcaptcha::api::v1::pow","","","","","mcaptcha::api::v1::pow::get_config","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::pow::routes","","","","","","","","","","","","","","mcaptcha::api::v1::pow::verify_pow","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::pow::verify_token","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::api::v1::routes","","","","","","","","","","","","","","","","","","","mcaptcha::data","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::date","","","","","","","","","","","","","","","","","","","","","mcaptcha::demo","","","","","mcaptcha::docs","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::docs::routes","","","","","","","","","","","","","mcaptcha::email","mcaptcha::email::verification","","","","","","","","","","","","","","","","","","mcaptcha::errors","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::middleware","mcaptcha::middleware::auth","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages","","","","","","","mcaptcha::pages::auth","","","","","mcaptcha::pages::auth::login","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::auth::register","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::auth::routes","","","","","","","","","","","","","mcaptcha::pages::auth::sudo","","","","","","","","","","","","","","","","","","mcaptcha::pages::errors","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::errors::routes","","","","","","","","","","","","mcaptcha::pages::panel","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::routes","","","","","","","","","","","","","","","mcaptcha::pages::panel::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::settings::routes","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey","","","","","","","mcaptcha::pages::panel::sitekey::add","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::delete","","","","","","","","","","mcaptcha::pages::panel::sitekey::edit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::list","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::routes","","","","","","","","","","","","","","","","mcaptcha::pages::panel::sitekey::view","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::routes","","","","","","","","","","","","","","","","","","","","","","mcaptcha::pages::sitemap","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::routes","","","","","","","","","","","","","mcaptcha::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::static_assets","","","mcaptcha::static_assets::filemap","","","","","","","","","","","","mcaptcha::static_assets::static_files","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::static_assets::static_files::assets","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::stats","","mcaptcha::stats::fetch","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::stats::fetch::runners","","","mcaptcha::stats::record","","","mcaptcha::widget","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mcaptcha::widget::routes","","","","","","","","","",""],"d":["","","","","","","","","","App data","","","","","","","","","","","","","","","","","","points to source files matching build commit","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","mCaptcha system: Redis cache, etc.","","credential management configuration","App data: redis cache, database connections, etc.","","","databse pool","","Defines resoures for Methods","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","email client","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","User facing CAPTCHA widget","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","update email","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","update username","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","returns Ok(()) when everything checks out and the user is …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Builder for BuildDetails.","Error type for BuildDetailsBuilder","Health check return datatype","Builder for Health.","Error type for HealthBuilder","Uninitialized field","Uninitialized field","Custom validation error","Custom validation error","","","","","","","","","","","","","","","","","Builds a new BuildDetails.","Builds a new Health.","emmits build details of the bninary","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","checks all components of the system","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that adds a notification message","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that gets all unread notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that marks a notification read","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","PoW Verification module","PoW success token module","","","","","","","","","","","","get PoW configuration for an mcaptcha key","Call this when MCaptcha is not in master.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","validation token that clients receive as proof for …","","","","","","","","","","","","","","","","","","","","","","","route handler that verifies PoW and issues a solution …","","","","","","","","","","","","","","","","","","","","","","","","","","route hander that validates a PoW solution token","","","","","","","","","","","","","","","","","","","","","","App data","","Mailer data type AsyncSmtpTransport","","Represents mCaptcha cache and master system. When Redis …","","","","","","mCaptcha system: Redis cache, etc.","credential management configuration","databse pool","","","","","","","","email client","","create new instance of app data","","","","","","","","","","","","","","","","","","","","","","","print date","","","","","print relative time from date","","","","","","","Demo password","Demo username","","register demo user runner","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Email operations: verification, notification, etc","","","","","","","","","","","","","","","","","","","","","when the value passed contains blacklisted words see …","","","email is already taken","","","","","","","","","","","when the value passed contains profainity","","","","","when the a token name is already taken token not found","Unable to send email","when the value passed contains characters not present in …","","when the a username is already taken","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","notifications","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that renders individual views for sitekeys","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","utility function to get a list of all sitekeys that a …","","","render a list of all sitekeys that a user has","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","route handler that renders individual views for sitekeys","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","GET hander","","POST handler","Protected GET handler","Protected POST handler","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","featch PoWConfig confirms","","","","featch PoWConfig fetches","featch PoWConfig confirms","featch PoWConfig solves","record PoWConfig confirms","record PoWConfig fetches","record PoWConfig solves","","","","","","","","","","","","","","","","","","","","","","","","","","","widget services","render a client side widget for CAPTCHA verification","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,19,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,20,19,20,0,19,0,20,19,0,0,11,12,13,14,15,16,17,18,0,0,0,11,12,13,14,15,16,17,18,0,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,20,0,0,0,19,19,0,19,0,19,19,0,0,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,11,12,13,14,15,16,17,18,0,0,0,0,0,0,0,0,0,0,0,0,21,22,21,22,21,22,21,22,0,21,22,0,22,21,22,21,22,21,22,0,0,0,21,22,0,21,22,21,22,21,22,21,22,0,21,21,22,23,23,0,23,23,23,0,0,23,23,23,23,0,0,24,25,26,24,25,26,24,24,24,24,0,24,24,25,26,24,25,26,25,26,24,0,0,24,24,25,26,24,25,26,24,25,26,24,25,26,0,0,27,28,29,27,28,29,28,28,27,28,28,28,27,27,28,29,27,28,29,27,28,28,29,28,0,28,27,28,29,27,28,29,27,28,29,0,0,27,28,29,0,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,0,31,32,33,31,32,33,31,31,31,31,31,32,33,0,31,32,33,32,33,31,31,0,31,31,32,33,31,32,33,31,32,33,0,31,32,33,0,34,35,36,34,35,36,35,35,35,35,34,35,36,34,35,36,34,36,0,35,0,0,35,34,35,36,34,35,36,34,35,36,35,0,34,35,36,0,37,38,39,37,38,39,37,38,39,37,38,39,0,0,37,38,39,0,0,0,0,37,38,39,37,38,39,37,38,39,37,38,39,0,40,40,40,40,40,40,40,40,40,40,40,40,0,0,0,41,42,43,41,42,43,41,42,43,41,42,43,41,41,42,43,41,41,42,43,41,42,43,41,42,43,42,0,41,42,43,0,41,42,43,41,42,43,41,42,43,41,42,43,41,42,43,41,41,42,43,0,0,0,0,0,0,0,0,0,0,44,45,46,47,48,49,50,44,45,46,47,48,49,50,44,45,47,49,44,45,47,49,0,44,45,47,49,44,45,47,49,44,45,46,47,48,49,50,0,44,45,46,47,48,49,50,45,47,49,44,45,47,46,48,50,0,44,45,47,49,0,44,45,47,49,44,45,46,47,48,49,50,44,45,46,47,48,49,50,44,45,46,47,48,49,50,0,0,44,45,46,47,48,49,50,0,51,51,51,51,51,51,51,51,51,51,51,51,0,0,0,52,53,54,55,56,52,53,54,55,56,52,54,55,52,54,52,53,54,55,56,0,52,53,54,55,56,52,53,56,0,52,54,55,0,55,52,53,54,55,56,52,53,54,55,56,52,53,54,55,56,0,52,53,54,55,56,0,57,57,57,57,57,57,57,57,57,57,57,0,0,0,0,0,58,59,60,61,62,63,64,58,59,60,61,62,63,64,63,64,63,64,58,60,58,60,63,64,64,58,60,63,64,58,59,60,61,62,63,64,0,0,58,59,60,61,62,63,64,60,58,60,63,59,61,62,0,58,60,63,64,0,63,64,58,59,60,61,62,63,64,58,59,60,61,62,63,64,58,59,60,61,62,63,64,0,64,58,59,60,61,62,63,64,0,65,65,65,65,65,65,65,65,65,65,65,65,0,0,0,0,0,0,66,67,66,67,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,69,72,0,68,69,71,72,68,69,71,72,72,71,72,69,72,68,71,68,66,66,71,67,67,68,69,66,66,66,70,71,72,67,67,67,73,69,68,69,0,68,69,66,70,71,72,67,73,71,72,71,72,70,73,0,68,71,0,68,69,71,72,66,67,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,68,69,66,70,71,72,67,73,69,68,69,68,69,66,70,71,72,67,73,0,74,74,74,74,74,74,74,74,74,74,74,0,0,0,0,0,0,0,75,76,75,76,75,75,76,75,75,76,75,76,75,75,75,76,75,76,75,76,75,76,0,0,77,78,79,77,78,79,78,77,78,78,79,0,77,78,77,78,77,78,79,77,78,77,78,77,78,79,0,78,77,78,79,77,78,79,77,78,79,77,78,79,0,0,0,80,81,82,80,81,82,80,81,80,81,82,81,80,81,80,81,82,0,81,81,81,82,80,81,80,81,82,80,81,82,80,81,82,80,81,82,0,83,83,83,83,83,83,83,83,83,83,83,83,0,0,0,0,0,0,84,85,84,85,84,84,84,84,84,85,0,0,84,85,84,85,84,84,84,85,84,85,84,85,84,85,0,86,86,86,86,86,86,86,86,86,86,86,86,86,0,87,88,87,88,87,87,87,87,87,88,87,88,88,87,87,87,87,88,87,88,87,88,0,87,88,0,89,90,89,90,89,89,89,89,89,90,89,90,90,89,89,89,90,89,90,89,90,89,0,89,90,0,0,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,91,0,92,0,92,0,92,92,20,92,20,20,20,20,92,20,20,20,92,92,20,20,92,20,92,92,92,92,20,92,20,92,20,92,92,92,20,0,0,0,0,0,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,93,0,0,0,0,0,0,0,94,95,96,97,94,95,96,97,0,94,95,96,97,94,94,0,0,94,95,96,97,94,94,95,96,97,0,0,0,94,95,96,97,94,95,96,97,94,95,96,97,94,95,96,97,0,98,98,98,98,98,98,98,98,98,98,98,98,0,0,0,99,99,99,99,99,99,99,99,99,99,99,99,99,0,99,99,100,101,101,101,101,101,0,101,102,101,101,0,0,101,101,101,101,0,102,0,0,101,101,101,101,101,101,100,101,103,102,100,101,103,102,103,100,101,102,103,101,102,100,100,101,101,102,102,100,101,101,101,101,101,101,101,101,101,103,102,102,102,100,101,103,102,101,102,103,100,101,102,101,102,100,101,102,100,101,103,102,100,101,103,102,100,101,103,102,100,101,103,102,0,0,0,104,105,104,105,105,104,105,104,105,105,104,105,105,104,105,104,105,104,105,104,105,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,106,107,106,108,107,106,108,107,107,107,106,107,106,108,106,107,106,108,0,108,107,107,107,107,106,108,107,106,108,107,106,108,107,106,108,0,0,0,109,110,109,111,110,109,111,110,110,110,109,110,109,111,109,110,109,111,0,111,110,110,110,110,109,111,110,109,111,110,109,111,110,109,111,0,112,112,112,112,112,112,112,112,112,112,112,112,0,0,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,113,0,0,0,0,0,114,115,116,114,115,117,116,114,115,117,116,116,114,115,0,116,114,115,117,114,115,116,114,115,117,116,116,117,116,116,0,0,116,116,116,114,115,117,116,114,115,117,116,114,115,117,116,114,115,117,0,118,118,118,118,118,118,118,118,118,118,118,0,0,119,120,119,120,119,119,119,120,119,120,119,0,0,120,119,119,0,0,0,0,119,119,119,120,119,120,119,120,119,120,0,0,0,121,122,123,121,122,123,121,121,122,123,121,121,121,122,123,121,122,121,122,0,121,121,123,122,122,121,122,123,121,122,123,121,122,123,121,122,123,0,124,124,124,124,124,124,124,124,124,124,124,124,124,124,0,0,125,126,127,128,125,126,127,128,125,125,0,125,125,126,127,128,125,126,127,128,126,127,128,125,125,0,125,0,0,125,125,126,127,128,125,126,127,128,125,126,127,128,0,125,125,126,127,128,0,129,129,129,129,129,129,129,129,129,129,129,129,129,0,0,0,0,0,0,0,0,0,0,130,0,130,131,132,130,131,132,131,131,131,130,131,131,131,130,131,132,130,130,131,132,131,132,131,131,131,130,131,132,130,131,132,130,131,132,130,131,132,133,133,0,133,133,133,133,133,133,133,0,0,0,0,134,135,136,137,134,135,136,137,134,135,136,134,135,136,134,135,134,136,0,134,135,136,137,134,135,136,137,136,136,134,136,136,137,136,136,134,135,136,134,135,136,137,134,135,136,137,134,135,136,137,135,134,135,136,137,0,0,0,138,139,138,139,138,138,138,139,0,138,139,0,138,139,138,138,138,138,138,139,138,139,138,139,138,139,0,140,140,140,140,140,140,140,140,140,140,140,140,140,140,140,0,0,0,0,141,142,143,144,141,142,143,144,141,142,143,141,142,143,141,142,141,143,141,142,143,144,141,142,143,144,143,143,141,143,143,144,143,143,143,141,142,143,141,142,143,144,141,142,143,144,141,142,143,144,0,142,141,142,143,144,0,0,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,145,0,0,146,147,146,148,147,146,148,147,147,147,146,147,147,146,148,146,147,146,148,148,147,147,0,147,147,146,148,147,146,148,147,146,148,147,147,146,148,149,0,149,149,149,149,149,149,149,149,149,149,149,0,0,0,0,0,0,0,19,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,0,150,151,152,153,154,155,19,150,151,152,153,154,155,19,19,150,19,19,150,151,152,153,154,155,19,150,153,150,151,152,153,154,155,19,150,151,152,153,154,155,19,152,151,150,153,150,151,152,153,154,155,19,150,153,19,152,153,154,155,150,152,153,19,150,19,152,151,19,0,0,19,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,150,151,152,153,154,155,19,152,153,154,155,150,152,153,150,151,152,153,154,155,19,0,0,0,0,156,156,156,156,156,156,156,156,156,156,156,0,0,0,157,158,159,160,157,158,159,160,0,157,158,159,160,157,157,159,159,0,0,157,158,159,160,157,157,159,159,158,160,0,157,158,159,160,157,158,159,160,157,158,159,160,157,158,159,160,0,0,0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,0,0,0,0,0,161,162,163,161,162,163,161,162,163,161,162,163,161,162,161,162,161,163,161,162,163,161,162,163,161,161,162,163,163,162,0,161,163,161,162,161,162,163,161,162,163,161,162,163,161,162,163,161,161,162,163,0,0,0,0,0,0,0,0,0,0,164,165,164,166,165,164,166,165,165,164,165,164,166,164,165,164,166,165,166,165,165,0,0,0,165,165,164,166,165,164,166,165,164,166,165,164,166,0,167,167,167,167,167,167,167,167,167,167],"f":[null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,null,[[],["settings",3]],[[],["filemap",3]],[[]],[[]],[[]],[[]],[[]],[[],["string",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],[["identityservice",3,["cookieidentitypolicy"]],["cookieidentitypolicy",3]]],[[],["jsonconfig",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[],["result",6]],null,null,null,null,null,null,null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,[[["serviceconfig",3]]],null,null,[[]],[[]],[[]],[[]],[[],["accountcheckpayload",3]],[[],["accountcheckresp",3]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],null,null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],null,null,null,[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,[[]],[[]],[[["appservice",3]]],null,[[["serviceconfig",3]]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],[[["str",15],["appdata",6]]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["email",3]],[[]],[[],["result",4]],null,null,[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],[[],["result",4]],[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["changepasswordreqest",3]],[[]],null,null,[[],["result",4]],[[["formatter",3]],["result",6]],[[["changepasswordreqest",3]]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,[[["appservice",3]]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[["updatepassword",3],["str",15],["data",3]]],null,[[]],[[]],[[]],null,[[]],[[]],null,null,[[]],null,[[]],[[],["account",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,null,null,null,null,[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["secret",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[["serviceconfig",3]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["username",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[["accountcheckpayload",3],["appdata",6]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,null,[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],null,null,[[],["auth",3]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["register",3]],[[],["login",3]],[[],["password",3]],[[]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appdata",6],["login",3]]],null,null,null,[[["appdata",6],["register",3]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,null,[[["usize",15]],["string",3]],null,[[["serviceconfig",3]]],null,null,null,null,[[["u32",15],["identity",3],["str",15],["appdata",6]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaid",3]],[[],["mcaptchadetails",3]],[[],["deletecaptcha",3]],[[],["statspayload",3]],[[]],[[]],[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[["str",15],["appdata",6]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],[[]],[[],["mcaptcha",3]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,null,[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[],["duration",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["levels",3]],[[],["i32levels",3]],[[]],[[]],null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,null,null,[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["str",15],["appdata",6]]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[],["levels",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],[["result",4,["builddetails","builddetailsbuildererror"]],["builddetails",3],["builddetailsbuildererror",4]]],[[],[["health",3],["result",4,["health","healthbuildererror"]],["healthbuildererror",4]]],null,[[],["builddetails",3]],[[],["builddetailsbuilder",3]],[[],["health",3]],[[],["healthbuilder",3]],[[]],[[]],[[]],[[]],[[["bool",15]]],null,null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[["string",3]]],[[["uninitializedfielderror",3]]],[[]],[[]],[[]],[[]],[[["string",3]]],[[]],[[["uninitializedfielderror",3]]],[[]],[[["str",15]]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["option",4]],["bool",15]],[[["option",4,["bool"]],["bool",15]]],null,null,[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[["serviceconfig",3]]],[[]],[[]],[[]],[[]],[[],["string",3]],[[],["string",3]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[["str",15]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,[[["serviceconfig",3]]],null,null,[[]],[[]],[[]],[[]],[[],["result",4]],[[]],[[]],null,[[]],[[]],null,[[["appservice",3]]],[[],["result",4]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[]],[[]],[[["notification",3]]],[[]],null,null,null,null,null,[[]],[[]],[[]],null,null,null,null,null,null,[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[["str",15],["appdata",6]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],null,null,null,null,[[["appservice",3]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],null,[[],["notifications",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[["serviceconfig",3]]],null,null,null,[[]],[[]],[[]],[[]],[[],["getconfigpayload",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],null,[[["str",15],["appdata",6]]],[[]],[[]],null,[[["appservice",3]]],[[],["result",4]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,null,[[]],null,[[]],[[]],[[]],[[]],[[],["validationtoken",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],null,[[]],[[]],[[]],[[]],[[],["captchavalidateresp",3]],[[]],[[],["result",4]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],null,null,null,null,[[]],[[]],null,[[]],[[]],null,null,null,[[],["routes",3]],null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,[[["addsite",3]]],[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[],["config",3]],[[],[["option",4,["asyncsmtptransport"]],["asyncsmtptransport",3,["tokio1executor"]]]],[[["string",3]]],[[]],[[]],null,[[]],[[]],[[["addr",3],["mastertrait",8],["addr",3],["save",8]],[["save",8],["mastertrait",8],["system",3]]],[[["removecaptcha",3]]],[[["rename",3]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[["verifycaptcharesult",3]]],[[["work",3]]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[],["date",3]],[[]],[[],["string",3]],[[["formatter",3]],["result",6]],[[["offsetdatetime",3]],["string",3]],[[]],[[]],[[],["string",3]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[["appdata",6]]],[[["appdata",6]]],[[["appdata",6],["duration",3]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],["httpresponse",3]],null,[[]],[[]],[[]],[[]],[[]],[[],["filenames",4]],[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],null,[[["serviceconfig",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[]],null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[["str",15]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[["str",15],["data",3]]],null,[[]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["bool",15]],[[["serviceerror",4]],["bool",15]],[[["pageerror",4]],["bool",15]],null,[[],["httpresponse",3]],[[],["httpresponse",3]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[["validationerrors",3]],["serviceerror",4]],[[["credserror",4]],["serviceerror",4]],[[["mailboxerror",4]]],[[["smtperror",3]]],[[["recverror",3]]],[[]],[[["error",4]]],[[["captchaerror",4]],["serviceerror",4]],[[["parseerror",4]],["serviceerror",4]],[[]],[[]],[[["serviceerror",4]]],[[["error",4]]],[[]],[[]],[[]],[[]],[[["serviceerror",4]],["bool",15]],[[["pageerror",4]],["bool",15]],[[],["result",4]],[[],[["error",8],["option",4,["error"]]]],[[],[["error",8],["option",4,["error"]]]],[[],[["error",8],["option",4,["error"]]]],[[],["statuscode",3]],[[],["statuscode",3]],[[],["string",3]],[[],["string",3]],[[],["string",3]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[["servicerequest",3]]],[[]],[[]],[[]],[[]],[[]],[[]],[[["context",3]],[["poll",4,["result"]],["result",4]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],null,null,[[],["auth",3]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[]],[[]],[[],["sudopage",3]],[[]],null,[[]],[[]],[[["option",4,["vec"]],["vec",3],["str",15]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["errorpage",3]],[[]],[[],["string",3]],[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["str",15]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[]],[[]],[[["mcaptchadetails",3],["vec",3,["mcaptchadetails"]]]],null,null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[["serviceconfig",3]]],null,null,null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[["notification",3]]],[[]],[[]],[[]],null,null,[[]],[[]],[[]],null,null,null,[[["vec",3,["notification"]],["notification",3]]],null,[[],["string",3]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],null,[[]],[[]],null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[["appservice",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,[[]],[[]],null,[[]],[[]],null,[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,null,[[["serviceconfig",3]]],null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[["appservice",3]]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaconfig",3]],[[],["level",3]],[[],["indexpage",3]],[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["mcaptchaconfig",3],["level",3],["vec",3,["level"]],["string",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[]],[[["identity",3],["appdata",6]]],[[]],[[]],null,[[["mcaptchadetails",3],["vec",3,["mcaptchadetails"]]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],null,null,[[]],[[]],null,null,[[]],[[]],[[]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["mcaptchaconfig",3]],[[],["level",3]],[[],["indexpage",3]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[["stats",3],["level",3],["vec",3,["level"]],["mcaptchaconfig",3],["string",3]]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,[[]],[[]],[[]],[[]],null,null,null,null,[[]],[[]],null,null,[[]],[[]],null,[[]],[[],["routes",3]],null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[]],[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["config",3]]],[[],["server",3]],[[],["captcha",3]],[[],["smtp",3]],[[],["databasebuilder",3]],[[],["database",3]],[[],["redis",3]],[[],["settings",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["url",3]]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],[["result",4,["configerror"]],["configerror",4]]],null,null,null,null,null,null,null,null,null,null,null,null,null,[[["config",3]]],[[["config",3],["databasebuilder",3]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[["serviceconfig",3]]],null,null,[[]],[[]],null,[[]],[[["str",15]],[["str",15],["option",4,["str"]]]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],[["option",4,["embeddedfile"]],["embeddedfile",3]]],[[["str",15]],["httpresponse",3]],[[["str",15]],["httpresponse",3]],[[]],[[]],[[]],[[]],[[]],[[],["filenames",4]],[[],["filenames",4]],[[]],[[["appservice",3]]],[[["appservice",3]]],null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["statsunixtimestamp",3]],[[],["stats",3]],[[],["statspayload",3]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[["stats",3]]],[[]],[[]],[[]],null,[[["str",15],["pgpool",6]]],null,[[],["result",4]],[[],["result",4]],null,null,[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],[["vec",3,["i64"]],["i64",15]]],[[]],[[]],[[]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],[[["str",15],["pgpool",6]]],null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[],["indexpage",3]],[[]],[[],["string",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["appservice",3]]],[[],["renderresult",6]],[[["buffer",3]],[["result",4,["rendererror"]],["rendererror",4]]],null,[[["serviceconfig",3]]],null,[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[]],[[]],[[]],null,[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],null,[[]]],"p":[[3,"KEY"],[3,"GITHUB"],[3,"HOME"],[3,"SETTINGS_ICON"],[3,"CREDIT_CARD"],[3,"HELP_CIRCLE"],[3,"MESSAGE"],[3,"DOCS_ICON"],[3,"MCAPTCHA_TRANS_ICON"],[3,"BAR_CHART"],[3,"SETTINGS"],[3,"FILES"],[3,"JS"],[3,"CSS"],[3,"MOBILE_CSS"],[3,"VERIFICATIN_WIDGET_JS"],[3,"VERIFICATIN_WIDGET_CSS"],[3,"SOURCE_FILES_OF_INSTANCE"],[3,"Settings"],[3,"Data"],[3,"AccountCheckPayload"],[3,"AccountCheckResp"],[3,"delete_account"],[3,"Email"],[3,"email_exists"],[3,"set_email"],[3,"UpdatePassword"],[3,"ChangePasswordReqest"],[3,"update_user_password"],[3,"Account"],[3,"Secret"],[3,"get_secret"],[3,"update_user_secret"],[3,"username_exists"],[3,"Username"],[3,"set_username"],[3,"register"],[3,"login"],[3,"signout"],[3,"Auth"],[3,"Register"],[3,"Login"],[3,"Password"],[3,"MCaptchaID"],[3,"MCaptchaDetails"],[3,"update_token"],[3,"DeleteCaptcha"],[3,"delete_mcaptcha"],[3,"StatsPayload"],[3,"get_stats"],[3,"MCaptcha"],[3,"UpdateDuration"],[3,"update_duration"],[3,"GetDurationResp"],[3,"GetDuration"],[3,"get_duration"],[3,"Duration"],[3,"AddLevels"],[3,"add_levels"],[3,"UpdateLevels"],[3,"update_levels"],[3,"get_levels"],[3,"Levels"],[3,"I32Levels"],[3,"Levels"],[4,"BuildDetailsBuilderError"],[4,"HealthBuilderError"],[3,"BuildDetails"],[3,"BuildDetailsBuilder"],[3,"build_details"],[3,"Health"],[3,"HealthBuilder"],[3,"health"],[3,"Meta"],[3,"AddNotification"],[3,"add_notification"],[3,"Notification"],[3,"NotificationResp"],[3,"get_notification"],[3,"MarkReadReq"],[3,"NotificationResp"],[3,"mark_read"],[3,"Notifications"],[3,"GetConfigPayload"],[3,"get_config"],[3,"PoW"],[3,"ValidationToken"],[3,"verify_pow"],[3,"CaptchaValidateResp"],[3,"validate_captcha_token"],[3,"Routes"],[4,"SystemGroup"],[3,"Date"],[3,"Asset"],[3,"dist"],[3,"spec"],[3,"index"],[3,"Docs"],[3,"IndexPage"],[3,"SmtpErrorWrapper"],[4,"ServiceError"],[4,"PageError"],[3,"ErrorToResponse"],[3,"CheckLogin"],[3,"CheckLoginMiddleware"],[3,"INDEX"],[3,"IndexPage"],[3,"login"],[3,"INDEX"],[3,"IndexPage"],[3,"join"],[3,"Auth"],[3,"SudoPage"],[3,"INTERNAL_SERVER_ERROR_BODY"],[3,"UNKNOWN_ERROR_BODY"],[3,"ErrorPage"],[3,"error"],[3,"Errors"],[3,"IndexPage"],[3,"panel"],[3,"Notification"],[3,"IndexPage"],[3,"notifications"],[3,"Panel"],[3,"IndexPage"],[3,"settings"],[3,"delete_account"],[3,"update_secret"],[3,"Settings"],[3,"INDEX"],[3,"IndexPage"],[3,"add_sitekey"],[3,"delete_sitekey"],[3,"McaptchaConfig"],[3,"Level"],[3,"IndexPage"],[3,"edit_sitekey"],[3,"IndexPage"],[3,"list_sitekeys"],[3,"Sitekey"],[3,"McaptchaConfig"],[3,"Level"],[3,"IndexPage"],[3,"view_sitekey"],[3,"Routes"],[3,"INDEX"],[3,"IndexPage"],[3,"sitemap"],[4,"Methods"],[3,"Server"],[3,"Captcha"],[3,"Smtp"],[3,"DatabaseBuilder"],[3,"Database"],[3,"Redis"],[3,"FileMap"],[3,"Asset"],[3,"static_files"],[3,"Favicons"],[3,"favicons"],[3,"StatsUnixTimestamp"],[3,"Stats"],[3,"StatsPayload"],[3,"INDEX_PAGE"],[3,"IndexPage"],[3,"show_widget"],[3,"Widget"]]},\ +"mcaptcha_browser":{"doc":"mCaptcha is a proof of work based Denaial-of-Service …","t":[3,5,11,11,11,11,11,5,11,12,12,11,11,11,11],"n":["Work","__wasm_bindgen_generated_gen_pow","borrow","borrow_mut","deserialize","from","from","gen_pow","into","nonce","result","serialize","try_from","try_into","type_id"],"q":["mcaptcha_browser","","","","","","","","","","","","","",""],"d":["","generate proof-of-work","","","","","","generate proof-of-work","","","","","","",""],"i":[0,0,1,1,1,1,1,0,1,1,1,1,1,1,1],"f":[null,[[]],[[]],[[]],[[],["result",4]],[[]],[[["pow",3,["string"]],["string",3]]],[[["u32",15],["string",3]],["string",3]],[[]],null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]]],"p":[[3,"Work"]]},\ +"tests_migrate":{"doc":"","t":[3,3,12,12,12,11,11,5,5,12,12,12,11,11,11,11,5,12,12,12,0,12,12,11,11,11,11,3,3,3,3,3,3,3,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,5,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,11,11,11,11,11,11,11,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,11,12,11,11,11,11,11,11,11,12,12,11,12,12,12,12,12,12,12,12,12,12,12,12,12,5,5,12,12,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,11,11,11,11,11,11,11],"n":["SETTINGS","Settings","__private_field","allow_demo","allow_registration","borrow","borrow_mut","build","cache_bust","commercial","database","debug","deref","from","initialize","into","main","pow","redis","server","settings","smtp","source_code","try_from","try_into","type_id","vzip","Captcha","Database","DatabaseBuilder","Redis","Server","Settings","Smtp","allow_demo","allow_registration","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","check_url","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","commercial","cookie_secret","database","debug","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","domain","extract_database_url","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","gc","get_ip","hostname","into","into","into","into","into","into","into","ip","name","new","password","password","pool","pool","port","port","port","pow","proxy_has_tls","redis","reply","salt","server","set_database_url","set_from_database_url","smtp","source_code","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","url","url","url","url","url_prefix","username","username","vzip","vzip","vzip","vzip","vzip","vzip","vzip"],"q":["tests_migrate","","","","","","","","","","","","","","","","","","","","","","","","","","","tests_migrate::settings","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"d":["","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,1,2,2,1,1,0,0,2,2,2,1,1,1,1,0,2,2,2,0,2,2,1,1,1,1,0,0,0,0,0,0,0,2,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,0,3,4,5,6,7,8,2,3,4,5,6,7,8,2,2,3,2,2,3,4,5,6,7,8,2,3,6,3,4,5,6,7,8,2,3,4,5,6,7,8,2,5,4,3,6,3,4,5,6,7,8,2,3,6,2,5,6,7,8,3,5,6,2,3,2,5,4,2,0,0,2,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,3,4,5,6,7,8,2,5,6,7,8,3,5,6,3,4,5,6,7,8,2],"f":[null,null,null,null,null,[[]],[[]],[[]],[[]],null,null,null,[[],["settings",3]],[[]],[[]],[[]],[[]],null,null,null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[]],null,null,null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[["config",3]]],[[],["server",3]],[[],["captcha",3]],[[],["smtp",3]],[[],["databasebuilder",3]],[[],["database",3]],[[],["redis",3]],[[],["settings",3]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,null,null,[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],null,[[["url",3]]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[["formatter",3]],["result",6]],[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],["string",3]],null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],null,null,[[],[["result",4,["configerror"]],["configerror",4]]],null,null,null,null,null,null,null,null,null,null,null,null,null,[[["config",3]]],[[["databasebuilder",3],["config",3]]],null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["result",4]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],[[],["typeid",3]],null,null,null,null,null,null,null,[[]],[[]],[[]],[[]],[[]],[[]],[[]]],"p":[[3,"SETTINGS"],[3,"Settings"],[3,"Server"],[3,"Captcha"],[3,"Smtp"],[3,"DatabaseBuilder"],[3,"Database"],[3,"Redis"]]}\ }'); if (window.initSearch) {window.initSearch(searchIndex)}; \ No newline at end of file diff --git a/search.js b/search.js index af0714ee..91de2a15 100644 --- a/search.js +++ b/search.js @@ -1 +1 @@ -(function(){var itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias"];var TY_PRIMITIVE=itemTypes.indexOf("primitive");var TY_KEYWORD=itemTypes.indexOf("keyword");function printTab(nb){if(nb===0||nb===1||nb===2){searchState.currentTab=nb}var nb_copy=nb;onEachLazy(document.getElementById("titles").childNodes,function(elem){if(nb_copy===0){addClass(elem,"selected")}else{removeClass(elem,"selected")}nb_copy-=1});onEachLazy(document.getElementById("results").childNodes,function(elem){if(nb===0){addClass(elem,"active")}else{removeClass(elem,"active")}nb-=1})}function removeEmptyStringsFromArray(x){for(var i=0,len=x.length;i-1){var obj=searchIndex[results[i].id];obj.lev=results[i].lev;var res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}return out}function sortResults(results,isType){var ar=[];for(var entry in results){if(hasOwnPropertyRustdoc(results,entry)){ar.push(results[entry])}}results=ar;var i,len,result;for(i=0,len=results.length;ib?+1:-1)}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});for(i=0,len=results.length;i"));return{name:val.substring(0,val.indexOf("<")),generics:values.split(/\s*,\s*/),}}return{name:val,generics:[],}}function getObjectNameFromId(id){if(typeof id==="number"){return searchIndex[id].name}return id}function checkGenerics(obj,val){var tmp_lev,elem_name;if(val.generics.length>0){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=Object.create(null);var elength=obj[GENERICS_DATA].length;for(var x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=Object.create(null);len=obj[GENERICS_DATA].length;for(x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length!==0){var tmp_lev=checkGenerics(obj,val);if(tmp_lev<=MAX_LEV_DISTANCE){return tmp_lev}}else{return 0}}if(literalSearch){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){return obj[GENERICS_DATA].some(function(name){return name===val.name})}return false}lev_distance=Math.min(levenshtein(obj[NAME],val.name),lev_distance);if(lev_distance<=MAX_LEV_DISTANCE){lev_distance=Math.ceil((checkGenerics(obj,val)+lev_distance)/2)}else if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){var olength=obj[GENERICS_DATA].length;for(x=0;x0){var length=obj.type[INPUTS_DATA].length;for(var i=0;iOUTPUT_DATA){var ret=obj.type[OUTPUT_DATA];if(typeof ret[0]==="string"){ret=[ret]}for(var x=0,len=ret.length;xlength){return MAX_LEV_DISTANCE+1}for(var i=0;ilength){break}var lev_total=0;var aborted=false;for(var x=0;xMAX_LEV_DISTANCE){aborted=true;break}lev_total+=lev}if(!aborted){ret_lev=Math.min(ret_lev,Math.round(lev_total/clength))}}return ret_lev}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER)return true;if(filter===type)return true;var name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,}}function handleAliases(ret,query,filterCrates){var aliases=[];var crateAliases=[];if(filterCrates!==undefined){if(ALIASES[filterCrates]&&ALIASES[filterCrates][query.search]){var query_aliases=ALIASES[filterCrates][query.search];var len=query_aliases.length;for(var i=0;iMAX_RESULTS){ret.others.pop()}};onEach(aliases,pushFunc);onEach(crateAliases,pushFunc)}var nSearchWords=searchWords.length;var i,it;var ty;var fullId;var returned;var in_args;var len;if((val.charAt(0)==="\""||val.charAt(0)==="'")&&val.charAt(val.length-1)===val.charAt(0)){val=extractGenerics(val.substr(1,val.length-2));for(i=0;i")>-1){var trimmer=function(s){return s.trim()};var parts=val.split("->").map(trimmer);var input=parts[0];var inputs=input.split(",").map(trimmer).sort();for(i=0,len=inputs.length;i1?paths.length-1:1);var lev,j;for(j=0;j1){lev=checkPath(contains,paths[paths.length-1],ty);if(lev>MAX_LEV_DISTANCE){continue}else if(lev>0){lev_add=lev/10}}returned=MAX_LEV_DISTANCE+1;in_args=MAX_LEV_DISTANCE+1;var index=-1;lev=MAX_LEV_DISTANCE+1;fullId=ty.id;if(searchWords[j].indexOf(split[i])>-1||searchWords[j].indexOf(val)>-1||ty.normalizedName.indexOf(val)>-1){if(typePassesFilter(typeFilter,ty.ty)&&results[fullId]===undefined){index=ty.normalizedName.indexOf(val)}}if((lev=levenshtein(searchWords[j],val))<=MAX_LEV_DISTANCE){if(typePassesFilter(typeFilter,ty.ty)){lev+=1}else{lev=MAX_LEV_DISTANCE+1}}in_args=findArg(ty,valGenerics,false,typeFilter);returned=checkReturned(ty,valGenerics,false,typeFilter);lev+=lev_add;if(lev>0&&val.length>3&&searchWords[j].indexOf(val)>-1){if(val.length<6){lev-=1}else{lev=0}}if(in_args<=MAX_LEV_DISTANCE){if(results_in_args[fullId]===undefined){results_in_args[fullId]={id:j,index:index,lev:in_args,}}results_in_args[fullId].lev=Math.min(results_in_args[fullId].lev,in_args)}if(returned<=MAX_LEV_DISTANCE){if(results_returned[fullId]===undefined){results_returned[fullId]={id:j,index:index,lev:returned,}}results_returned[fullId].lev=Math.min(results_returned[fullId].lev,returned)}if(index!==-1||lev<=MAX_LEV_DISTANCE){if(index!==-1&&paths.length<2){lev=0}if(results[fullId]===undefined){results[fullId]={id:j,index:index,lev:lev,}}results[fullId].lev=Math.min(results[fullId].lev,lev)}}}var ret={"in_args":sortResults(results_in_args,true),"returned":sortResults(results_returned,true),"others":sortResults(results,false),};handleAliases(ret,query,filterCrates);return ret}function validateResult(name,path,keys,parent){for(var i=0,len=keys.length;i-1||path.indexOf(keys[i])>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(keys[i])>-1)||levenshtein(name,keys[i])<=MAX_LEV_DISTANCE)){return false}}return true}function getQuery(raw){var matches,type,query;query=raw;matches=query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);if(matches){type=matches[1].replace(/^const$/,"constant");query=query.substring(matches[0].length)}return{raw:raw,query:query,type:type,id:query+type}}function nextTab(direction){var next=(searchState.currentTab+direction+3)%searchState.focusedByTab.length;searchState.focusedByTab[searchState.currentTab]=document.activeElement;printTab(next);focusSearchResult()}function focusSearchResult(){var target=searchState.focusedByTab[searchState.currentTab]||document.querySelectorAll(".search-results.active a").item(0)||document.querySelectorAll("#titles > button").item(searchState.currentTab);if(target){target.focus()}}function buildHrefAndPath(item){var displayPath;var href;var type=itemTypes[item.ty];var name=item.name;var path=item.path;if(type==="mod"){displayPath=path+"::";href=window.rootPath+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="primitive"||type==="keyword"){displayPath="";href=window.rootPath+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=window.rootPath+name+"/index.html"}else if(item.parent!==undefined){var myparent=item.parent;var anchor="#"+type+"."+name;var parentType=itemTypes[myparent.ty];var pageType=parentType;var pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){var enumNameIdx=item.path.lastIndexOf("::");var enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=window.rootPath+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=window.rootPath+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function escape(content){var h1=document.createElement("h1");h1.textContent=content;return h1.innerHTML}function pathSplitter(path){var tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){var extraClass="";if(display===true){extraClass=" active"}var output=document.createElement("div");var duplicates={};var length=0;if(array.length>0){output.className="search-results "+extraClass;array.forEach(function(item){if(item.is_alias!==true){if(duplicates[item.fullPath]){return}duplicates[item.fullPath]=true}var name=item.name;var type=itemTypes[item.ty];length+=1;var extra="";if(type==="primitive"){extra=" (primitive type)"}else if(type==="keyword"){extra=" (keyword)"}var link=document.createElement("a");link.className="result-"+type;link.href=item.href;var wrapper=document.createElement("div");var resultName=document.createElement("div");resultName.className="result-name";if(item.is_alias){var alias=document.createElement("span");alias.className="alias";var bold=document.createElement("b");bold.innerText=item.alias;alias.appendChild(bold);alias.insertAdjacentHTML("beforeend"," - see ");resultName.appendChild(alias)}resultName.insertAdjacentHTML("beforeend",item.displayPath+""+name+extra+"");wrapper.appendChild(resultName);var description=document.createElement("div");description.className="desc";var spanDesc=document.createElement("span");spanDesc.insertAdjacentHTML("beforeend",item.desc);description.appendChild(spanDesc);wrapper.appendChild(description);link.appendChild(wrapper);output.appendChild(link)})}else{output.className="search-failed"+extraClass;output.innerHTML="No results :(
"+"Try on DuckDuckGo?

"+"Or try looking in one of these:"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){if(searchState.currentTab===tabNb){return""}return""}function showResults(results){var search=searchState.outputElement();if(results.others.length===1&&getSettingValue("go-to-only-result")==="true"&&(!search.firstChild||search.firstChild.innerText!==searchState.loadingText)){var elem=document.createElement("a");elem.href=results.others[0].href;removeClass(elem,"active");document.body.appendChild(elem);elem.click();return}var query=getQuery(searchState.input.value);currentResults=query.id;var ret_others=addTab(results.others,query);var ret_in_args=addTab(results.in_args,query,false);var ret_returned=addTab(results.returned,query,false);var currentTab=searchState.currentTab;if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}var output="

Results for "+escape(query.query)+(query.type?" (type: "+escape(query.type)+")":"")+"

"+"
"+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
";var resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;search.appendChild(resultsElem);searchState.focusedByTab=[null,null,null];searchState.showResults(search);var elems=document.getElementById("titles").childNodes;elems[0].onclick=function(){printTab(0)};elems[1].onclick=function(){printTab(1)};elems[2].onclick=function(){printTab(2)};printTab(currentTab)}function execSearch(query,searchWords,filterCrates){function getSmallest(arrays,positions,notDuplicates){var start=null;for(var it=0,len=positions.length;itpositions[it]&&(start===null||start>arrays[it][positions[it]].lev)&&!notDuplicates[arrays[it][positions[it]].fullPath]){start=arrays[it][positions[it]].lev}}return start}function mergeArrays(arrays){var ret=[];var positions=[];var notDuplicates={};for(var x=0,arrays_len=arrays.length;xpositions[x]&&arrays[x][positions[x]].lev===smallest&&!notDuplicates[arrays[x][positions[x]].fullPath]){ret.push(arrays[x][positions[x]]);notDuplicates[arrays[x][positions[x]].fullPath]=true;positions[x]+=1}}}return ret}var queries=query.raw.split(",");var results={"in_args":[],"returned":[],"others":[],};for(var i=0,len=queries.length;i1){return{"in_args":mergeArrays(results.in_args),"returned":mergeArrays(results.returned),"others":mergeArrays(results.others),}}return{"in_args":results.in_args[0],"returned":results.returned[0],"others":results.others[0],}}function getFilterCrates(){var elem=document.getElementById("crate-search");if(elem&&elem.value!=="All crates"&&hasOwnPropertyRustdoc(rawSearchIndex,elem.value)){return elem.value}return undefined}function search(e,forced){var params=searchState.getQueryStringParams();var query=getQuery(searchState.input.value.trim());if(e){e.preventDefault()}if(query.query.length===0){return}if(!forced&&query.id===currentResults){if(query.query.length>0){searchState.putBackSearch(searchState.input)}return}searchState.title="Results for "+query.query+" - Rust";if(searchState.browserSupportsHistoryApi()){var newURL=getNakedUrl()+"?search="+encodeURIComponent(query.raw)+window.location.hash;if(!history.state&&!params.search){history.pushState(query,"",newURL)}else{history.replaceState(query,"",newURL)}}var filterCrates=getFilterCrates();showResults(execSearch(query,index,filterCrates))}function buildIndex(rawSearchIndex){searchIndex=[];var searchWords=[];var i,word;var currentIndex=0;var id=0;for(var crate in rawSearchIndex){if(!hasOwnPropertyRustdoc(rawSearchIndex,crate)){continue}var crateSize=0;searchWords.push(crate);var crateRow={crate:crate,ty:1,name:crate,path:"",desc:rawSearchIndex[crate].doc,parent:undefined,type:null,id:id,normalizedName:crate.indexOf("_")===-1?crate:crate.replace(/_/g,""),};id+=1;searchIndex.push(crateRow);currentIndex+=1;var itemTypes=rawSearchIndex[crate].t;var itemNames=rawSearchIndex[crate].n;var itemPaths=rawSearchIndex[crate].q;var itemDescs=rawSearchIndex[crate].d;var itemParentIdxs=rawSearchIndex[crate].i;var itemFunctionSearchTypes=rawSearchIndex[crate].f;var paths=rawSearchIndex[crate].p;var aliases=rawSearchIndex[crate].a;var len=paths.length;for(i=0;i0?paths[itemParentIdxs[i]-1]:undefined,type:itemFunctionSearchTypes[i],id:id,normalizedName:word.indexOf("_")===-1?word:word.replace(/_/g,""),};id+=1;searchIndex.push(row);lastPath=row.path;crateSize+=1}if(aliases){ALIASES[crate]={};var j,local_aliases;for(var alias_name in aliases){if(!hasOwnPropertyRustdoc(aliases,alias_name)){continue}if(!hasOwnPropertyRustdoc(ALIASES[crate],alias_name)){ALIASES[crate][alias_name]=[]}local_aliases=aliases[alias_name];for(j=0,len=local_aliases.length;j0){searchState.input.value=params.search;search(e)}else{searchState.input.value="";searchState.hideResults()}})}window.onpageshow=function(){var qSearch=searchState.getQueryStringParams().search;if(searchState.input.value===""&&qSearch){searchState.input.value=qSearch}search()}}index=buildIndex(rawSearchIndex);registerSearchEvents();if(searchState.getQueryStringParams().search){search()}};if(window.searchIndex!==undefined){initSearch(window.searchIndex)}})() \ No newline at end of file +(function(){var itemTypes=["mod","externcrate","import","struct","enum","fn","type","static","trait","impl","tymethod","method","structfield","variant","macro","primitive","associatedtype","constant","associatedconstant","union","foreigntype","keyword","existential","attr","derive","traitalias"];var TY_PRIMITIVE=itemTypes.indexOf("primitive");var TY_KEYWORD=itemTypes.indexOf("keyword");function printTab(nb){if(nb===0||nb===1||nb===2){searchState.currentTab=nb}var nb_copy=nb;onEachLazy(document.getElementById("titles").childNodes,function(elem){if(nb_copy===0){addClass(elem,"selected")}else{removeClass(elem,"selected")}nb_copy-=1});onEachLazy(document.getElementById("results").childNodes,function(elem){if(nb===0){addClass(elem,"active")}else{removeClass(elem,"active")}nb-=1})}function removeEmptyStringsFromArray(x){for(var i=0,len=x.length;i-1){var obj=searchIndex[results[i].id];obj.lev=results[i].lev;var res=buildHrefAndPath(obj);obj.displayPath=pathSplitter(res[0]);obj.fullPath=obj.displayPath+obj.name;obj.fullPath+="|"+obj.ty;obj.href=res[1];out.push(obj);if(out.length>=MAX_RESULTS){break}}}return out}function sortResults(results,isType){var ar=[];for(var entry in results){if(hasOwnPropertyRustdoc(results,entry)){ar.push(results[entry])}}results=ar;var i,len,result;for(i=0,len=results.length;ib?+1:-1)}a=(aaa.index<0);b=(bbb.index<0);if(a!==b){return a-b}a=aaa.index;b=bbb.index;if(a!==b){return a-b}if((aaa.item.ty===TY_PRIMITIVE&&bbb.item.ty!==TY_KEYWORD)||(aaa.item.ty===TY_KEYWORD&&bbb.item.ty!==TY_PRIMITIVE)){return-1}if((bbb.item.ty===TY_PRIMITIVE&&aaa.item.ty!==TY_PRIMITIVE)||(bbb.item.ty===TY_KEYWORD&&aaa.item.ty!==TY_KEYWORD)){return 1}a=(aaa.item.desc==="");b=(bbb.item.desc==="");if(a!==b){return a-b}a=aaa.item.ty;b=bbb.item.ty;if(a!==b){return a-b}a=aaa.item.path;b=bbb.item.path;if(a!==b){return(a>b?+1:-1)}return 0});for(i=0,len=results.length;i"));return{name:val.substring(0,val.indexOf("<")),generics:values.split(/\s*,\s*/),}}return{name:val,generics:[],}}function checkGenerics(obj,val){var tmp_lev,elem_name;if(val.generics.length>0){if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>=val.generics.length){var elems=Object.create(null);var elength=obj[GENERICS_DATA].length;for(var x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length>0){var elems=Object.create(null);len=obj[GENERICS_DATA].length;for(x=0;xGENERICS_DATA&&obj[GENERICS_DATA].length!==0){var tmp_lev=checkGenerics(obj,val);if(tmp_lev<=MAX_LEV_DISTANCE){return tmp_lev}}}}else if(literalSearch){if((!val.generics||val.generics.length===0)&&obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){return obj[GENERICS_DATA].some(function(name){return name===val.name})}return false}lev_distance=Math.min(levenshtein(obj[NAME],val.name),lev_distance);if(lev_distance<=MAX_LEV_DISTANCE){lev_distance=Math.ceil((checkGenerics(obj,val)+lev_distance)/2)}else if(obj.length>GENERICS_DATA&&obj[GENERICS_DATA].length>0){var olength=obj[GENERICS_DATA].length;for(x=0;x0){var length=obj.type[INPUTS_DATA].length;for(var i=0;iOUTPUT_DATA){var ret=obj.type[OUTPUT_DATA];if(typeof ret[0]==="string"){ret=[ret]}for(var x=0,len=ret.length;xlength){return MAX_LEV_DISTANCE+1}for(var i=0;ilength){break}var lev_total=0;var aborted=false;for(var x=0;xMAX_LEV_DISTANCE){aborted=true;break}lev_total+=lev}if(!aborted){ret_lev=Math.min(ret_lev,Math.round(lev_total/clength))}}return ret_lev}function typePassesFilter(filter,type){if(filter<=NO_TYPE_FILTER)return true;if(filter===type)return true;var name=itemTypes[type];switch(itemTypes[filter]){case"constant":return name==="associatedconstant";case"fn":return name==="method"||name==="tymethod";case"type":return name==="primitive"||name==="associatedtype";case"trait":return name==="traitalias"}return false}function createAliasFromItem(item){return{crate:item.crate,name:item.name,path:item.path,desc:item.desc,ty:item.ty,parent:item.parent,type:item.type,is_alias:true,}}function handleAliases(ret,query,filterCrates){var aliases=[];var crateAliases=[];if(filterCrates!==undefined){if(ALIASES[filterCrates]&&ALIASES[filterCrates][query.search]){var query_aliases=ALIASES[filterCrates][query.search];var len=query_aliases.length;for(var i=0;iMAX_RESULTS){ret.others.pop()}};onEach(aliases,pushFunc);onEach(crateAliases,pushFunc)}var nSearchWords=searchWords.length;var i,it;var ty;var fullId;var returned;var in_args;var len;if((val.charAt(0)==="\""||val.charAt(0)==="'")&&val.charAt(val.length-1)===val.charAt(0)){val=extractGenerics(val.substr(1,val.length-2));for(i=0;i")>-1){var trimmer=function(s){return s.trim()};var parts=val.split("->").map(trimmer);var input=parts[0];var inputs=input.split(",").map(trimmer).sort();for(i=0,len=inputs.length;i1?paths.length-1:1);var lev,j;for(j=0;j1){lev=checkPath(contains,paths[paths.length-1],ty);if(lev>MAX_LEV_DISTANCE){continue}else if(lev>0){lev_add=lev/10}}returned=MAX_LEV_DISTANCE+1;in_args=MAX_LEV_DISTANCE+1;var index=-1;lev=MAX_LEV_DISTANCE+1;fullId=ty.id;if(searchWords[j].indexOf(split[i])>-1||searchWords[j].indexOf(val)>-1||ty.normalizedName.indexOf(val)>-1){if(typePassesFilter(typeFilter,ty.ty)&&results[fullId]===undefined){index=ty.normalizedName.indexOf(val)}}if((lev=levenshtein(searchWords[j],val))<=MAX_LEV_DISTANCE){if(typePassesFilter(typeFilter,ty.ty)){lev+=1}else{lev=MAX_LEV_DISTANCE+1}}in_args=findArg(ty,valGenerics,false,typeFilter);returned=checkReturned(ty,valGenerics,false,typeFilter);lev+=lev_add;if(lev>0&&val.length>3&&searchWords[j].indexOf(val)>-1){if(val.length<6){lev-=1}else{lev=0}}if(in_args<=MAX_LEV_DISTANCE){if(results_in_args[fullId]===undefined){results_in_args[fullId]={id:j,index:index,lev:in_args,}}results_in_args[fullId].lev=Math.min(results_in_args[fullId].lev,in_args)}if(returned<=MAX_LEV_DISTANCE){if(results_returned[fullId]===undefined){results_returned[fullId]={id:j,index:index,lev:returned,}}results_returned[fullId].lev=Math.min(results_returned[fullId].lev,returned)}if(typePassesFilter(typeFilter,ty.ty)&&(index!==-1||lev<=MAX_LEV_DISTANCE)){if(index!==-1&&paths.length<2){lev=0}if(results[fullId]===undefined){results[fullId]={id:j,index:index,lev:lev,}}results[fullId].lev=Math.min(results[fullId].lev,lev)}}}var ret={"in_args":sortResults(results_in_args,true),"returned":sortResults(results_returned,true),"others":sortResults(results,false),};handleAliases(ret,query,filterCrates);return ret}function validateResult(name,path,keys,parent){for(var i=0,len=keys.length;i-1||path.indexOf(keys[i])>-1||(parent!==undefined&&parent.name!==undefined&&parent.name.toLowerCase().indexOf(keys[i])>-1)||levenshtein(name,keys[i])<=MAX_LEV_DISTANCE)){return false}}return true}function getQuery(raw){var matches,type,query;query=raw;matches=query.match(/^(fn|mod|struct|enum|trait|type|const|macro)\s*:\s*/i);if(matches){type=matches[1].replace(/^const$/,"constant");query=query.substring(matches[0].length)}return{raw:raw,query:query,type:type,id:query+type}}function nextTab(direction){var next=(searchState.currentTab+direction+3)%searchState.focusedByTab.length;searchState.focusedByTab[searchState.currentTab]=document.activeElement;printTab(next);focusSearchResult()}function focusSearchResult(){var target=searchState.focusedByTab[searchState.currentTab]||document.querySelectorAll(".search-results.active a").item(0)||document.querySelectorAll("#titles > button").item(searchState.currentTab);if(target){target.focus()}}function buildHrefAndPath(item){var displayPath;var href;var type=itemTypes[item.ty];var name=item.name;var path=item.path;if(type==="mod"){displayPath=path+"::";href=window.rootPath+path.replace(/::/g,"/")+"/"+name+"/index.html"}else if(type==="primitive"||type==="keyword"){displayPath="";href=window.rootPath+path.replace(/::/g,"/")+"/"+type+"."+name+".html"}else if(type==="externcrate"){displayPath="";href=window.rootPath+name+"/index.html"}else if(item.parent!==undefined){var myparent=item.parent;var anchor="#"+type+"."+name;var parentType=itemTypes[myparent.ty];var pageType=parentType;var pageName=myparent.name;if(parentType==="primitive"){displayPath=myparent.name+"::"}else if(type==="structfield"&&parentType==="variant"){var enumNameIdx=item.path.lastIndexOf("::");var enumName=item.path.substr(enumNameIdx+2);path=item.path.substr(0,enumNameIdx);displayPath=path+"::"+enumName+"::"+myparent.name+"::";anchor="#variant."+myparent.name+".field."+name;pageType="enum";pageName=enumName}else{displayPath=path+"::"+myparent.name+"::"}href=window.rootPath+path.replace(/::/g,"/")+"/"+pageType+"."+pageName+".html"+anchor}else{displayPath=item.path+"::";href=window.rootPath+item.path.replace(/::/g,"/")+"/"+type+"."+name+".html"}return[displayPath,href]}function escape(content){var h1=document.createElement("h1");h1.textContent=content;return h1.innerHTML}function pathSplitter(path){var tmp=""+path.replace(/::/g,"::");if(tmp.endsWith("")){return tmp.slice(0,tmp.length-6)}return tmp}function addTab(array,query,display){var extraClass="";if(display===true){extraClass=" active"}var output=document.createElement("div");var duplicates={};var length=0;if(array.length>0){output.className="search-results "+extraClass;array.forEach(function(item){if(item.is_alias!==true){if(duplicates[item.fullPath]){return}duplicates[item.fullPath]=true}var name=item.name;var type=itemTypes[item.ty];length+=1;var extra="";if(type==="primitive"){extra=" (primitive type)"}else if(type==="keyword"){extra=" (keyword)"}var link=document.createElement("a");link.className="result-"+type;link.href=item.href;var wrapper=document.createElement("div");var resultName=document.createElement("div");resultName.className="result-name";if(item.is_alias){var alias=document.createElement("span");alias.className="alias";var bold=document.createElement("b");bold.innerText=item.alias;alias.appendChild(bold);alias.insertAdjacentHTML("beforeend"," - see ");resultName.appendChild(alias)}resultName.insertAdjacentHTML("beforeend",item.displayPath+""+name+extra+"");wrapper.appendChild(resultName);var description=document.createElement("div");description.className="desc";var spanDesc=document.createElement("span");spanDesc.insertAdjacentHTML("beforeend",item.desc);description.appendChild(spanDesc);wrapper.appendChild(description);link.appendChild(wrapper);output.appendChild(link)})}else{output.className="search-failed"+extraClass;output.innerHTML="No results :(
"+"Try on DuckDuckGo?

"+"Or try looking in one of these:"}return[output,length]}function makeTabHeader(tabNb,text,nbElems){if(searchState.currentTab===tabNb){return""}return""}function showResults(results,go_to_first){var search=searchState.outputElement();if(go_to_first||(results.others.length===1&&getSettingValue("go-to-only-result")==="true"&&(!search.firstChild||search.firstChild.innerText!==searchState.loadingText))){var elem=document.createElement("a");elem.href=results.others[0].href;removeClass(elem,"active");document.body.appendChild(elem);elem.click();return}var query=getQuery(searchState.input.value);currentResults=query.id;var ret_others=addTab(results.others,query);var ret_in_args=addTab(results.in_args,query,false);var ret_returned=addTab(results.returned,query,false);var currentTab=searchState.currentTab;if((currentTab===0&&ret_others[1]===0)||(currentTab===1&&ret_in_args[1]===0)||(currentTab===2&&ret_returned[1]===0)){if(ret_others[1]!==0){currentTab=0}else if(ret_in_args[1]!==0){currentTab=1}else if(ret_returned[1]!==0){currentTab=2}}var output="

Results for "+escape(query.query)+(query.type?" (type: "+escape(query.type)+")":"")+"

"+"
"+makeTabHeader(0,"In Names",ret_others[1])+makeTabHeader(1,"In Parameters",ret_in_args[1])+makeTabHeader(2,"In Return Types",ret_returned[1])+"
";var resultsElem=document.createElement("div");resultsElem.id="results";resultsElem.appendChild(ret_others[0]);resultsElem.appendChild(ret_in_args[0]);resultsElem.appendChild(ret_returned[0]);search.innerHTML=output;search.appendChild(resultsElem);searchState.focusedByTab=[null,null,null];searchState.showResults(search);var elems=document.getElementById("titles").childNodes;elems[0].onclick=function(){printTab(0)};elems[1].onclick=function(){printTab(1)};elems[2].onclick=function(){printTab(2)};printTab(currentTab)}function execSearch(query,searchWords,filterCrates){function getSmallest(arrays,positions,notDuplicates){var start=null;for(var it=0,len=positions.length;itpositions[it]&&(start===null||start>arrays[it][positions[it]].lev)&&!notDuplicates[arrays[it][positions[it]].fullPath]){start=arrays[it][positions[it]].lev}}return start}function mergeArrays(arrays){var ret=[];var positions=[];var notDuplicates={};for(var x=0,arrays_len=arrays.length;xpositions[x]&&arrays[x][positions[x]].lev===smallest&&!notDuplicates[arrays[x][positions[x]].fullPath]){ret.push(arrays[x][positions[x]]);notDuplicates[arrays[x][positions[x]].fullPath]=true;positions[x]+=1}}}return ret}function tokenizeQuery(raw){var i,matched;var l=raw.length;var depth=0;var nextAngle=/(<|>)/g;var ret=[];var start=0;for(i=0;i'){depth+=1}break;case">":if(depth>0){depth-=1}break;case",":if(depth===0){ret.push(raw.substring(start,i));start=i+1}break}}if(start!==i){ret.push(raw.substring(start,i))}return ret}var queries=tokenizeQuery(query.raw);var results={"in_args":[],"returned":[],"others":[],};for(var i=0,len=queries.length;i1){return{"in_args":mergeArrays(results.in_args),"returned":mergeArrays(results.returned),"others":mergeArrays(results.others),}}return{"in_args":results.in_args[0],"returned":results.returned[0],"others":results.others[0],}}function getFilterCrates(){var elem=document.getElementById("crate-search");if(elem&&elem.value!=="All crates"&&hasOwnPropertyRustdoc(rawSearchIndex,elem.value)){return elem.value}return undefined}function search(e,forced){var params=searchState.getQueryStringParams();var query=getQuery(searchState.input.value.trim());if(e){e.preventDefault()}if(query.query.length===0){return}if(!forced&&query.id===currentResults){if(query.query.length>0){searchState.putBackSearch(searchState.input)}return}searchState.title="Results for "+query.query+" - Rust";if(searchState.browserSupportsHistoryApi()){var newURL=getNakedUrl()+"?search="+encodeURIComponent(query.raw)+window.location.hash;if(!history.state&&!params.search){history.pushState(query,"",newURL)}else{history.replaceState(query,"",newURL)}}var filterCrates=getFilterCrates();showResults(execSearch(query,index,filterCrates),params.go_to_first)}function buildIndex(rawSearchIndex){searchIndex=[];var searchWords=[];var i,word;var currentIndex=0;var id=0;for(var crate in rawSearchIndex){if(!hasOwnPropertyRustdoc(rawSearchIndex,crate)){continue}var crateSize=0;searchWords.push(crate);var crateRow={crate:crate,ty:1,name:crate,path:"",desc:rawSearchIndex[crate].doc,parent:undefined,type:null,id:id,normalizedName:crate.indexOf("_")===-1?crate:crate.replace(/_/g,""),};id+=1;searchIndex.push(crateRow);currentIndex+=1;var itemTypes=rawSearchIndex[crate].t;var itemNames=rawSearchIndex[crate].n;var itemPaths=rawSearchIndex[crate].q;var itemDescs=rawSearchIndex[crate].d;var itemParentIdxs=rawSearchIndex[crate].i;var itemFunctionSearchTypes=rawSearchIndex[crate].f;var paths=rawSearchIndex[crate].p;var aliases=rawSearchIndex[crate].a;var len=paths.length;for(i=0;i0?paths[itemParentIdxs[i]-1]:undefined,type:itemFunctionSearchTypes[i],id:id,normalizedName:word.indexOf("_")===-1?word:word.replace(/_/g,""),};id+=1;searchIndex.push(row);lastPath=row.path;crateSize+=1}if(aliases){ALIASES[crate]={};var j,local_aliases;for(var alias_name in aliases){if(!hasOwnPropertyRustdoc(aliases,alias_name)){continue}if(!hasOwnPropertyRustdoc(ALIASES[crate],alias_name)){ALIASES[crate][alias_name]=[]}local_aliases=aliases[alias_name];for(j=0,len=local_aliases.length;j0){searchState.input.value=params.search;search(e)}else{searchState.input.value="";searchState.hideResults()}})}window.onpageshow=function(){var qSearch=searchState.getQueryStringParams().search;if(searchState.input.value===""&&qSearch){searchState.input.value=qSearch}search()}}index=buildIndex(rawSearchIndex);registerSearchEvents();if(searchState.getQueryStringParams().search){search()}};if(window.searchIndex!==undefined){initSearch(window.searchIndex)}})() \ No newline at end of file diff --git a/settings.html b/settings.html index d6cd08bf..6a4dda3b 100644 --- a/settings.html +++ b/settings.html @@ -1,4 +1,4 @@ -Rustdoc settings - -

Rustdoc settings

Theme preferences
Use system theme
Preferred dark theme
Preferred light theme
-
Auto-hide item contents for large items.
Auto-hide item methods' documentation
Auto-hide trait implementation documentation
Auto-hide implementors of a trait
Directly go to item in search if there is only one result
Show line numbers on code examples
Disable keyboard shortcuts
\ No newline at end of file +Rustdoc settings

Rustdoc settings

Theme preferences
Use system theme
Preferred dark theme
Preferred light theme
+
Auto-hide item contents for large items.
Auto-hide item methods' documentation
Auto-hide trait implementation documentation
Directly go to item in search if there is only one result
Show line numbers on code examples
Disable keyboard shortcuts
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/mod.rs.html b/src/mcaptcha/api/mod.rs.html index 010f8101..d8480327 100644 --- a/src/mcaptcha/api/mod.rs.html +++ b/src/mcaptcha/api/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -38,4 +36,6 @@
 
 pub mod v1;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/delete.rs.html b/src/mcaptcha/api/v1/account/delete.rs.html index 2c95cc2e..c1acf4b4 100644 --- a/src/mcaptcha/api/v1/account/delete.rs.html +++ b/src/mcaptcha/api/v1/account/delete.rs.html @@ -1,6 +1,4 @@ -delete.rs - source - -
 1
+delete.rs - source
 1
  2
  3
  4
@@ -154,4 +152,6 @@
     cfg.service(delete_account);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/email.rs.html b/src/mcaptcha/api/v1/account/email.rs.html index 2a4ebc7e..9e9e3176 100644 --- a/src/mcaptcha/api/v1/account/email.rs.html +++ b/src/mcaptcha/api/v1/account/email.rs.html @@ -1,6 +1,4 @@ -email.rs - source - -
 1
+email.rs - source
 1
  2
  3
  4
@@ -190,4 +188,6 @@
     cfg.service(set_email);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/mod.rs.html b/src/mcaptcha/api/v1/account/mod.rs.html index ad542946..d4857f89 100644 --- a/src/mcaptcha/api/v1/account/mod.rs.html +++ b/src/mcaptcha/api/v1/account/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -170,4 +168,6 @@
     password::services(cfg);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/password.rs.html b/src/mcaptcha/api/v1/account/password.rs.html index 1b34ddc8..d567eae5 100644 --- a/src/mcaptcha/api/v1/account/password.rs.html +++ b/src/mcaptcha/api/v1/account/password.rs.html @@ -1,6 +1,4 @@ -password.rs - source - -
  1
+password.rs - source
  1
   2
   3
   4
@@ -414,4 +412,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/secret.rs.html b/src/mcaptcha/api/v1/account/secret.rs.html index b9b6c98b..4e47dd27 100644 --- a/src/mcaptcha/api/v1/account/secret.rs.html +++ b/src/mcaptcha/api/v1/account/secret.rs.html @@ -1,6 +1,4 @@ -secret.rs - source - -
 1
+secret.rs - source
 1
  2
  3
  4
@@ -182,4 +180,6 @@
     cfg.service(update_user_secret);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/account/username.rs.html b/src/mcaptcha/api/v1/account/username.rs.html index 8a09ca55..1ad7a946 100644 --- a/src/mcaptcha/api/v1/account/username.rs.html +++ b/src/mcaptcha/api/v1/account/username.rs.html @@ -1,6 +1,4 @@ -username.rs - source - -
  1
+username.rs - source
  1
   2
   3
   4
@@ -222,4 +220,6 @@
     cfg.service(set_username);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/auth.rs.html b/src/mcaptcha/api/v1/auth.rs.html index 6d8c4704..e2affa09 100644 --- a/src/mcaptcha/api/v1/auth.rs.html +++ b/src/mcaptcha/api/v1/auth.rs.html @@ -1,6 +1,4 @@ -auth.rs - source - -
  1
+auth.rs - source
  1
   2
   3
   4
@@ -466,4 +464,6 @@
         .finish()
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/mcaptcha/captcha.rs.html b/src/mcaptcha/api/v1/mcaptcha/captcha.rs.html index a05f72df..329f6f23 100644 --- a/src/mcaptcha/api/v1/mcaptcha/captcha.rs.html +++ b/src/mcaptcha/api/v1/mcaptcha/captcha.rs.html @@ -1,6 +1,4 @@ -captcha.rs - source - -
  1
+captcha.rs - source
  1
   2
   3
   4
@@ -680,4 +678,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/mcaptcha/duration.rs.html b/src/mcaptcha/api/v1/mcaptcha/duration.rs.html index 2486f27d..eb2ddc51 100644 --- a/src/mcaptcha/api/v1/mcaptcha/duration.rs.html +++ b/src/mcaptcha/api/v1/mcaptcha/duration.rs.html @@ -1,6 +1,4 @@ -duration.rs - source - -
  1
+duration.rs - source
  1
   2
   3
   4
@@ -362,4 +360,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/mcaptcha/levels.rs.html b/src/mcaptcha/api/v1/mcaptcha/levels.rs.html index bd9c8b29..debe5e2e 100644 --- a/src/mcaptcha/api/v1/mcaptcha/levels.rs.html +++ b/src/mcaptcha/api/v1/mcaptcha/levels.rs.html @@ -1,6 +1,4 @@ -levels.rs - source - -
  1
+levels.rs - source
  1
   2
   3
   4
@@ -350,6 +348,14 @@
 348
 349
 350
+351
+352
+353
+354
+355
+356
+357
+358
 
 /*
  * Copyright (C) 2021  Aravinth Manivannan <realaravinth@batsense.net>
@@ -370,7 +376,7 @@
 use actix_identity::Identity;
 use actix_web::{web, HttpResponse, Responder};
 use futures::future::try_join_all;
-use libmcaptcha::{defense::Level, DefenseBuilder, master::messages::RemoveCaptcha};
+use libmcaptcha::{defense::Level, master::messages::RemoveCaptcha, DefenseBuilder};
 use log::debug;
 use serde::{Deserialize, Serialize};
 
@@ -543,8 +549,16 @@
     }
 
     try_join_all(futs).await?;
-    if let Err(ServiceError::CaptchaError(e)) =  data.captcha.remove(RemoveCaptcha(payload.key.clone())).await {
-        log::error!("Deleting captcha key {} while updating it, error: {:?}", &payload.key, e)
+    if let Err(ServiceError::CaptchaError(e)) = data
+        .captcha
+        .remove(RemoveCaptcha(payload.key.clone()))
+        .await
+    {
+        log::error!(
+            "Deleting captcha key {} while updating it, error: {:?}",
+            &payload.key,
+            e
+        )
     }
     Ok(HttpResponse::Ok())
 }
@@ -702,4 +716,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/mcaptcha/mod.rs.html b/src/mcaptcha/api/v1/mcaptcha/mod.rs.html index 8c5fb4c1..3b8cd921 100644 --- a/src/mcaptcha/api/v1/mcaptcha/mod.rs.html +++ b/src/mcaptcha/api/v1/mcaptcha/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -82,4 +80,6 @@
     captcha::services(cfg);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/meta.rs.html b/src/mcaptcha/api/v1/meta.rs.html index 3620b6a5..8933a464 100644 --- a/src/mcaptcha/api/v1/meta.rs.html +++ b/src/mcaptcha/api/v1/meta.rs.html @@ -1,6 +1,4 @@ -meta.rs - source - -
  1
+meta.rs - source
  1
   2
   3
   4
@@ -302,4 +300,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/mod.rs.html b/src/mcaptcha/api/v1/mod.rs.html index 7fccb1ce..87618504 100644 --- a/src/mcaptcha/api/v1/mod.rs.html +++ b/src/mcaptcha/api/v1/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -82,4 +80,6 @@
 #[cfg(test)]
 mod tests;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/notifications/add.rs.html b/src/mcaptcha/api/v1/notifications/add.rs.html index 7c362af2..f214a4af 100644 --- a/src/mcaptcha/api/v1/notifications/add.rs.html +++ b/src/mcaptcha/api/v1/notifications/add.rs.html @@ -1,6 +1,4 @@ -add.rs - source - -
  1
+add.rs - source
  1
   2
   3
   4
@@ -214,4 +212,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/notifications/get.rs.html b/src/mcaptcha/api/v1/notifications/get.rs.html index 200be234..48dcd37c 100644 --- a/src/mcaptcha/api/v1/notifications/get.rs.html +++ b/src/mcaptcha/api/v1/notifications/get.rs.html @@ -1,6 +1,4 @@ -get.rs - source - -
  1
+get.rs - source
  1
   2
   3
   4
@@ -332,4 +330,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/notifications/mark_read.rs.html b/src/mcaptcha/api/v1/notifications/mark_read.rs.html index c1c3f7b1..d9d131e1 100644 --- a/src/mcaptcha/api/v1/notifications/mark_read.rs.html +++ b/src/mcaptcha/api/v1/notifications/mark_read.rs.html @@ -1,6 +1,4 @@ -mark_read.rs - source - -
  1
+mark_read.rs - source
  1
   2
   3
   4
@@ -312,4 +310,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/notifications/mod.rs.html b/src/mcaptcha/api/v1/notifications/mod.rs.html index f7292944..b851021e 100644 --- a/src/mcaptcha/api/v1/notifications/mod.rs.html +++ b/src/mcaptcha/api/v1/notifications/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -92,4 +90,6 @@
     cfg.service(mark_read::mark_read);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/pow/get_config.rs.html b/src/mcaptcha/api/v1/pow/get_config.rs.html index 35cebcc7..db46de20 100644 --- a/src/mcaptcha/api/v1/pow/get_config.rs.html +++ b/src/mcaptcha/api/v1/pow/get_config.rs.html @@ -1,6 +1,4 @@ -get_config.rs - source - -
  1
+get_config.rs - source
  1
   2
   3
   4
@@ -404,4 +402,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/pow/mod.rs.html b/src/mcaptcha/api/v1/pow/mod.rs.html index 32867c0c..c2d8bd00 100644 --- a/src/mcaptcha/api/v1/pow/mod.rs.html +++ b/src/mcaptcha/api/v1/pow/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -190,4 +188,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/pow/verify_pow.rs.html b/src/mcaptcha/api/v1/pow/verify_pow.rs.html index 8e4941f0..0f7acce9 100644 --- a/src/mcaptcha/api/v1/pow/verify_pow.rs.html +++ b/src/mcaptcha/api/v1/pow/verify_pow.rs.html @@ -1,6 +1,4 @@ -verify_pow.rs - source - -
  1
+verify_pow.rs - source
  1
   2
   3
   4
@@ -276,4 +274,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/pow/verify_token.rs.html b/src/mcaptcha/api/v1/pow/verify_token.rs.html index ff8b0a68..5166f46b 100644 --- a/src/mcaptcha/api/v1/pow/verify_token.rs.html +++ b/src/mcaptcha/api/v1/pow/verify_token.rs.html @@ -1,6 +1,4 @@ -verify_token.rs - source - -
  1
+verify_token.rs - source
  1
   2
   3
   4
@@ -324,4 +322,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/api/v1/routes.rs.html b/src/mcaptcha/api/v1/routes.rs.html index 863535c5..a5a2c672 100644 --- a/src/mcaptcha/api/v1/routes.rs.html +++ b/src/mcaptcha/api/v1/routes.rs.html @@ -1,6 +1,4 @@ -routes.rs - source - -
 1
+routes.rs - source
 1
  2
  3
  4
@@ -108,4 +106,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/data.rs.html b/src/mcaptcha/data.rs.html index 2df933e8..9bb0e856 100644 --- a/src/mcaptcha/data.rs.html +++ b/src/mcaptcha/data.rs.html @@ -1,6 +1,4 @@ -data.rs - source - -
  1
+data.rs - source
  1
   2
   3
   4
@@ -446,4 +444,6 @@
 /// Mailer data type AsyncSmtpTransport<Tokio1Executor>
 pub type Mailer = AsyncSmtpTransport<Tokio1Executor>;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/date.rs.html b/src/mcaptcha/date.rs.html index ce468b47..c8ba3e31 100644 --- a/src/mcaptcha/date.rs.html +++ b/src/mcaptcha/date.rs.html @@ -1,6 +1,4 @@ -date.rs - source - -
  1
+date.rs - source
  1
   2
   3
   4
@@ -220,4 +218,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/demo.rs.html b/src/mcaptcha/demo.rs.html index d3d1bb19..d857c2cd 100644 --- a/src/mcaptcha/demo.rs.html +++ b/src/mcaptcha/demo.rs.html @@ -1,6 +1,4 @@ -demo.rs - source - -
  1
+demo.rs - source
  1
   2
   3
   4
@@ -292,4 +290,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/docs.rs.html b/src/mcaptcha/docs.rs.html index 53d89e49..646806ae 100644 --- a/src/mcaptcha/docs.rs.html +++ b/src/mcaptcha/docs.rs.html @@ -1,6 +1,4 @@ -docs.rs - source - -
  1
+docs.rs - source
  1
   2
   3
   4
@@ -264,4 +262,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/email/mod.rs.html b/src/mcaptcha/email/mod.rs.html index fac88194..7f8479f1 100644 --- a/src/mcaptcha/email/mod.rs.html +++ b/src/mcaptcha/email/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -38,4 +36,6 @@
 
 pub mod verification;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/email/verification.rs.html b/src/mcaptcha/email/verification.rs.html index 627a39d2..5cbcfe0d 100644 --- a/src/mcaptcha/email/verification.rs.html +++ b/src/mcaptcha/email/verification.rs.html @@ -1,6 +1,4 @@ -verification.rs - source - -
  1
+verification.rs - source
  1
   2
   3
   4
@@ -262,4 +260,6 @@ project website: {}",
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/errors.rs.html b/src/mcaptcha/errors.rs.html index 9c79e0fd..0c579669 100644 --- a/src/mcaptcha/errors.rs.html +++ b/src/mcaptcha/errors.rs.html @@ -1,6 +1,4 @@ -errors.rs - source - -
  1
+errors.rs - source
  1
   2
   3
   4
@@ -632,4 +630,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/main.rs.html b/src/mcaptcha/main.rs.html index e41d2776..cd213ce2 100644 --- a/src/mcaptcha/main.rs.html +++ b/src/mcaptcha/main.rs.html @@ -1,6 +1,4 @@ -main.rs - source - -
  1
+main.rs - source
  1
   2
   3
   4
@@ -376,4 +374,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/middleware/auth.rs.html b/src/mcaptcha/middleware/auth.rs.html index a8e2d8ef..59a6fdf8 100644 --- a/src/mcaptcha/middleware/auth.rs.html +++ b/src/mcaptcha/middleware/auth.rs.html @@ -1,6 +1,4 @@ -auth.rs - source - -
  1
+auth.rs - source
  1
   2
   3
   4
@@ -214,4 +212,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/middleware/mod.rs.html b/src/mcaptcha/middleware/mod.rs.html index bff14274..54c4ea9e 100644 --- a/src/mcaptcha/middleware/mod.rs.html +++ b/src/mcaptcha/middleware/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -38,4 +36,6 @@
 
 pub mod auth;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/auth/login.rs.html b/src/mcaptcha/pages/auth/login.rs.html index b1756cf7..f866f4de 100644 --- a/src/mcaptcha/pages/auth/login.rs.html +++ b/src/mcaptcha/pages/auth/login.rs.html @@ -1,6 +1,4 @@ -login.rs - source - -
 1
+login.rs - source
 1
  2
  3
  4
@@ -92,4 +90,6 @@
         .body(&*INDEX)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/auth/mod.rs.html b/src/mcaptcha/pages/auth/mod.rs.html index f7868138..d875055a 100644 --- a/src/mcaptcha/pages/auth/mod.rs.html +++ b/src/mcaptcha/pages/auth/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -92,4 +90,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/auth/register.rs.html b/src/mcaptcha/pages/auth/register.rs.html index c74d7b29..cb3d8d4f 100644 --- a/src/mcaptcha/pages/auth/register.rs.html +++ b/src/mcaptcha/pages/auth/register.rs.html @@ -1,6 +1,4 @@ -register.rs - source - -
 1
+register.rs - source
 1
  2
  3
  4
@@ -88,4 +86,6 @@
         .body(&*INDEX)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/auth/sudo.rs.html b/src/mcaptcha/pages/auth/sudo.rs.html index a9d22978..a9c957c2 100644 --- a/src/mcaptcha/pages/auth/sudo.rs.html +++ b/src/mcaptcha/pages/auth/sudo.rs.html @@ -1,6 +1,4 @@ -sudo.rs - source - -
 1
+sudo.rs - source
 1
  2
  3
  4
@@ -92,4 +90,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/errors.rs.html b/src/mcaptcha/pages/errors.rs.html index db9bf587..77415988 100644 --- a/src/mcaptcha/pages/errors.rs.html +++ b/src/mcaptcha/pages/errors.rs.html @@ -1,6 +1,4 @@ -errors.rs - source - -
  1
+errors.rs - source
  1
   2
   3
   4
@@ -238,4 +236,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/mod.rs.html b/src/mcaptcha/pages/mod.rs.html index 5ef145d4..731dbeaa 100644 --- a/src/mcaptcha/pages/mod.rs.html +++ b/src/mcaptcha/pages/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
  1
+mod.rs - source
  1
   2
   3
   4
@@ -220,4 +218,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/mod.rs.html b/src/mcaptcha/pages/panel/mod.rs.html index dbc73a52..9b50763c 100644 --- a/src/mcaptcha/pages/panel/mod.rs.html +++ b/src/mcaptcha/pages/panel/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -190,4 +188,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/notifications.rs.html b/src/mcaptcha/pages/panel/notifications.rs.html index 72412ea7..cd00eb71 100644 --- a/src/mcaptcha/pages/panel/notifications.rs.html +++ b/src/mcaptcha/pages/panel/notifications.rs.html @@ -1,6 +1,4 @@ -notifications.rs - source - -
  1
+notifications.rs - source
  1
   2
   3
   4
@@ -256,4 +254,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/settings.rs.html b/src/mcaptcha/pages/panel/settings.rs.html index bc54b021..9b3edd3e 100644 --- a/src/mcaptcha/pages/panel/settings.rs.html +++ b/src/mcaptcha/pages/panel/settings.rs.html @@ -1,6 +1,4 @@ -settings.rs - source - -
  1
+settings.rs - source
  1
   2
   3
   4
@@ -238,4 +236,6 @@
         .body(&page)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/add.rs.html b/src/mcaptcha/pages/panel/sitekey/add.rs.html index 1007dbf7..69313f9f 100644 --- a/src/mcaptcha/pages/panel/sitekey/add.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/add.rs.html @@ -1,6 +1,4 @@ -add.rs - source - -
 1
+add.rs - source
 1
  2
  3
  4
@@ -108,4 +106,6 @@
         .body(&*INDEX)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/delete.rs.html b/src/mcaptcha/pages/panel/sitekey/delete.rs.html index 2145cdba..bf2690c4 100644 --- a/src/mcaptcha/pages/panel/sitekey/delete.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/delete.rs.html @@ -1,6 +1,4 @@ -delete.rs - source - -
 1
+delete.rs - source
 1
  2
  3
  4
@@ -72,4 +70,6 @@
         .body(&page)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/edit.rs.html b/src/mcaptcha/pages/panel/sitekey/edit.rs.html index f134cb1b..5ec0611b 100644 --- a/src/mcaptcha/pages/panel/sitekey/edit.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/edit.rs.html @@ -1,6 +1,4 @@ -edit.rs - source - -
  1
+edit.rs - source
  1
   2
   3
   4
@@ -296,4 +294,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/list.rs.html b/src/mcaptcha/pages/panel/sitekey/list.rs.html index 3b82e400..517b8835 100644 --- a/src/mcaptcha/pages/panel/sitekey/list.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/list.rs.html @@ -1,6 +1,4 @@ -list.rs - source - -
  1
+list.rs - source
  1
   2
   3
   4
@@ -236,4 +234,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/mod.rs.html b/src/mcaptcha/pages/panel/sitekey/mod.rs.html index 2ce458e1..03804982 100644 --- a/src/mcaptcha/pages/panel/sitekey/mod.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -114,4 +112,6 @@
     cfg.service(delete::delete_sitekey);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/panel/sitekey/view.rs.html b/src/mcaptcha/pages/panel/sitekey/view.rs.html index 7d529764..e2b40365 100644 --- a/src/mcaptcha/pages/panel/sitekey/view.rs.html +++ b/src/mcaptcha/pages/panel/sitekey/view.rs.html @@ -1,6 +1,4 @@ -view.rs - source - -
  1
+view.rs - source
  1
   2
   3
   4
@@ -322,4 +320,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/routes.rs.html b/src/mcaptcha/pages/routes.rs.html index bdcc47fd..cb2fbadc 100644 --- a/src/mcaptcha/pages/routes.rs.html +++ b/src/mcaptcha/pages/routes.rs.html @@ -1,6 +1,4 @@ -routes.rs - source - -
 1
+routes.rs - source
 1
  2
  3
  4
@@ -140,4 +138,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/pages/sitemap.rs.html b/src/mcaptcha/pages/sitemap.rs.html index 9e5df502..526522c1 100644 --- a/src/mcaptcha/pages/sitemap.rs.html +++ b/src/mcaptcha/pages/sitemap.rs.html @@ -1,6 +1,4 @@ -sitemap.rs - source - -
 1
+sitemap.rs - source
 1
  2
  3
  4
@@ -110,4 +108,6 @@
         .body(&*INDEX)
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/routes.rs.html b/src/mcaptcha/routes.rs.html index 1f0a01aa..41d05f09 100644 --- a/src/mcaptcha/routes.rs.html +++ b/src/mcaptcha/routes.rs.html @@ -1,6 +1,4 @@ -routes.rs - source - -
 1
+routes.rs - source
 1
  2
  3
  4
@@ -134,4 +132,6 @@
     };
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/settings.rs.html b/src/mcaptcha/settings.rs.html index b44769c2..c4f2a30e 100644 --- a/src/mcaptcha/settings.rs.html +++ b/src/mcaptcha/settings.rs.html @@ -1,6 +1,4 @@ -settings.rs - source - -
  1
+settings.rs - source
  1
   2
   3
   4
@@ -464,4 +462,6 @@
 //    }
 //}
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/static_assets/filemap.rs.html b/src/mcaptcha/static_assets/filemap.rs.html index 0086bf52..d207ee7e 100644 --- a/src/mcaptcha/static_assets/filemap.rs.html +++ b/src/mcaptcha/static_assets/filemap.rs.html @@ -1,6 +1,4 @@ -filemap.rs - source - -
 1
+filemap.rs - source
 1
  2
  3
  4
@@ -94,4 +92,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/static_assets/mod.rs.html b/src/mcaptcha/static_assets/mod.rs.html index 39973177..2f1ac644 100644 --- a/src/mcaptcha/static_assets/mod.rs.html +++ b/src/mcaptcha/static_assets/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -52,4 +50,6 @@
     cfg.service(static_files::favicons);
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/static_assets/static_files.rs.html b/src/mcaptcha/static_assets/static_files.rs.html index 467f04fc..4295939f 100644 --- a/src/mcaptcha/static_assets/static_files.rs.html +++ b/src/mcaptcha/static_assets/static_files.rs.html @@ -1,6 +1,4 @@ -static_files.rs - source - -
  1
+static_files.rs - source
  1
   2
   3
   4
@@ -410,4 +408,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/stats/fetch.rs.html b/src/mcaptcha/stats/fetch.rs.html index 68e7bfd4..b082d353 100644 --- a/src/mcaptcha/stats/fetch.rs.html +++ b/src/mcaptcha/stats/fetch.rs.html @@ -1,6 +1,4 @@ -fetch.rs - source - -
  1
+fetch.rs - source
  1
   2
   3
   4
@@ -440,4 +438,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/stats/mod.rs.html b/src/mcaptcha/stats/mod.rs.html index 96cac9ca..7f60c22f 100644 --- a/src/mcaptcha/stats/mod.rs.html +++ b/src/mcaptcha/stats/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -40,4 +38,6 @@
 pub mod fetch;
 pub mod record;
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/stats/record.rs.html b/src/mcaptcha/stats/record.rs.html index 05e05277..3a6daac4 100644 --- a/src/mcaptcha/stats/record.rs.html +++ b/src/mcaptcha/stats/record.rs.html @@ -1,6 +1,4 @@ -record.rs - source - -
 1
+record.rs - source
 1
  2
  3
  4
@@ -124,4 +122,6 @@
     .await;
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha/widget/mod.rs.html b/src/mcaptcha/widget/mod.rs.html index 856b503c..dc23803a 100644 --- a/src/mcaptcha/widget/mod.rs.html +++ b/src/mcaptcha/widget/mod.rs.html @@ -1,6 +1,4 @@ -mod.rs - source - -
 1
+mod.rs - source
 1
  2
  3
  4
@@ -164,4 +162,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/mcaptcha_browser/lib.rs.html b/src/mcaptcha_browser/lib.rs.html index a1edce17..85ea3c5e 100644 --- a/src/mcaptcha_browser/lib.rs.html +++ b/src/mcaptcha_browser/lib.rs.html @@ -1,6 +1,4 @@ -lib.rs - source - -
  1
+lib.rs - source
  1
   2
   3
   4
@@ -304,4 +302,6 @@
     }
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/tests_migrate/settings.rs.html b/src/tests_migrate/settings.rs.html index a61d53ac..dd2dbc40 100644 --- a/src/tests_migrate/settings.rs.html +++ b/src/tests_migrate/settings.rs.html @@ -1,6 +1,4 @@ -settings.rs - source - -
  1
+settings.rs - source
  1
   2
   3
   4
@@ -464,4 +462,6 @@
 //    }
 //}
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/src/tests_migrate/tests-migrate.rs.html b/src/tests_migrate/tests-migrate.rs.html index 6cada24b..2d1e9041 100644 --- a/src/tests_migrate/tests-migrate.rs.html +++ b/src/tests_migrate/tests-migrate.rs.html @@ -1,6 +1,4 @@ -tests-migrate.rs - source - -
 1
+tests-migrate.rs - source
 1
  2
  3
  4
@@ -186,4 +184,6 @@
     config.process().unwrap();
 }
 

-

\ No newline at end of file
+
+ + \ No newline at end of file diff --git a/tests_migrate/all.html b/tests_migrate/all.html index dc226f71..ea6248de 100644 --- a/tests_migrate/all.html +++ b/tests_migrate/all.html @@ -1,5 +1,5 @@ -List of all items in this crate - -

List of all items[−] +List of all items in this crate

List of all items[−] -

Structs

Functions

\ No newline at end of file +

Structs

Functions

+ + \ No newline at end of file diff --git a/tests_migrate/fn.build.html b/tests_migrate/fn.build.html index 850b0908..f3e6dd56 100644 --- a/tests_migrate/fn.build.html +++ b/tests_migrate/fn.build.html @@ -1,3 +1,3 @@ -build in tests_migrate - Rust - -

Function tests_migrate::build[−][src]

pub(crate) fn build()
\ No newline at end of file +build in tests_migrate - Rust

Function tests_migrate::build[−][src]

pub(crate) fn build()
+ + \ No newline at end of file diff --git a/tests_migrate/fn.cache_bust.html b/tests_migrate/fn.cache_bust.html index 6a51c6d7..01dc5403 100644 --- a/tests_migrate/fn.cache_bust.html +++ b/tests_migrate/fn.cache_bust.html @@ -1,3 +1,3 @@ -cache_bust in tests_migrate - Rust - -

Function tests_migrate::cache_bust[−][src]

pub(crate) fn cache_bust()
\ No newline at end of file +cache_bust in tests_migrate - Rust

Function tests_migrate::cache_bust[−][src]

pub(crate) fn cache_bust()
+ + \ No newline at end of file diff --git a/tests_migrate/fn.main.html b/tests_migrate/fn.main.html index 2b21e6fc..71e8274b 100644 --- a/tests_migrate/fn.main.html +++ b/tests_migrate/fn.main.html @@ -1,3 +1,3 @@ -main in tests_migrate - Rust - -

Function tests_migrate::main[−][src]

pub(crate) fn main()
\ No newline at end of file +main in tests_migrate - Rust

Function tests_migrate::main[−][src]

pub(crate) fn main()
+ + \ No newline at end of file diff --git a/tests_migrate/index.html b/tests_migrate/index.html index 4e087b60..57699660 100644 --- a/tests_migrate/index.html +++ b/tests_migrate/index.html @@ -1,6 +1,6 @@ -tests_migrate - Rust - -

Crate tests_migrate[−][src]

Modules

-
settings

Structs

-
SETTINGS
Settings

Functions

-
build
cache_bust
main
\ No newline at end of file +tests_migrate - Rust

Crate tests_migrate[−][src]

Modules

+
settings

Structs

+
SETTINGS
Settings

Functions

+
build
cache_bust
main
+ + \ No newline at end of file diff --git a/tests_migrate/settings/fn.check_url.html b/tests_migrate/settings/fn.check_url.html index e2153d81..60588ef4 100644 --- a/tests_migrate/settings/fn.check_url.html +++ b/tests_migrate/settings/fn.check_url.html @@ -1,3 +1,3 @@ -check_url in tests_migrate::settings - Rust - -

Function tests_migrate::settings::check_url[−][src]

fn check_url(s: &Config)
\ No newline at end of file +check_url in tests_migrate::settings - Rust

Function tests_migrate::settings::check_url[−][src]

fn check_url(s: &Config)
+ + \ No newline at end of file diff --git a/tests_migrate/settings/fn.set_database_url.html b/tests_migrate/settings/fn.set_database_url.html index 6a6975f4..cf6ee929 100644 --- a/tests_migrate/settings/fn.set_database_url.html +++ b/tests_migrate/settings/fn.set_database_url.html @@ -1,3 +1,3 @@ -set_database_url in tests_migrate::settings - Rust - -

Function tests_migrate::settings::set_database_url[−][src]

fn set_database_url(s: &mut Config)
\ No newline at end of file +set_database_url in tests_migrate::settings - Rust

Function tests_migrate::settings::set_database_url[−][src]

fn set_database_url(s: &mut Config)
+ + \ No newline at end of file diff --git a/tests_migrate/settings/fn.set_from_database_url.html b/tests_migrate/settings/fn.set_from_database_url.html index 3613b6de..71076d99 100644 --- a/tests_migrate/settings/fn.set_from_database_url.html +++ b/tests_migrate/settings/fn.set_from_database_url.html @@ -1,3 +1,3 @@ -set_from_database_url in tests_migrate::settings - Rust - -

Function tests_migrate::settings::set_from_database_url[−][src]

fn set_from_database_url(s: &mut Config, database_conf: &DatabaseBuilder)
\ No newline at end of file +set_from_database_url in tests_migrate::settings - Rust

Function tests_migrate::settings::set_from_database_url[−][src]

fn set_from_database_url(s: &mut Config, database_conf: &DatabaseBuilder)
+ + \ No newline at end of file diff --git a/tests_migrate/settings/index.html b/tests_migrate/settings/index.html index 991c1b83..e0085f67 100644 --- a/tests_migrate/settings/index.html +++ b/tests_migrate/settings/index.html @@ -1,5 +1,5 @@ -tests_migrate::settings - Rust - -

Module tests_migrate::settings[−][src]

Structs

-
Captcha
Database
DatabaseBuilder
Redis
Server
Settings
Smtp

Functions

-
check_url
set_database_url
set_from_database_url
\ No newline at end of file +tests_migrate::settings - Rust

Module tests_migrate::settings[−][src]

Structs

+
Captcha
Database
DatabaseBuilder
Redis
Server
Settings
Smtp

Functions

+
check_url
set_database_url
set_from_database_url
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Captcha.html b/tests_migrate/settings/struct.Captcha.html index 53d300b3..1f964708 100644 --- a/tests_migrate/settings/struct.Captcha.html +++ b/tests_migrate/settings/struct.Captcha.html @@ -1,118 +1,117 @@ -Captcha in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Captcha[−][src]

pub struct Captcha {
-    pub salt: String,
-    pub gc: u64,
-}

- Fields

salt: Stringgc: u64

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Captcha in tests_migrate::settings - Rust

Struct tests_migrate::settings::Captcha[−][src]

pub struct Captcha {
+    pub salt: String,
+    pub gc: u64,
+}

Fields

salt: Stringgc: u64

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Database.html b/tests_migrate/settings/struct.Database.html index d6c824bc..2a1eaf5d 100644 --- a/tests_migrate/settings/struct.Database.html +++ b/tests_migrate/settings/struct.Database.html @@ -1,118 +1,117 @@ -Database in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Database[−][src]

pub struct Database {
-    pub url: String,
-    pub pool: u32,
-}

- Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Database in tests_migrate::settings - Rust

Struct tests_migrate::settings::Database[−][src]

pub struct Database {
+    pub url: String,
+    pub pool: u32,
+}

Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.DatabaseBuilder.html b/tests_migrate/settings/struct.DatabaseBuilder.html index 2831c59c..07a9eab1 100644 --- a/tests_migrate/settings/struct.DatabaseBuilder.html +++ b/tests_migrate/settings/struct.DatabaseBuilder.html @@ -1,122 +1,121 @@ -DatabaseBuilder in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::DatabaseBuilder[−][src]

struct DatabaseBuilder {
-    pub port: u32,
-    pub hostname: String,
-    pub username: String,
-    pub password: String,
-    pub name: String,
-    pub url: String,
-}

- Fields

port: u32hostname: Stringusername: Stringpassword: Stringname: Stringurl: String

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +DatabaseBuilder in tests_migrate::settings - Rust

Struct tests_migrate::settings::DatabaseBuilder[−][src]

struct DatabaseBuilder {
+    pub port: u32,
+    pub hostname: String,
+    pub username: String,
+    pub password: String,
+    pub name: String,
+    pub url: String,
+}

Fields

port: u32hostname: Stringusername: Stringpassword: Stringname: Stringurl: String

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Redis.html b/tests_migrate/settings/struct.Redis.html index e07cf165..36c0d165 100644 --- a/tests_migrate/settings/struct.Redis.html +++ b/tests_migrate/settings/struct.Redis.html @@ -1,118 +1,117 @@ -Redis in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Redis[−][src]

pub struct Redis {
-    pub url: String,
-    pub pool: u32,
-}

- Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Redis in tests_migrate::settings - Rust

Struct tests_migrate::settings::Redis[−][src]

pub struct Redis {
+    pub url: String,
+    pub pool: u32,
+}

Fields

url: Stringpool: u32

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Server.html b/tests_migrate/settings/struct.Server.html index a1832fa5..ee9e5887 100644 --- a/tests_migrate/settings/struct.Server.html +++ b/tests_migrate/settings/struct.Server.html @@ -1,122 +1,121 @@ -Server in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Server[−][src]

pub struct Server {
-    pub port: u32,
-    pub domain: String,
-    pub cookie_secret: String,
-    pub ip: String,
-    pub url_prefix: Option<String>,
-    pub proxy_has_tls: bool,
-}

- Fields

port: u32domain: Stringcookie_secret: Stringip: Stringurl_prefix: Option<String>proxy_has_tls: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Server in tests_migrate::settings - Rust

Struct tests_migrate::settings::Server[−][src]

pub struct Server {
+    pub port: u32,
+    pub domain: String,
+    pub cookie_secret: String,
+    pub ip: String,
+    pub url_prefix: Option<String>,
+    pub proxy_has_tls: bool,
+}

Fields

port: u32domain: Stringcookie_secret: Stringip: Stringurl_prefix: Option<String>proxy_has_tls: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Settings.html b/tests_migrate/settings/struct.Settings.html index 4307ebc7..8f79cc86 100644 --- a/tests_migrate/settings/struct.Settings.html +++ b/tests_migrate/settings/struct.Settings.html @@ -1,126 +1,125 @@ -Settings in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Settings[−][src]

pub struct Settings {
-    pub debug: bool,
-    pub commercial: bool,
+Settings in tests_migrate::settings - Rust
Struct tests_migrate::settings::Settings[−][src]
pub struct Settings {
+    pub debug: bool,
+    pub commercial: bool,
     pub database: Database,
-    pub redis: Option<Redis>,
+    pub redis: Option<Redis>,
     pub server: Server,
     pub pow: Captcha,
-    pub source_code: String,
-    pub smtp: Option<Smtp>,
-    pub allow_registration: bool,
-    pub allow_demo: bool,
-}

-                       Fields
debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub source_code: String,
+    pub smtp: Option<Smtp>,
+    pub allow_registration: bool,
+    pub allow_demo: bool,
+}

Fields

debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/settings/struct.Smtp.html b/tests_migrate/settings/struct.Smtp.html index 11610b2d..2e8effeb 100644 --- a/tests_migrate/settings/struct.Smtp.html +++ b/tests_migrate/settings/struct.Smtp.html @@ -1,122 +1,121 @@ -Smtp in tests_migrate::settings - Rust - -

Struct tests_migrate::settings::Smtp[−][src]

pub struct Smtp {
-    pub from: String,
-    pub reply: String,
-    pub url: String,
-    pub username: String,
-    pub password: String,
-    pub port: u16,
-}

- Fields

from: Stringreply: Stringurl: Stringusername: Stringpassword: Stringport: u16

Trait Implementations

Returns a copy of the value. Read more

-

Performs copy-assignment from source. Read more

-

Formats the value using the given formatter. Read more

-

Deserialize this value from the given Serde deserializer. Read more

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +Smtp in tests_migrate::settings - Rust

Struct tests_migrate::settings::Smtp[−][src]

pub struct Smtp {
+    pub from: String,
+    pub reply: String,
+    pub url: String,
+    pub username: String,
+    pub password: String,
+    pub port: u16,
+}

Fields

from: Stringreply: Stringurl: Stringusername: Stringpassword: Stringport: u16

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/struct.SETTINGS.html b/tests_migrate/struct.SETTINGS.html index 0939e3ea..3dd41154 100644 --- a/tests_migrate/struct.SETTINGS.html +++ b/tests_migrate/struct.SETTINGS.html @@ -1,111 +1,110 @@ -SETTINGS in tests_migrate - Rust - -

Struct tests_migrate::SETTINGS[−][src]

pub struct SETTINGS {
-    __private_field: (),
-}

- Fields

__private_field: ()

Methods from Deref<Target = Settings>

Trait Implementations

The resulting type after dereferencing.

-

Dereferences the value.

-

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

-

Immutably borrows from an owned value. Read more

-

Mutably borrows from an owned value. Read more

-

Converts self into T using Into<T>. Read more

-

Converts self into a target type. Read more

-

Causes self to use its Binary implementation when Debug-formatted.

-

Causes self to use its Display implementation when +SETTINGS in tests_migrate - Rust

Struct tests_migrate::SETTINGS[−][src]

pub struct SETTINGS {
+    __private_field: (),
+}

Fields

__private_field: ()

Methods from Deref<Target = Settings>

Trait Implementations

The resulting type after dereferencing.

+

Dereferences the value.

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file diff --git a/tests_migrate/struct.Settings.html b/tests_migrate/struct.Settings.html index 8805f236..a6cba53c 100644 --- a/tests_migrate/struct.Settings.html +++ b/tests_migrate/struct.Settings.html @@ -1,126 +1,125 @@ -Settings in tests_migrate - Rust - -

Struct tests_migrate::Settings[−][src]

pub struct Settings {
-    pub debug: bool,
-    pub commercial: bool,
+Settings in tests_migrate - Rust
Struct tests_migrate::Settings[−][src]
pub struct Settings {
+    pub debug: bool,
+    pub commercial: bool,
     pub database: Database,
-    pub redis: Option<Redis>,
+    pub redis: Option<Redis>,
     pub server: Server,
     pub pow: Captcha,
-    pub source_code: String,
-    pub smtp: Option<Smtp>,
-    pub allow_registration: bool,
-    pub allow_demo: bool,
-}

-                       Fields
debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool
Implementations
Trait Implementations
Returns a copy of the value. Read more

-
Performs copy-assignment from source. Read more

-
Formats the value using the given formatter. Read more

-
Deserialize this value from the given Serde deserializer. Read more

-
Auto Trait Implementations
Blanket Implementations
Gets the TypeId of self. Read more

-
Immutably borrows from an owned value. Read more

-
Mutably borrows from an owned value. Read more

-
Converts self into T using Into<T>. Read more

-
Converts self into a target type. Read more

-
Causes self to use its Binary implementation when Debug-formatted.

-
Causes self to use its Display implementation when
+    pub source_code: String,
+    pub smtp: Option<Smtp>,
+    pub allow_registration: bool,
+    pub allow_demo: bool,
+}

Fields

debug: boolcommercial: booldatabase: Databaseredis: Option<Redis>server: Serverpow: Captchasource_code: Stringsmtp: Option<Smtp>allow_registration: boolallow_demo: bool

Implementations

Trait Implementations

Returns a copy of the value. Read more

+

Performs copy-assignment from source. Read more

+

Formats the value using the given formatter. Read more

+

Deserialize this value from the given Serde deserializer. Read more

+

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

+

Immutably borrows from an owned value. Read more

+

Mutably borrows from an owned value. Read more

+

Converts self into T using Into<T>. Read more

+

Converts self into a target type. Read more

+

Causes self to use its Binary implementation when Debug-formatted.

+

Causes self to use its Display implementation when Debug-formatted. Read more

-

Causes self to use its LowerExp implementation when +

Causes self to use its LowerExp implementation when Debug-formatted. Read more

-

Causes self to use its LowerHex implementation when +

Causes self to use its LowerHex implementation when Debug-formatted. Read more

-

Causes self to use its Octal implementation when Debug-formatted.

-

Causes self to use its Pointer implementation when +

Causes self to use its Octal implementation when Debug-formatted.

+

Causes self to use its Pointer implementation when Debug-formatted. Read more

-

Causes self to use its UpperExp implementation when +

Causes self to use its UpperExp implementation when Debug-formatted. Read more

-

Causes self to use its UpperHex implementation when +

Causes self to use its UpperHex implementation when Debug-formatted. Read more

-

Performs the conversion.

-

Instruments this type with the provided Span, returning an +

Performs the conversion.

+

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

-

Instruments this type with the current Span, returning an +

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

-

Performs the conversion.

-

Pipes by value. This is generally the method you want to use. Read more

-

Borrows self and passes that borrow into the pipe function. Read more

-

Mutably borrows self and passes that borrow into the pipe function. Read more

-

Borrows self, then passes self.borrow() into the pipe function. Read more

-

Mutably borrows self, then passes self.borrow_mut() into the pipe +

Performs the conversion.

+

Pipes by value. This is generally the method you want to use. Read more

+

Borrows self and passes that borrow into the pipe function. Read more

+

Mutably borrows self and passes that borrow into the pipe function. Read more

+

Borrows self, then passes self.borrow() into the pipe function. Read more

+

Mutably borrows self, then passes self.borrow_mut() into the pipe function. Read more

-

Borrows self, then passes self.as_ref() into the pipe function.

-

Mutably borrows self, then passes self.as_mut() into the pipe +

Borrows self, then passes self.as_ref() into the pipe function.

+

Mutably borrows self, then passes self.as_mut() into the pipe function. Read more

-

Borrows self, then passes self.deref() into the pipe function.

-

Mutably borrows self, then passes self.deref_mut() into the pipe +

Borrows self, then passes self.deref() into the pipe function.

+

Mutably borrows self, then passes self.deref_mut() into the pipe function. Read more

-

Pipes a value into a function that cannot ordinarily be called in suffix +

Pipes a value into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait borrow into a function that cannot normally be called in +

Pipes a trait borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a trait mutable borrow into a function that cannot normally be +

Pipes a trait mutable borrow into a function that cannot normally be called in suffix position. Read more

-

Pipes a dereference into a function that cannot normally be called in +

Pipes a dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a mutable dereference into a function that cannot normally be +

Pipes a mutable dereference into a function that cannot normally be called in suffix position. Read more

-

Pipes a reference into a function that cannot ordinarily be called in +

Pipes a reference into a function that cannot ordinarily be called in suffix position. Read more

-

Pipes a mutable reference into a function that cannot ordinarily be +

Pipes a mutable reference into a function that cannot ordinarily be called in suffix position. Read more

-

Should always be Self

-

Immutable access to a value. Read more

-

Mutable access to a value. Read more

-

Immutable access to the Borrow<B> of a value. Read more

-

Mutable access to the BorrowMut<B> of a value. Read more

-

Immutable access to the AsRef<R> view of a value. Read more

-

Mutable access to the AsMut<R> view of a value. Read more

-

Immutable access to the Deref::Target of a value. Read more

-

Mutable access to the Deref::Target of a value. Read more

-

Calls .tap() only in debug builds, and is erased in release builds.

-

Calls .tap_mut() only in debug builds, and is erased in release +

Should always be Self

+

Immutable access to a value. Read more

+

Mutable access to a value. Read more

+

Immutable access to the Borrow<B> of a value. Read more

+

Mutable access to the BorrowMut<B> of a value. Read more

+

Immutable access to the AsRef<R> view of a value. Read more

+

Mutable access to the AsMut<R> view of a value. Read more

+

Immutable access to the Deref::Target of a value. Read more

+

Mutable access to the Deref::Target of a value. Read more

+

Calls .tap() only in debug builds, and is erased in release builds.

+

Calls .tap_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow() only in debug builds, and is erased in release +

Calls .tap_borrow() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_borrow_mut() only in debug builds, and is erased in release +

Calls .tap_borrow_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref() only in debug builds, and is erased in release +

Calls .tap_ref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_ref_mut() only in debug builds, and is erased in release +

Calls .tap_ref_mut() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref() only in debug builds, and is erased in release +

Calls .tap_deref() only in debug builds, and is erased in release builds. Read more

-

Calls .tap_deref_mut() only in debug builds, and is erased in release +

Calls .tap_deref_mut() only in debug builds, and is erased in release builds. Read more

-

Provides immutable access for inspection. Read more

-

Calls tap in debug builds, and does nothing in release builds.

-

Provides mutable access for modification. Read more

-

Calls tap_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the reference for inspection.

-

Calls tap_ref in debug builds, and does nothing in release builds.

-

Provides mutable access to the reference for modification.

-

Calls tap_ref_mut in debug builds, and does nothing in release builds.

-

Provides immutable access to the borrow for inspection. Read more

-

Calls tap_borrow in debug builds, and does nothing in release builds.

-

Provides mutable access to the borrow for modification.

-

Calls tap_borrow_mut in debug builds, and does nothing in release +

Provides immutable access for inspection. Read more

+

Calls tap in debug builds, and does nothing in release builds.

+

Provides mutable access for modification. Read more

+

Calls tap_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the reference for inspection.

+

Calls tap_ref in debug builds, and does nothing in release builds.

+

Provides mutable access to the reference for modification.

+

Calls tap_ref_mut in debug builds, and does nothing in release builds.

+

Provides immutable access to the borrow for inspection. Read more

+

Calls tap_borrow in debug builds, and does nothing in release builds.

+

Provides mutable access to the borrow for modification.

+

Calls tap_borrow_mut in debug builds, and does nothing in release builds. Read more

-

Immutably dereferences self for inspection.

-

Calls tap_deref in debug builds, and does nothing in release builds.

-

Mutably dereferences self for modification.

-

Calls tap_deref_mut in debug builds, and does nothing in release +

Immutably dereferences self for inspection.

+

Calls tap_deref in debug builds, and does nothing in release builds.

+

Mutably dereferences self for modification.

+

Calls tap_deref_mut in debug builds, and does nothing in release builds. Read more

-

The resulting type after obtaining ownership.

-

Creates owned data from borrowed data, usually by cloning. Read more

-
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

-

Uses borrowed data to replace owned data, usually by cloning. Read more

-

Attempts to convert self into T using TryInto<T>. Read more

-

Attempts to convert self into a target type. Read more

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-

The type returned in the event of a conversion error.

-

Performs the conversion.

-
\ No newline at end of file +

The resulting type after obtaining ownership.

+

Creates owned data from borrowed data, usually by cloning. Read more

+
🔬 This is a nightly-only experimental API. (toowned_clone_into)

recently added

+

Uses borrowed data to replace owned data, usually by cloning. Read more

+

Attempts to convert self into T using TryInto<T>. Read more

+

Attempts to convert self into a target type. Read more

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+

The type returned in the event of a conversion error.

+

Performs the conversion.

+
+ + \ No newline at end of file