text stringlengths 8 4.13M |
|---|
use diar::domain::{model::Favorite, repository::IRepository};
use super::inmemory::repository::Repository;
#[test]
pub fn test_add() {
let repo = Repository::new(Vec::new());
let fav = Favorite::new("name1", "path1");
let added = &repo.add(&fav);
assert_eq!(added.as_ref().unwrap().name(), fav.name());
assert_eq!(added.as_ref().unwrap().path(), fav.path());
}
#[test]
pub fn test_get_all() {
let fav1 = Favorite::new("name1", "path1");
let fav2 = Favorite::new("name2", "path2");
let repo = Repository::new(vec![fav1.clone(), fav2.clone()]);
let got = &repo.get_all().unwrap();
assert_eq!(got[0].name(), fav1.name());
assert_eq!(got[0].path(), fav1.path());
assert_eq!(got[1].name(), fav2.name());
assert_eq!(got[1].path(), fav2.path());
}
#[test]
pub fn test_get() {
let fav = Favorite::new("name1", "path1");
let repo = Repository::new(vec![fav.clone()]);
let got = &repo.get(&fav.name()).unwrap().unwrap();
assert_eq!(got.name(), fav.name());
assert_eq!(got.path(), fav.path());
}
#[test]
pub fn test_remove() {
let fav = Favorite::new("name1", "path1");
let repo = Repository::new(vec![fav.clone()]);
let _ = &repo.remove(&fav.name()).unwrap().unwrap();
let got = &repo.get(&fav.name()).unwrap();
assert!(got.is_none());
}
#[test]
pub fn test_remove_all() {
let fav1 = Favorite::new("name1", "path1");
let fav2 = Favorite::new("name2", "path2");
let repo = Repository::new(vec![fav1, fav2]);
let _ = &repo.remove_all();
let got = &repo.get_all().unwrap();
assert!(got.is_empty());
}
#[test]
pub fn test_exists() {
let fav1 = Favorite::new("name1", "path1");
let repo = Repository::new(vec![fav1.clone()]);
assert!(repo.is_exist(&fav1.name()).unwrap());
}
|
// === MATCH Control Flow === //
/*
Rust has an extremely powerful control flow operator called match that allows you to compare a value against a series
of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable
names, wildcards, and many other things.
Think of a match expression as being like a coin-sorting machine: coins slide down a track with variously sized holes
along it, and each coin falls through the first hole it encounters that it fits into. In the same way, values go through
each pattern in a match, and at the first pattern the value “fits,” the value falls into the associated code block to be
used during execution.
*/
#[derive(Debug)]
enum UsState {
Alabama,
Alaska,
// -- more states --
}
#[derive(Debug)]
enum Coin {
Penny,
Nickel,
Dime,
Quarter(UsState),
}
fn main() {
println!("Hello, world!");
let penny = Coin::Penny;
let quarter = Coin::Quarter(UsState::Alabama);
let one = value_in_cents(penny);
let twenty_five = value_in_cents(quarter);
println!("penny is {} cent", one );
println!("quarter is {} cents", twenty_five);
// the Options<T> match
let five = Some(5);
let six = plus_one(five);
let none = plus_one(None);
println!("five: {:?}, six {:?}", five, six );
/*
MATCHES are EXHAUSTIVE
this won't work
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
Some(i) => Some(i + 1),
// here should've been a None case
}
}
*/
// === THE _ PLACEHOLDER === //
/*
Rust also has a pattern we can use when we don’t want to list all possible values. For example, a u8 can have valid values of 0 through 255.
If we only care about the values 1, 3, 5, and 7, we don’t want to have to list out 0, 2, 4, 6, 8, 9 all the way up to 255. Fortunately,
we don’t have to: we can use the special pattern _ instead:
*/
let some_u8_value = 5u8;
match some_u8_value {
1 => println!("one"),
3 => println!("three"),
5 => println!("five"),
7 => println!("seven"),
_ => (), // do nothing for the rest
}
}
fn value_in_cents(coin: Coin) -> u8 {
match coin {
// match arms
//Pattern Code
Coin::Penny => {
println!("lucky penny!");
1
},
Coin::Nickel => 5,
Coin::Dime => 10,
Coin::Quarter(state) => {
println!("State quarter from {:?}!", state );
25
}
}
}
// === MATCHING WITH Option<T>
fn plus_one(x: Option<i32>) -> Option<i32> {
match x {
None => None,
Some(i) => Some(i + 1),
}
}
|
#![doc = "generated by AutoRust 0.1.0"]
#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryNameCheckRequest {
pub name: String,
#[serde(rename = "type")]
pub type_: registry_name_check_request::Type,
}
pub mod registry_name_check_request {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Type {
#[serde(rename = "Microsoft.ContainerRegistry/registries")]
MicrosoftContainerRegistryRegistries,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryNameStatus {
#[serde(rename = "nameAvailable", default, skip_serializing_if = "Option::is_none")]
pub name_available: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OperationListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<OperationDefinition>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OperationDefinition {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<OperationDisplayDefinition>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct OperationDisplayDefinition {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operation: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Registry {
#[serde(flatten)]
pub resource: Resource,
pub sku: Sku,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<RegistryProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Sku {
pub name: sku::Name,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tier: Option<sku::Tier>,
}
pub mod sku {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Name {
Basic,
#[serde(rename = "Managed_Basic")]
ManagedBasic,
#[serde(rename = "Managed_Standard")]
ManagedStandard,
#[serde(rename = "Managed_Premium")]
ManagedPremium,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Tier {
Basic,
Managed,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryProperties {
#[serde(rename = "loginServer", default, skip_serializing_if = "Option::is_none")]
pub login_server: Option<String>,
#[serde(rename = "creationDate", default, skip_serializing_if = "Option::is_none")]
pub creation_date: Option<String>,
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<registry_properties::ProvisioningState>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<Status>,
#[serde(rename = "adminUserEnabled", default, skip_serializing_if = "Option::is_none")]
pub admin_user_enabled: Option<bool>,
#[serde(rename = "storageAccount", default, skip_serializing_if = "Option::is_none")]
pub storage_account: Option<StorageAccountProperties>,
}
pub mod registry_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ProvisioningState {
Creating,
Updating,
Deleting,
Succeeded,
Failed,
Canceled,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Status {
#[serde(rename = "displayStatus", default, skip_serializing_if = "Option::is_none")]
pub display_status: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct StorageAccountProperties {
pub id: String,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryUpdateParameters {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub sku: Option<Sku>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<RegistryPropertiesUpdateParameters>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryPropertiesUpdateParameters {
#[serde(rename = "adminUserEnabled", default, skip_serializing_if = "Option::is_none")]
pub admin_user_enabled: Option<bool>,
#[serde(rename = "storageAccount", default, skip_serializing_if = "Option::is_none")]
pub storage_account: Option<StorageAccountProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Registry>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryListCredentialsResult {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub passwords: Vec<RegistryPassword>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryPassword {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<registry_password::Name>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
pub mod registry_password {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Name {
#[serde(rename = "password")]
Password,
#[serde(rename = "password2")]
Password2,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegenerateCredentialParameters {
pub name: regenerate_credential_parameters::Name,
}
pub mod regenerate_credential_parameters {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Name {
#[serde(rename = "password")]
Password,
#[serde(rename = "password2")]
Password2,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryUsageListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<RegistryUsage>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct RegistryUsage {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "currentValue", default, skip_serializing_if = "Option::is_none")]
pub current_value: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub unit: Option<registry_usage::Unit>,
}
pub mod registry_usage {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Unit {
Count,
Bytes,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Replication {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<ReplicationProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ReplicationProperties {
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<replication_properties::ProvisioningState>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<Status>,
}
pub mod replication_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ProvisioningState {
Creating,
Updating,
Deleting,
Succeeded,
Failed,
Canceled,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ReplicationUpdateParameters {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct ReplicationListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Replication>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Webhook {
#[serde(flatten)]
pub resource: Resource,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<WebhookProperties>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookProperties {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<webhook_properties::Status>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
pub actions: Vec<String>,
#[serde(rename = "provisioningState", default, skip_serializing_if = "Option::is_none")]
pub provisioning_state: Option<webhook_properties::ProvisioningState>,
}
pub mod webhook_properties {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Status {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum ProvisioningState {
Creating,
Updating,
Deleting,
Succeeded,
Failed,
Canceled,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookCreateParameters {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
pub location: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<WebhookPropertiesCreateParameters>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookPropertiesCreateParameters {
#[serde(rename = "serviceUri")]
pub service_uri: String,
#[serde(rename = "customHeaders", default, skip_serializing_if = "Option::is_none")]
pub custom_headers: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<webhook_properties_create_parameters::Status>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
pub actions: Vec<String>,
}
pub mod webhook_properties_create_parameters {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Status {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookUpdateParameters {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<WebhookPropertiesUpdateParameters>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookPropertiesUpdateParameters {
#[serde(rename = "serviceUri", default, skip_serializing_if = "Option::is_none")]
pub service_uri: Option<String>,
#[serde(rename = "customHeaders", default, skip_serializing_if = "Option::is_none")]
pub custom_headers: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<webhook_properties_update_parameters::Status>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub scope: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub actions: Vec<String>,
}
pub mod webhook_properties_update_parameters {
use super::*;
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub enum Status {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct WebhookListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Webhook>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventInfo {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct CallbackConfig {
#[serde(rename = "serviceUri")]
pub service_uri: String,
#[serde(rename = "customHeaders", default, skip_serializing_if = "Option::is_none")]
pub custom_headers: Option<serde_json::Value>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventListResult {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub value: Vec<Event>,
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Event {
#[serde(flatten)]
pub event_info: EventInfo,
#[serde(rename = "eventRequestMessage", default, skip_serializing_if = "Option::is_none")]
pub event_request_message: Option<EventRequestMessage>,
#[serde(rename = "eventResponseMessage", default, skip_serializing_if = "Option::is_none")]
pub event_response_message: Option<EventResponseMessage>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventRequestMessage {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<EventContent>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub headers: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub method: Option<String>,
#[serde(rename = "requestUri", default, skip_serializing_if = "Option::is_none")]
pub request_uri: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventResponseMessage {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub headers: Option<serde_json::Value>,
#[serde(rename = "reasonPhrase", default, skip_serializing_if = "Option::is_none")]
pub reason_phrase: Option<String>,
#[serde(rename = "statusCode", default, skip_serializing_if = "Option::is_none")]
pub status_code: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct EventContent {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target: Option<Target>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub request: Option<Request>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub actor: Option<Actor>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub source: Option<Source>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Target {
#[serde(rename = "mediaType", default, skip_serializing_if = "Option::is_none")]
pub media_type: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub size: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub digest: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub length: Option<i64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub repository: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tag: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Request {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub addr: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub host: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub method: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub useragent: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Actor {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Source {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub addr: Option<String>,
#[serde(rename = "instanceID", default, skip_serializing_if = "Option::is_none")]
pub instance_id: Option<String>,
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Resource {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
pub location: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
|
//! Pathfinder build script.
//!
//! Just sets up `vergen` to query our git information for the build.
fn main() {
// our Dockerfile is set up to a dependency only run, to cache a layer with all of the
// dependencies downloaded. during that "DEPENDENCY_LAYER" environment variable is set,
// and we shouldn't ask vergen to setup anything on that run to avoid this adding additional
// cache-miss reasons.
if std::env::var_os("DEPENDENCY_LAYER").is_some() {
return;
}
{
// at 7.0.0 default enables everything compiled in, selected with feature-flags
let mut config = vergen::Config::default();
*config.git_mut().semver_kind_mut() = vergen::SemverKind::Lightweight;
*config.git_mut().semver_dirty_mut() = Some("-dirty");
vergen::vergen(config)
.expect("vergen failed; this is probably due to missing .git directory");
}
}
|
use anyhow::Result;
use chrono::{DateTime, Utc};
use env_logger;
use getopts;
use getopts::Options;
use libc::_exit;
use log::{info, warn};
use nix::fcntl::{open, OFlag};
use nix::sys::signal::{sigaction, SaFlags, SigAction, SigHandler, SigSet, Signal};
use nix::sys::stat::Mode;
use nix::unistd::{
chdir, chroot, dup2, fork, initgroups, setgid, setsid, setuid, ForkResult, Group, User,
};
use std::env;
use std::ffi::CString;
use std::fmt;
use std::fs;
use std::fs::File;
use std::io::prelude::*;
use std::io::{BufReader, BufWriter};
use std::net::{TcpListener, TcpStream, ToSocketAddrs};
use std::process::exit;
use std::str::FromStr;
const MAX_REQUEST_BODY_LENGTH: i64 = 10_000;
const HTTP_MINOR_VERSION: u32 = 1;
const SERVER_NAME: &str = "RustHTTP";
const SERVER_VERSION: &str = "0.0.1";
#[derive(Debug)]
pub enum CustomError {
ParseError(String),
TooLongRequestBodyError,
NoAddressError(String),
SetupEnvError,
}
impl std::error::Error for CustomError {}
impl fmt::Display for CustomError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
CustomError::ParseError(s) => write!(f, "parse error on request line: {}", s),
CustomError::TooLongRequestBodyError => write!(f, "too long request body"),
CustomError::NoAddressError(s) => write!(f, "no address: {} does not exist", s),
CustomError::SetupEnvError => write!(f, "failed to set up environment"),
}
}
}
struct HTTPHeaderField {
name: String,
value: String,
next: Option<Box<HTTPHeaderField>>,
}
impl HTTPHeaderField {
pub fn new() -> HTTPHeaderField {
HTTPHeaderField {
name: String::new(),
value: String::new(),
next: None,
}
}
}
struct HTTPRequest {
protocol_minor_version: i32,
method: String,
path: String,
header: Option<Box<HTTPHeaderField>>,
body: String,
length: i64,
}
impl HTTPRequest {
pub fn new() -> HTTPRequest {
HTTPRequest {
protocol_minor_version: 0,
method: String::new(),
path: String::new(),
header: None,
body: String::new(),
length: 0,
}
}
}
struct FileInfo {
path: String,
size: u64,
ok: bool,
}
impl FileInfo {
pub fn new(docroot: String, urlpath: &str) -> FileInfo {
let path = docroot + "/" + &urlpath;
let st = match fs::metadata(&path) {
Ok(st) => st,
Err(_) => {
return FileInfo {
path: path,
size: 0,
ok: false,
};
}
};
if !st.is_file() {
return FileInfo {
path: path,
size: 0,
ok: false,
};
}
FileInfo {
path: path,
size: st.len(),
ok: true,
}
}
}
// TODO: implement like OOP
fn respond_to(
req: &HTTPRequest,
buf_out: &mut BufWriter<&TcpStream>,
docroot: String,
) -> Result<()> {
if req.method == "GET" {
do_file_response(req, buf_out, docroot)?;
} else if req.method == "HEAD" {
do_file_response(req, buf_out, docroot)?;
} else if req.method == "POST" {
method_not_allowed(req, buf_out)?;
} else {
not_implemented(req, buf_out)?;
}
Ok(())
}
fn not_found(req: &HTTPRequest, buf_out: &mut BufWriter<&TcpStream>) -> Result<()> {
output_common_header_fields(req, buf_out, "404 Not Found")?;
Ok(())
}
fn not_implemented(req: &HTTPRequest, buf_out: &mut BufWriter<&TcpStream>) -> Result<()> {
output_common_header_fields(req, buf_out, "501 Not Implemented")?;
Ok(())
}
fn method_not_allowed(req: &HTTPRequest, buf_out: &mut BufWriter<&TcpStream>) -> Result<()> {
output_common_header_fields(req, buf_out, "405 Method Not Allowed")?;
Ok(())
}
// TODO: implement like OOP
fn do_file_response(
req: &HTTPRequest,
buf_out: &mut BufWriter<&TcpStream>,
docroot: String,
) -> Result<()> {
let info = FileInfo::new(docroot, &req.path);
if !info.ok {
not_found(req, buf_out)?;
return Ok(());
}
output_common_header_fields(req, buf_out, "200 OK")?;
write!(buf_out, "Content-Length: {}\r\n", info.size)?;
// TODO: implement guess_content_type fn
write!(buf_out, "Content-Type: {}\r\n", "text/plain")?;
write!(buf_out, "\r\n")?;
if req.method != "HEAD" {
let file = File::open(info.path)?;
let mut file_buf = BufReader::new(file);
let mut file_string = String::new();
file_buf.read_to_string(&mut file_string)?;
buf_out.write_all(file_string.as_bytes())?;
}
buf_out.flush()?;
Ok(())
}
fn output_common_header_fields(
_req: &HTTPRequest,
buf_out: &mut BufWriter<&TcpStream>,
status: &str,
) -> Result<()> {
write!(buf_out, "HTTP/1.{} {}\r\n", HTTP_MINOR_VERSION, status)?;
let utc: DateTime<Utc> = Utc::now();
write!(
buf_out,
"Date: {}\r\n",
utc.format("%a, %d %b %Y %H:%M:%S GMT")
)?;
write!(buf_out, "Server: {}/{}\r\n", SERVER_NAME, SERVER_VERSION)?;
write!(buf_out, "Connection: close\r\n")?;
Ok(())
}
fn install_signal_handlers() -> Result<()> {
trap_signal(Signal::SIGPIPE, signal_exit)?;
detach_children()?;
Ok(())
}
fn detach_children() -> Result<()> {
let act = SigAction::new(
SigHandler::Handler(noop_handler),
SaFlags::SA_RESTART | SaFlags::SA_NOCLDWAIT,
SigSet::empty(),
);
unsafe { sigaction(Signal::SIGCHLD, &act) }?;
Ok(())
}
fn trap_signal(sig: Signal, handler: extern "C" fn(i32)) -> Result<()> {
let act = SigAction::new(
SigHandler::Handler(handler),
SaFlags::SA_RESTART,
SigSet::empty(),
);
unsafe { sigaction(sig, &act) }?;
Ok(())
}
extern "C" fn signal_exit(signum: i32) {
warn!("exit by signal {}", signum);
}
extern "C" fn noop_handler(_signum: i32) {}
fn service(
buf_in: &mut BufReader<&TcpStream>,
buf_out: &mut BufWriter<&TcpStream>,
path: &str,
) -> Result<()> {
let req = read_request(buf_in)?;
respond_to(&req, buf_out, path.to_string())?;
Ok(())
}
fn read_request(buf_in: &mut BufReader<&TcpStream>) -> Result<HTTPRequest> {
let mut req = HTTPRequest::new();
read_request_line(buf_in, &mut req)?;
while let Some(mut h) = read_header_field(buf_in) {
h.next = req.header;
req.header = Some(Box::new(h));
}
req.length = if let Some(l) = content_length(&req.header) {
l
} else {
0
// Err(CustomError::ParseError("no content length".to_string()))?;
};
if req.length != 0 {
if req.length > MAX_REQUEST_BODY_LENGTH {
Err(CustomError::TooLongRequestBodyError)?;
}
let mut body = String::with_capacity(req.length as usize);
buf_in.read_to_string(&mut body)?;
req.body = body;
}
Ok(req)
}
fn content_length(h: &Option<Box<HTTPHeaderField>>) -> Option<i64> {
if let Some(kv) = h {
if kv.name == "Content-Length" {
return kv.value.parse::<i64>().ok();
} else {
return content_length(&kv.next);
}
}
return None;
}
fn read_header_field(buf_in: &mut BufReader<&TcpStream>) -> Option<HTTPHeaderField> {
let mut line = String::new();
if let Some(n) = buf_in.read_line(&mut line).ok() {
if n == 0 {
return None;
}
let kv: Vec<&str> = line.split_whitespace().collect();
if kv.len() >= 2 {
let mut h = HTTPHeaderField::new();
h.name = kv[0].to_string();
h.value = kv[1].to_string();
return Some(h);
}
}
return None;
}
fn read_request_line(buf_in: &mut BufReader<&TcpStream>, req: &mut HTTPRequest) -> Result<()> {
let mut line = String::new();
let _ = buf_in.read_line(&mut line)?;
line.remove(line.len() - 1);
let args: Vec<&str> = line.split_whitespace().collect();
if args.len() < 3 {
return Err(From::from(CustomError::ParseError(line)));
}
let method = args[0].to_uppercase();
let path = args[1].to_string();
let protocol = args[2].to_string();
if !protocol.starts_with("HTTP/1.") {
// MEMO: 本当は Err(CustomError::ParseError(protocol))? と書きたかった...
// protocolがParseErrorにmoveされてしまうので
return Err(From::from(CustomError::ParseError(protocol)));
}
let protocol_minor_version: i32 = FromStr::from_str(&protocol[protocol.len() - 1..])?;
req.protocol_minor_version = protocol_minor_version;
req.method = method;
req.path = path;
Ok(())
}
fn become_daemon() -> Result<()> {
chdir("/")?;
let nio = open("/dev/null", OFlag::O_RDWR, Mode::S_IRWXU)?;
dup2(nio, 0)?;
dup2(nio, 1)?;
dup2(nio, 2)?;
match unsafe { fork() }? {
ForkResult::Parent { child, .. } => {
let mut f = File::create("/home/yuzi/myprogramming/rust/rust_stdlinux/aba.txt")?;
write!(f, "child pid: {}", child)?;
f.flush()?;
unsafe { _exit(0) };
}
ForkResult::Child => {
setsid()?;
}
}
Ok(())
}
fn listen_socket(port: String) -> Result<TcpListener> {
let hostname = "localhost".to_string() + ":" + &port;
// FIXME: Device or resource is busy
let mut addrs = hostname.to_socket_addrs()?;
if let Some(addr) = addrs.find(|x| (*x).is_ipv4()) {
// MEMO: portが1024未満の場合特権ポートと呼ばれroot権限が必要
let listener = TcpListener::bind(addr)?;
return Ok(listener);
}
return Err(From::from(CustomError::NoAddressError(hostname)));
}
fn server_main(listner: TcpListener, docroot: String) -> Result<()> {
loop {
let (socket, _addr) = listner.accept()?;
match unsafe { fork() }? {
ForkResult::Parent { child: _, .. } => {}
ForkResult::Child => {
let mut ins = BufReader::new(&socket);
let mut outs = BufWriter::new(&socket);
service(&mut ins, &mut outs, &docroot)?;
exit(0);
}
}
}
}
// TODO: chroot
fn setup_environment(root: &str, user_name: String, group_name: String) -> Result<()> {
let cuser_name = CString::new(user_name.clone())?;
if let Some(group) = Group::from_name(&group_name)? {
setgid(group.gid)?;
// initgroupsにはroot権限が必要
initgroups(&cuser_name, group.gid)?;
if let Some(user) = User::from_name(&user_name)? {
chroot(root)?;
setuid(user.uid)?;
return Ok(());
}
}
Err(From::from(CustomError::SetupEnvError))
}
fn main() -> Result<()> {
let args: Vec<String> = env::args().collect();
let mut debug_mode = false;
let mut do_chroot = false;
let mut user: String = String::new();
let mut group: String = String::new();
let mut port: String = String::new();
let mut opts = Options::new();
opts.optflag("h", "help", "print this help menu");
opts.optflag("d", "debug", "debug mode");
opts.optflag("c", "chroot", "change root");
opts.optopt("u", "user", "user name", "NAME");
opts.optopt("g", "group", "group name", "GROUP");
opts.optopt("p", "port", "port number", "PORT");
let matches = opts.parse(&args[1..])?;
if matches.opt_present("h") {
println!(
"Usage: {} [--port=p] [--chroot --user=u --group=g --debug] <docroot>",
&args[0]
);
return Ok(());
}
if matches.opt_present("d") {
debug_mode = true;
};
if matches.opt_present("c") {
do_chroot = true;
}
if let Some(u) = matches.opt_str("u") {
user = u;
}
if let Some(g) = matches.opt_str("g") {
group = g;
}
if let Some(p) = matches.opt_str("p") {
port = p;
}
if matches.free.is_empty() {
eprintln!(
"Usage: {} [--port=p] [--chroot --user=u --group=g --debug] <docroot>",
&args[0]
);
exit(1);
}
let mut docroot = matches.free[0].clone();
if do_chroot {
setup_environment(&docroot, user, group)?;
docroot = "".to_string();
}
install_signal_handlers()?;
let listener = listen_socket(port)?;
if !debug_mode {
env::set_var("RUST_LOG", "info");
env_logger::init();
become_daemon()?;
info!("start service");
}
server_main(listener, docroot)?;
Ok(())
}
|
mod custom_resource;
mod daemon_deployment;
use crate::operator::custom_resource::{add_finalizer, remove_finalizer};
use crate::operator::daemon_deployment::{create_or_update, destroy, DaemonDeployment};
pub use custom_resource::TorHiddenService;
use custom_resource::TorHiddenServiceSpec;
use futures::{future, FutureExt, StreamExt};
use k8s_openapi::api::apps::v1::Deployment;
use kube::api::ListParams;
use kube::{Api, Client, Resource};
use kube_runtime::controller::{Context, ReconcilerAction};
use kube_runtime::Controller;
use std::fmt::Formatter;
use std::future::Future;
use std::pin::Pin;
#[derive(Clone)]
pub struct Operator {}
impl Operator {
pub async fn new(client: Client) -> (Self, Pin<Box<dyn Future<Output = ()> + Send + 'static>>) {
let context = Context::new(State {
client: client.clone(),
});
let api = Api::<TorHiddenService>::all(client);
let drainer = Controller::new(api, ListParams::default())
.run(reconcile, error_policy, context)
.filter_map(|x| async move { std::result::Result::ok(x) })
.for_each(|o| {
tracing::info!(tor_hidden_service = ?o, "Reconciliation finished");
future::ready(())
})
.boxed();
(Self {}, drainer)
}
}
struct State {
pub client: Client,
}
#[derive(Debug)]
struct OperatorError {}
impl std::error::Error for OperatorError {}
impl std::fmt::Display for OperatorError {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "{:?}", self)
}
}
impl From<serde_json::Error> for OperatorError {
fn from(e: serde_json::Error) -> Self {
panic!("{:?}", e);
}
}
impl From<kube::Error> for OperatorError {
fn from(e: kube::Error) -> Self {
panic!("{:?}", e);
}
}
#[tracing::instrument(skip(ctx))]
async fn reconcile(
tor_hidden_service: TorHiddenService,
ctx: Context<State>,
) -> Result<ReconcilerAction, OperatorError> {
tracing::info!("Reconciliation started");
// metadata
let name = tor_hidden_service.name();
let namespace: &str = tor_hidden_service.metadata.namespace.as_ref().unwrap();
let spec: &TorHiddenServiceSpec = &tor_hidden_service.spec;
// prepare data
let daemon_deployment = DaemonDeployment {
hs_ed25519_public_key: spec.hs_ed25519_public_key.clone(),
hs_ed25519_secret_key: spec.hs_ed25519_secret_key.clone(),
name,
virtual_port: spec.virtual_port,
target_address: spec.target_address.to_owned(),
target_port: spec.target_port,
};
// apis
let deployments: Api<Deployment> = Api::namespaced(ctx.get_ref().client.clone(), namespace);
let tor_hidden_services: Api<TorHiddenService> =
Api::namespaced(ctx.get_ref().client.clone(), namespace);
match &tor_hidden_service.metadata.deletion_timestamp {
None => {
add_finalizer(tor_hidden_services, &tor_hidden_service).await;
create_or_update(deployments, &daemon_deployment).await;
}
Some(_) => {
destroy(deployments, &daemon_deployment).await;
remove_finalizer(tor_hidden_services, &tor_hidden_service).await;
}
}
Ok(ReconcilerAction {
requeue_after: Some(std::time::Duration::from_secs(1800)),
})
}
#[tracing::instrument(skip(_ctx))]
fn error_policy(error: &OperatorError, _ctx: Context<State>) -> ReconcilerAction {
println!("Reconciliation failed");
ReconcilerAction {
requeue_after: Some(std::time::Duration::from_secs(360)),
}
}
|
use crate::schema::users;
use chrono::NaiveDateTime;
use diesel::pg::PgConnection;
use diesel::prelude::*;
use serde_derive::Serialize;
#[derive(Clone, Debug, Queryable, Identifiable, Serialize, PartialEq)]
pub struct User {
pub id: i64,
pub puid: String,
pub first_name: String,
pub last_name: String,
pub email: String,
pub email_confirmed: bool,
pub created_at: NaiveDateTime,
pub updated_at: Option<NaiveDateTime>,
}
pub fn find(db: &PgConnection, id: i64) -> QueryResult<User> {
users::table.find(id).first::<User>(db)
}
|
fn prime_factors(mut num: i64) -> Vec<i64> {
let mut result = vec![];
let mut i = 2;
while num > 1 {
while num % i == 0 {
result.push(i);
num /= i;
}
i +=1;
}
result
}
#[test]
fn prime_factors_of_48() {
assert_eq!(prime_factors(48), [2, 2, 2, 2, 3]);
}
#[test]
fn prime_factors_of_two() {
assert_eq!(prime_factors(2), [2]);
}
#[test]
fn prime_factors_of_tree() {
assert_eq!(prime_factors(3), [3]);
}
#[test]
fn prime_factors_of_four() {
assert_eq!(prime_factors(4), [2, 2]);
}
#[test]
fn prime_factors_of_six() {
assert_eq!(prime_factors(6), [2, 3]);
}
#[test]
fn prime_factors_of_nine() {
assert_eq!(prime_factors(9), [3, 3]);
}
#[test]
fn prime_factors_of_101() {
assert_eq!(prime_factors(101), [101]);
}
|
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
#[non_exhaustive]
#[derive(std::fmt::Debug)]
pub enum Error {
AccessDeniedError(crate::error::AccessDeniedError),
AttributeLimitExceededError(crate::error::AttributeLimitExceededError),
BlockedError(crate::error::BlockedError),
ClientError(crate::error::ClientError),
ClusterContainsContainerInstancesError(crate::error::ClusterContainsContainerInstancesError),
ClusterContainsServicesError(crate::error::ClusterContainsServicesError),
ClusterContainsTasksError(crate::error::ClusterContainsTasksError),
ClusterNotFoundError(crate::error::ClusterNotFoundError),
InvalidParameterError(crate::error::InvalidParameterError),
LimitExceededError(crate::error::LimitExceededError),
MissingVersionError(crate::error::MissingVersionError),
NoUpdateAvailableError(crate::error::NoUpdateAvailableError),
PlatformTaskDefinitionIncompatibilityError(
crate::error::PlatformTaskDefinitionIncompatibilityError,
),
PlatformUnknownError(crate::error::PlatformUnknownError),
ResourceInUseError(crate::error::ResourceInUseError),
ResourceNotFoundError(crate::error::ResourceNotFoundError),
ServerError(crate::error::ServerError),
ServiceNotActiveError(crate::error::ServiceNotActiveError),
ServiceNotFoundError(crate::error::ServiceNotFoundError),
TargetNotConnectedError(crate::error::TargetNotConnectedError),
TargetNotFoundError(crate::error::TargetNotFoundError),
TaskSetNotFoundError(crate::error::TaskSetNotFoundError),
UnsupportedFeatureError(crate::error::UnsupportedFeatureError),
UpdateInProgressError(crate::error::UpdateInProgressError),
Unhandled(Box<dyn std::error::Error + Send + Sync + 'static>),
}
impl std::fmt::Display for Error {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Error::AccessDeniedError(inner) => inner.fmt(f),
Error::AttributeLimitExceededError(inner) => inner.fmt(f),
Error::BlockedError(inner) => inner.fmt(f),
Error::ClientError(inner) => inner.fmt(f),
Error::ClusterContainsContainerInstancesError(inner) => inner.fmt(f),
Error::ClusterContainsServicesError(inner) => inner.fmt(f),
Error::ClusterContainsTasksError(inner) => inner.fmt(f),
Error::ClusterNotFoundError(inner) => inner.fmt(f),
Error::InvalidParameterError(inner) => inner.fmt(f),
Error::LimitExceededError(inner) => inner.fmt(f),
Error::MissingVersionError(inner) => inner.fmt(f),
Error::NoUpdateAvailableError(inner) => inner.fmt(f),
Error::PlatformTaskDefinitionIncompatibilityError(inner) => inner.fmt(f),
Error::PlatformUnknownError(inner) => inner.fmt(f),
Error::ResourceInUseError(inner) => inner.fmt(f),
Error::ResourceNotFoundError(inner) => inner.fmt(f),
Error::ServerError(inner) => inner.fmt(f),
Error::ServiceNotActiveError(inner) => inner.fmt(f),
Error::ServiceNotFoundError(inner) => inner.fmt(f),
Error::TargetNotConnectedError(inner) => inner.fmt(f),
Error::TargetNotFoundError(inner) => inner.fmt(f),
Error::TaskSetNotFoundError(inner) => inner.fmt(f),
Error::UnsupportedFeatureError(inner) => inner.fmt(f),
Error::UpdateInProgressError(inner) => inner.fmt(f),
Error::Unhandled(inner) => inner.fmt(f),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::CreateCapacityProviderError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::CreateCapacityProviderError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::CreateCapacityProviderErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::CreateCapacityProviderErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::CreateCapacityProviderErrorKind::LimitExceededError(inner) => {
Error::LimitExceededError(inner)
}
crate::error::CreateCapacityProviderErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::CreateCapacityProviderErrorKind::UpdateInProgressError(inner) => {
Error::UpdateInProgressError(inner)
}
crate::error::CreateCapacityProviderErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::CreateClusterError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::CreateClusterError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::CreateClusterErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::CreateClusterErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::CreateClusterErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::CreateClusterErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::CreateServiceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::CreateServiceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, ..} => match err.kind {
crate::error::CreateServiceErrorKind::AccessDeniedError(inner) => Error::AccessDeniedError(inner),
crate::error::CreateServiceErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::CreateServiceErrorKind::ClusterNotFoundError(inner) => Error::ClusterNotFoundError(inner),
crate::error::CreateServiceErrorKind::InvalidParameterError(inner) => Error::InvalidParameterError(inner),
crate::error::CreateServiceErrorKind::PlatformTaskDefinitionIncompatibilityError(inner) => Error::PlatformTaskDefinitionIncompatibilityError(inner),
crate::error::CreateServiceErrorKind::PlatformUnknownError(inner) => Error::PlatformUnknownError(inner),
crate::error::CreateServiceErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::CreateServiceErrorKind::UnsupportedFeatureError(inner) => Error::UnsupportedFeatureError(inner),
crate::error::CreateServiceErrorKind::Unhandled(inner) => Error::Unhandled(inner),
}
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::CreateTaskSetError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::CreateTaskSetError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, ..} => match err.kind {
crate::error::CreateTaskSetErrorKind::AccessDeniedError(inner) => Error::AccessDeniedError(inner),
crate::error::CreateTaskSetErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::CreateTaskSetErrorKind::ClusterNotFoundError(inner) => Error::ClusterNotFoundError(inner),
crate::error::CreateTaskSetErrorKind::InvalidParameterError(inner) => Error::InvalidParameterError(inner),
crate::error::CreateTaskSetErrorKind::PlatformTaskDefinitionIncompatibilityError(inner) => Error::PlatformTaskDefinitionIncompatibilityError(inner),
crate::error::CreateTaskSetErrorKind::PlatformUnknownError(inner) => Error::PlatformUnknownError(inner),
crate::error::CreateTaskSetErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::CreateTaskSetErrorKind::ServiceNotActiveError(inner) => Error::ServiceNotActiveError(inner),
crate::error::CreateTaskSetErrorKind::ServiceNotFoundError(inner) => Error::ServiceNotFoundError(inner),
crate::error::CreateTaskSetErrorKind::UnsupportedFeatureError(inner) => Error::UnsupportedFeatureError(inner),
crate::error::CreateTaskSetErrorKind::Unhandled(inner) => Error::Unhandled(inner),
}
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteAccountSettingError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteAccountSettingError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteAccountSettingErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeleteAccountSettingErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteAccountSettingErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeleteAccountSettingErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteAttributesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteAttributesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteAttributesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DeleteAttributesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteAttributesErrorKind::TargetNotFoundError(inner) => {
Error::TargetNotFoundError(inner)
}
crate::error::DeleteAttributesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteCapacityProviderError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteCapacityProviderError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteCapacityProviderErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeleteCapacityProviderErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteCapacityProviderErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeleteCapacityProviderErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteClusterError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteClusterError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteClusterErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeleteClusterErrorKind::ClusterContainsContainerInstancesError(
inner,
) => Error::ClusterContainsContainerInstancesError(inner),
crate::error::DeleteClusterErrorKind::ClusterContainsServicesError(inner) => {
Error::ClusterContainsServicesError(inner)
}
crate::error::DeleteClusterErrorKind::ClusterContainsTasksError(inner) => {
Error::ClusterContainsTasksError(inner)
}
crate::error::DeleteClusterErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DeleteClusterErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteClusterErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeleteClusterErrorKind::UpdateInProgressError(inner) => {
Error::UpdateInProgressError(inner)
}
crate::error::DeleteClusterErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteServiceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteServiceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteServiceErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeleteServiceErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DeleteServiceErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteServiceErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeleteServiceErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::DeleteServiceErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeleteTaskSetError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DeleteTaskSetError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeleteTaskSetErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::DeleteTaskSetErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeleteTaskSetErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DeleteTaskSetErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeleteTaskSetErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeleteTaskSetErrorKind::ServiceNotActiveError(inner) => {
Error::ServiceNotActiveError(inner)
}
crate::error::DeleteTaskSetErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::DeleteTaskSetErrorKind::TaskSetNotFoundError(inner) => {
Error::TaskSetNotFoundError(inner)
}
crate::error::DeleteTaskSetErrorKind::UnsupportedFeatureError(inner) => {
Error::UnsupportedFeatureError(inner)
}
crate::error::DeleteTaskSetErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeregisterContainerInstanceError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::DeregisterContainerInstanceError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeregisterContainerInstanceErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeregisterContainerInstanceErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DeregisterContainerInstanceErrorKind::InvalidParameterError(
inner,
) => Error::InvalidParameterError(inner),
crate::error::DeregisterContainerInstanceErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeregisterContainerInstanceErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DeregisterTaskDefinitionError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::DeregisterTaskDefinitionError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DeregisterTaskDefinitionErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DeregisterTaskDefinitionErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DeregisterTaskDefinitionErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DeregisterTaskDefinitionErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeCapacityProvidersError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::DescribeCapacityProvidersError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeCapacityProvidersErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeCapacityProvidersErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeCapacityProvidersErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeCapacityProvidersErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeClustersError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DescribeClustersError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeClustersErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeClustersErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeClustersErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeClustersErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeContainerInstancesError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::DescribeContainerInstancesError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeContainerInstancesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeContainerInstancesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DescribeContainerInstancesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeContainerInstancesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeContainerInstancesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeServicesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DescribeServicesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeServicesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeServicesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DescribeServicesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeServicesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeServicesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeTaskDefinitionError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DescribeTaskDefinitionError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeTaskDefinitionErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeTaskDefinitionErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeTaskDefinitionErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeTaskDefinitionErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeTasksError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DescribeTasksError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeTasksErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeTasksErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DescribeTasksErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeTasksErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeTasksErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DescribeTaskSetsError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DescribeTaskSetsError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DescribeTaskSetsErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::DescribeTaskSetsErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DescribeTaskSetsErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::DescribeTaskSetsErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::DescribeTaskSetsErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DescribeTaskSetsErrorKind::ServiceNotActiveError(inner) => {
Error::ServiceNotActiveError(inner)
}
crate::error::DescribeTaskSetsErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::DescribeTaskSetsErrorKind::UnsupportedFeatureError(inner) => {
Error::UnsupportedFeatureError(inner)
}
crate::error::DescribeTaskSetsErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::DiscoverPollEndpointError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::DiscoverPollEndpointError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::DiscoverPollEndpointErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::DiscoverPollEndpointErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::DiscoverPollEndpointErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ExecuteCommandError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ExecuteCommandError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ExecuteCommandErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::ExecuteCommandErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ExecuteCommandErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ExecuteCommandErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ExecuteCommandErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ExecuteCommandErrorKind::TargetNotConnectedError(inner) => {
Error::TargetNotConnectedError(inner)
}
crate::error::ExecuteCommandErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListAccountSettingsError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListAccountSettingsError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListAccountSettingsErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListAccountSettingsErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListAccountSettingsErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListAccountSettingsErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListAttributesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListAttributesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListAttributesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ListAttributesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListAttributesErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListClustersError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListClustersError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListClustersErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListClustersErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListClustersErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListClustersErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListContainerInstancesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListContainerInstancesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListContainerInstancesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListContainerInstancesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ListContainerInstancesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListContainerInstancesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListContainerInstancesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListServicesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListServicesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListServicesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListServicesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ListServicesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListServicesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListServicesErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListTagsForResourceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListTagsForResourceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListTagsForResourceErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListTagsForResourceErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ListTagsForResourceErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListTagsForResourceErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListTagsForResourceErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListTaskDefinitionFamiliesError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::ListTaskDefinitionFamiliesError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListTaskDefinitionFamiliesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListTaskDefinitionFamiliesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListTaskDefinitionFamiliesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListTaskDefinitionFamiliesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListTaskDefinitionsError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListTaskDefinitionsError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListTaskDefinitionsErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::ListTaskDefinitionsErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListTaskDefinitionsErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::ListTaskDefinitionsErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::ListTasksError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::ListTasksError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::ListTasksErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::ListTasksErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::ListTasksErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::ListTasksErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::ListTasksErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::ListTasksErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::PutAccountSettingError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::PutAccountSettingError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::PutAccountSettingErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::PutAccountSettingErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::PutAccountSettingErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::PutAccountSettingErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::PutAccountSettingDefaultError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::PutAccountSettingDefaultError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::PutAccountSettingDefaultErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::PutAccountSettingDefaultErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::PutAccountSettingDefaultErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::PutAccountSettingDefaultErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::PutAttributesError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::PutAttributesError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::PutAttributesErrorKind::AttributeLimitExceededError(inner) => {
Error::AttributeLimitExceededError(inner)
}
crate::error::PutAttributesErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::PutAttributesErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::PutAttributesErrorKind::TargetNotFoundError(inner) => {
Error::TargetNotFoundError(inner)
}
crate::error::PutAttributesErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::PutClusterCapacityProvidersError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::PutClusterCapacityProvidersError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::PutClusterCapacityProvidersErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::PutClusterCapacityProvidersErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::PutClusterCapacityProvidersErrorKind::InvalidParameterError(
inner,
) => Error::InvalidParameterError(inner),
crate::error::PutClusterCapacityProvidersErrorKind::ResourceInUseError(inner) => {
Error::ResourceInUseError(inner)
}
crate::error::PutClusterCapacityProvidersErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::PutClusterCapacityProvidersErrorKind::UpdateInProgressError(
inner,
) => Error::UpdateInProgressError(inner),
crate::error::PutClusterCapacityProvidersErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::RegisterContainerInstanceError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::RegisterContainerInstanceError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::RegisterContainerInstanceErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::RegisterContainerInstanceErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::RegisterContainerInstanceErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::RegisterContainerInstanceErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::RegisterTaskDefinitionError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::RegisterTaskDefinitionError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::RegisterTaskDefinitionErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::RegisterTaskDefinitionErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::RegisterTaskDefinitionErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::RegisterTaskDefinitionErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::RunTaskError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::RunTaskError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::RunTaskErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::RunTaskErrorKind::BlockedError(inner) => Error::BlockedError(inner),
crate::error::RunTaskErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::RunTaskErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::RunTaskErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::RunTaskErrorKind::PlatformTaskDefinitionIncompatibilityError(
inner,
) => Error::PlatformTaskDefinitionIncompatibilityError(inner),
crate::error::RunTaskErrorKind::PlatformUnknownError(inner) => {
Error::PlatformUnknownError(inner)
}
crate::error::RunTaskErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::RunTaskErrorKind::UnsupportedFeatureError(inner) => {
Error::UnsupportedFeatureError(inner)
}
crate::error::RunTaskErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::StartTaskError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::StartTaskError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::StartTaskErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::StartTaskErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::StartTaskErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::StartTaskErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::StartTaskErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::StopTaskError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::StopTaskError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::StopTaskErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::StopTaskErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::StopTaskErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::StopTaskErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::StopTaskErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::SubmitAttachmentStateChangesError>>
for Error
{
fn from(
err: smithy_http::result::SdkError<crate::error::SubmitAttachmentStateChangesError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::SubmitAttachmentStateChangesErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::SubmitAttachmentStateChangesErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::SubmitAttachmentStateChangesErrorKind::InvalidParameterError(
inner,
) => Error::InvalidParameterError(inner),
crate::error::SubmitAttachmentStateChangesErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::SubmitAttachmentStateChangesErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::SubmitContainerStateChangeError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::SubmitContainerStateChangeError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::SubmitContainerStateChangeErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::SubmitContainerStateChangeErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::SubmitContainerStateChangeErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::SubmitContainerStateChangeErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::SubmitTaskStateChangeError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::SubmitTaskStateChangeError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::SubmitTaskStateChangeErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::SubmitTaskStateChangeErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::SubmitTaskStateChangeErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::SubmitTaskStateChangeErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::SubmitTaskStateChangeErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::TagResourceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::TagResourceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::TagResourceErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::TagResourceErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::TagResourceErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::TagResourceErrorKind::ResourceNotFoundError(inner) => {
Error::ResourceNotFoundError(inner)
}
crate::error::TagResourceErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::TagResourceErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UntagResourceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UntagResourceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UntagResourceErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UntagResourceErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UntagResourceErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UntagResourceErrorKind::ResourceNotFoundError(inner) => {
Error::ResourceNotFoundError(inner)
}
crate::error::UntagResourceErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UntagResourceErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateCapacityProviderError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateCapacityProviderError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateCapacityProviderErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateCapacityProviderErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UpdateCapacityProviderErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateCapacityProviderErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateClusterError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateClusterError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateClusterErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateClusterErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UpdateClusterErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UpdateClusterErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateClusterErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateClusterSettingsError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateClusterSettingsError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateClusterSettingsErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateClusterSettingsErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UpdateClusterSettingsErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UpdateClusterSettingsErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateClusterSettingsErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateContainerAgentError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateContainerAgentError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateContainerAgentErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateContainerAgentErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UpdateContainerAgentErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UpdateContainerAgentErrorKind::MissingVersionError(inner) => {
Error::MissingVersionError(inner)
}
crate::error::UpdateContainerAgentErrorKind::NoUpdateAvailableError(inner) => {
Error::NoUpdateAvailableError(inner)
}
crate::error::UpdateContainerAgentErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateContainerAgentErrorKind::UpdateInProgressError(inner) => {
Error::UpdateInProgressError(inner)
}
crate::error::UpdateContainerAgentErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateContainerInstancesStateError>>
for Error
{
fn from(
err: smithy_http::result::SdkError<crate::error::UpdateContainerInstancesStateError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateContainerInstancesStateErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateContainerInstancesStateErrorKind::ClusterNotFoundError(
inner,
) => Error::ClusterNotFoundError(inner),
crate::error::UpdateContainerInstancesStateErrorKind::InvalidParameterError(
inner,
) => Error::InvalidParameterError(inner),
crate::error::UpdateContainerInstancesStateErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateContainerInstancesStateErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateServiceError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateServiceError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, ..} => match err.kind {
crate::error::UpdateServiceErrorKind::AccessDeniedError(inner) => Error::AccessDeniedError(inner),
crate::error::UpdateServiceErrorKind::ClientError(inner) => Error::ClientError(inner),
crate::error::UpdateServiceErrorKind::ClusterNotFoundError(inner) => Error::ClusterNotFoundError(inner),
crate::error::UpdateServiceErrorKind::InvalidParameterError(inner) => Error::InvalidParameterError(inner),
crate::error::UpdateServiceErrorKind::PlatformTaskDefinitionIncompatibilityError(inner) => Error::PlatformTaskDefinitionIncompatibilityError(inner),
crate::error::UpdateServiceErrorKind::PlatformUnknownError(inner) => Error::PlatformUnknownError(inner),
crate::error::UpdateServiceErrorKind::ServerError(inner) => Error::ServerError(inner),
crate::error::UpdateServiceErrorKind::ServiceNotActiveError(inner) => Error::ServiceNotActiveError(inner),
crate::error::UpdateServiceErrorKind::ServiceNotFoundError(inner) => Error::ServiceNotFoundError(inner),
crate::error::UpdateServiceErrorKind::Unhandled(inner) => Error::Unhandled(inner),
}
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateServicePrimaryTaskSetError>> for Error {
fn from(
err: smithy_http::result::SdkError<crate::error::UpdateServicePrimaryTaskSetError>,
) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateServicePrimaryTaskSetErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::InvalidParameterError(
inner,
) => Error::InvalidParameterError(inner),
crate::error::UpdateServicePrimaryTaskSetErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::ServiceNotActiveError(
inner,
) => Error::ServiceNotActiveError(inner),
crate::error::UpdateServicePrimaryTaskSetErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::TaskSetNotFoundError(inner) => {
Error::TaskSetNotFoundError(inner)
}
crate::error::UpdateServicePrimaryTaskSetErrorKind::UnsupportedFeatureError(
inner,
) => Error::UnsupportedFeatureError(inner),
crate::error::UpdateServicePrimaryTaskSetErrorKind::Unhandled(inner) => {
Error::Unhandled(inner)
}
},
_ => Error::Unhandled(err.into()),
}
}
}
impl From<smithy_http::result::SdkError<crate::error::UpdateTaskSetError>> for Error {
fn from(err: smithy_http::result::SdkError<crate::error::UpdateTaskSetError>) -> Self {
match err {
smithy_http::result::SdkError::ServiceError { err, .. } => match err.kind {
crate::error::UpdateTaskSetErrorKind::AccessDeniedError(inner) => {
Error::AccessDeniedError(inner)
}
crate::error::UpdateTaskSetErrorKind::ClientError(inner) => {
Error::ClientError(inner)
}
crate::error::UpdateTaskSetErrorKind::ClusterNotFoundError(inner) => {
Error::ClusterNotFoundError(inner)
}
crate::error::UpdateTaskSetErrorKind::InvalidParameterError(inner) => {
Error::InvalidParameterError(inner)
}
crate::error::UpdateTaskSetErrorKind::ServerError(inner) => {
Error::ServerError(inner)
}
crate::error::UpdateTaskSetErrorKind::ServiceNotActiveError(inner) => {
Error::ServiceNotActiveError(inner)
}
crate::error::UpdateTaskSetErrorKind::ServiceNotFoundError(inner) => {
Error::ServiceNotFoundError(inner)
}
crate::error::UpdateTaskSetErrorKind::TaskSetNotFoundError(inner) => {
Error::TaskSetNotFoundError(inner)
}
crate::error::UpdateTaskSetErrorKind::UnsupportedFeatureError(inner) => {
Error::UnsupportedFeatureError(inner)
}
crate::error::UpdateTaskSetErrorKind::Unhandled(inner) => Error::Unhandled(inner),
},
_ => Error::Unhandled(err.into()),
}
}
}
impl std::error::Error for Error {}
|
use serde_json::Value;
use crate::validator::{
scope::ScopedSchema,
state::ValidationState,
types::{validate_as_ipv4, validate_as_ipv6},
};
// https://github.com/balena-os/meta-balena/blob/v2.29.2/meta-resin-common/recipes-connectivity/resin-net-config/resin-net-config/resin-net-config#L34-L39
//
// This dnsmasq server address can be pretty complex:
//
// --server=[/[<domain>]/[domain/]][<ipaddr>[#<port>][@<source-ip>|<interface>[#<port>]]
//
// For now, we're going to validate it as either ipv4 or ipv6.
pub fn validate_as_dnsmasq_address(scope: &ScopedSchema, data: &Value) -> ValidationState {
let state = validate_as_ipv4(scope, data);
if state.is_valid() {
return state;
}
validate_as_ipv6(scope, data)
}
|
use cpu::Cpu;
use mmu::Mmu;
// Below are the macros for loading the value of a register (reg2) into another
// register (reg1).
macro_rules! ldrr (
([ $($fname:ident $reg1:ident $reg2:ident),+ ]) => (
$(
pub fn $fname (cpu: &mut Cpu) {
cpu.register.$reg1 = cpu.register.$reg2;
cpu.register.m = 1;
cpu.register.t = 4;
}
)+
);
)
ldrr!([ldrr_bb b b, ldrr_bc b c, ldrr_bd b d, ldrr_be b e, ldrr_bh b h, ldrr_bl b l, ldrr_ba b a])
ldrr!([ldrr_cb c b, ldrr_cc c c, ldrr_cd c d, ldrr_ce c e, ldrr_ch c h, ldrr_cl c l, ldrr_ca c a])
ldrr!([ldrr_db d b, ldrr_dc d c, ldrr_dd d d, ldrr_de d e, ldrr_dh d h, ldrr_dl d l, ldrr_da d a])
ldrr!([ldrr_eb e b, ldrr_ec e c, ldrr_ed e d, ldrr_ee e e, ldrr_eh e h, ldrr_el e l, ldrr_ea e a])
ldrr!([ldrr_hb h b, ldrr_hc h c, ldrr_hd h d, ldrr_he h e, ldrr_hh h h, ldrr_hl h l, ldrr_ha h a])
ldrr!([ldrr_lb l b, ldrr_lc l c, ldrr_ld l d, ldrr_le l e, ldrr_lh l h, ldrr_ll l l, ldrr_la l a])
ldrr!([ldrr_ab a b, ldrr_ac a c, ldrr_ad a d, ldrr_ae a e, ldrr_ah a h, ldrr_al a l, ldrr_aa a a])
// Some macros for loading the bytes pointed to by the L and H registers into another register.
macro_rules! ldrhlm (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
cpu.register.$reg = mmu.rb(addr);
cpu.register.m = 2;
cpu.register.t = 8;
}
);
)
ldrhlm!(ldrhlm_b b)
ldrhlm!(ldrhlm_c c)
ldrhlm!(ldrhlm_d d)
ldrhlm!(ldrhlm_e e)
ldrhlm!(ldrhlm_h h)
ldrhlm!(ldrhlm_l l)
ldrhlm!(ldrhlm_a a)
// Macros that write data in registers to address pointed to by register L and H.
macro_rules! ldhlmr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
mmu.wb(addr, cpu.register.$reg);
cpu.register.m=2;
cpu.register.t=8;
}
);
)
ldhlmr!(ldhlmr_b b)
ldhlmr!(ldhlmr_c c)
ldhlmr!(ldhlmr_d d)
ldhlmr!(ldhlmr_e e)
ldhlmr!(ldhlmr_h h)
ldhlmr!(ldhlmr_l l)
ldhlmr!(ldhlmr_a a)
// Macros for reading byte pointed to by program counter into registers.
macro_rules! ldrn (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.$reg = mmu.rb(cpu.register.pc);
cpu.register.pc += 1;
cpu.register.m = 2;
cpu.register.t = 8;
}
);
)
ldrn!(ldrn_b b)
ldrn!(ldrn_c c)
ldrn!(ldrn_d d)
ldrn!(ldrn_e e)
ldrn!(ldrn_h h)
ldrn!(ldrn_l l)
ldrn!(ldrn_a a)
// Read byte at address pointed to by PC, then write that into address pointed to
// by H<<8 + L.
pub fn ldhl_mn (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
mmu.wb(addr, mmu.rb(cpu.register.pc));
cpu.register.pc += 1;
cpu.register.m = 3;
cpu.register.t = 12;
}
// Macros for writing bytes into fancy offsets and addresses with A data.
macro_rules! ld_a (
($fname:ident $addr:expr) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
mmu.wb($addr, cpu.register.a);
cpu.register.m = 2;
cpu.register.t = 8;
}
);
)
ld_a!(ldbc_ma ((cpu.register.b as u16) << 8) + cpu.register.c as u16)
ld_a!(ldde_ma ((cpu.register.d as u16) << 8) + cpu.register.e as u16)
ld_a!(ldio_ca (0xff00 + cpu.register.c as u16))
// Macros for swapping values in registers with values pointed to by L and H.
macro_rules! swapr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
let tmp = cpu.register.$reg;
cpu.register.$reg = mmu.rb(hl(cpu));
mmu.wb(hl(cpu), tmp);
cpu.register.m = 4;
cpu.register.t = 16;
}
);
)
swapr!(swapr_b b)
swapr!(swapr_c c)
swapr!(swapr_d d)
swapr!(swapr_e e)
swapr!(swapr_h h)
swapr!(swapr_l l)
swapr!(swapr_a a)
// Bit manipulations macros. This could also be done with a more efficient macro, but maybe I'll clean
// this up later. For now, I just want to get all instructions to work.
macro_rules! bit (
($fname:ident $reg:ident $manip:expr) => (
pub fn $fname (cpu: &mut Cpu) {
fz(cpu.register.$reg & $manip, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
);
)
bit!(bit_0b b 0x01)
bit!(bit_0c c 0x01)
bit!(bit_0d d 0x01)
bit!(bit_0e e 0x01)
bit!(bit_0h h 0x01)
bit!(bit_0l l 0x01)
bit!(bit_0a a 0x01)
bit!(bit_1b b 0x02)
bit!(bit_1c c 0x02)
bit!(bit_1d d 0x02)
bit!(bit_1e e 0x02)
bit!(bit_1h h 0x02)
bit!(bit_1l l 0x02)
bit!(bit_1a a 0x02)
bit!(bit_2b b 0x04)
bit!(bit_2c c 0x04)
bit!(bit_2d d 0x04)
bit!(bit_2e e 0x04)
bit!(bit_2h h 0x04)
bit!(bit_2l l 0x04)
bit!(bit_2a a 0x04)
bit!(bit_3b b 0x08)
bit!(bit_3c c 0x08)
bit!(bit_3d d 0x08)
bit!(bit_3e e 0x08)
bit!(bit_3h h 0x08)
bit!(bit_3l l 0x08)
bit!(bit_3a a 0x08)
bit!(bit_4b b 0x10)
bit!(bit_4c c 0x10)
bit!(bit_4d d 0x10)
bit!(bit_4e e 0x10)
bit!(bit_4h h 0x10)
bit!(bit_4l l 0x10)
bit!(bit_4a a 0x10)
bit!(bit_5b b 0x20)
bit!(bit_5c c 0x20)
bit!(bit_5d d 0x20)
bit!(bit_5e e 0x20)
bit!(bit_5h h 0x20)
bit!(bit_5l l 0x20)
bit!(bit_5a a 0x20)
bit!(bit_6b b 0x40)
bit!(bit_6c c 0x40)
bit!(bit_6d d 0x40)
bit!(bit_6e e 0x40)
bit!(bit_6h h 0x40)
bit!(bit_6l l 0x40)
bit!(bit_6a a 0x40)
bit!(bit_7b b 0x80)
bit!(bit_7c c 0x80)
bit!(bit_7d d 0x80)
bit!(bit_7e e 0x80)
bit!(bit_7h h 0x80)
bit!(bit_7l l 0x80)
bit!(bit_7a a 0x80)
macro_rules! bitm (
($fname:ident $manip:expr) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = (hl(cpu)) & $manip;
fz(mmu.rb(addr), false, cpu);
cpu.register.m = 3;
cpu.register.t = 12;
}
);
)
bitm!(bit_0m 0x01)
bitm!(bit_1m 0x02)
bitm!(bit_2m 0x04)
bitm!(bit_3m 0x08)
bitm!(bit_4m 0x10)
bitm!(bit_5m 0x20)
bitm!(bit_6m 0x40)
bitm!(bit_7m 0x80)
// Logical AND with A register.
macro_rules! andr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu) {
cpu.register.a &= cpu.register.$reg;
fz(cpu.register.a, false, cpu);
cpu.register.m = 1;
cpu.register.t = 4;
}
);
)
andr!(andr_b b)
andr!(andr_c c)
andr!(andr_d d)
andr!(andr_e e)
andr!(andr_h h)
andr!(andr_l l)
andr!(andr_a a)
pub fn and_hl (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
cpu.register.a &= mmu.rb(addr);
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
pub fn and_n (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.a &= mmu.rb(cpu.register.pc);
cpu.register.pc += 1;
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
// Logical OR with A register.
macro_rules! orr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu) {
cpu.register.a |= cpu.register.$reg;
fz(cpu.register.a, false, cpu);
cpu.register.m = 1;
cpu.register.t = 4;
}
);
)
orr!(orr_b b)
orr!(orr_c c)
orr!(orr_d d)
orr!(orr_e e)
orr!(orr_h h)
orr!(orr_l l)
orr!(orr_a a)
pub fn or_hl (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
cpu.register.a |= mmu.rb(addr);
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
pub fn or_n (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.a |= mmu.rb(cpu.register.pc);
cpu.register.pc += 1;
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
// Logical XOR with A register.
macro_rules! xorr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu) {
cpu.register.a ^= cpu.register.$reg;
fz(cpu.register.a, false, cpu);
cpu.register.m = 1;
cpu.register.t = 4;
}
);
)
xorr!(xorr_b b)
xorr!(xorr_c c)
xorr!(xorr_d d)
xorr!(xorr_e e)
xorr!(xorr_h h)
xorr!(xorr_l l)
xorr!(xorr_a a)
pub fn xor_hl (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
cpu.register.a ^= mmu.rb(addr);
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
pub fn xor_n (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.a ^= mmu.rb(cpu.register.pc);
cpu.register.pc += 1;
fz(cpu.register.a, false, cpu);
cpu.register.m = 2;
cpu.register.t = 8;
}
// Compare with register A functions.
macro_rules! cmpr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu) {
let result = (cpu.register.a as int) - (cpu.register.$reg as int);
fz(result as u8, true, cpu);
if result < 0 { cpu.register.f |= 0x10; }
cpu.register.m = 1;
cpu.register.t = 4;
}
);
)
cmpr!(cmpr_b b)
cmpr!(cmpr_c c)
cmpr!(cmpr_d d)
cmpr!(cmpr_e e)
cmpr!(cmpr_h h)
cmpr!(cmpr_l l)
cmpr!(cmpr_a a)
pub fn cmp_hl (cpu: &mut Cpu, mmu: &mut Mmu) {
let addr = hl(cpu);
let result = (cpu.register.a as int) - (mmu.rb(addr) as int);
fz(result as u8, true, cpu);
if result < 0 { cpu.register.f |= 0x10; }
cpu.register.m = 2;
cpu.register.t = 8;
}
pub fn cmp_n (cpu: &mut Cpu, mmu: &mut Mmu) {
let result = (cpu.register.a as int) - (mmu.rb(cpu.register.pc) as int);
cpu.register.pc += 1;
fz(result as u8, true, cpu);
if result < 0 { cpu.register.f |= 0x10; }
cpu.register.m = 2;
cpu.register.t = 8;
}
// Stack functions.
macro_rules! push (
($fname:ident $reg1:ident $reg2:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.sp -= 1;
mmu.wb(cpu.register.sp, cpu.register.$reg1);
cpu.register.sp -= 1;
mmu.wb(cpu.register.sp, cpu.register.$reg2);
cpu.register.m = 3;
cpu.register.t = 12;
}
);
)
push!(push_bc b c)
push!(push_de d e)
push!(push_hl h l)
push!(push_af a f)
macro_rules! pop (
($fname:ident $reg1:ident $reg2:ident) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.$reg2 = mmu.rb(cpu.register.sp);
cpu.register.sp += 1;
cpu.register.$reg1 = mmu.rb(cpu.register.sp);
cpu.register.sp += 1;
cpu.register.m = 3;
cpu.register.t = 12;
}
);
)
pop!(pop_bc b c)
pop!(pop_de d e)
pop!(pop_hl h l)
pop!(pop_af a f)
// PC move and jump operations.
pub fn jmp_nn (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.pc = mmu.rw(cpu.register.pc);
cpu.register.m = 3;
cpu.register.t = 12;
}
pub fn jmp_hl (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.pc = hl(cpu);
cpu.register.m = 1;
cpu.register.t = 4;
}
macro_rules! jmp (
($fname:ident $test:expr) => (
pub fn $fname (cpu: &mut Cpu, mmu: &mut Mmu) {
cpu.register.m = 3;
cpu.register.t = 12;
if $test {
cpu.register.pc = mmu.rw(cpu.register.pc);
cpu.register.m += 1;
cpu.register.t += 4;
} else { cpu.register.pc += 2; }
}
);
)
jmp!(jmp_nznn (cpu.register.f & 0x80 == 0x00))
jmp!(jmp_znn (cpu.register.f & 0x80 == 0x80))
jmp!(jmp_ncnn (cpu.register.f & 0x10 == 0x00))
jmp!(jmp_cnn (cpu.register.f & 0x10 == 0x10))
// Data processing functions.
macro_rules! addr (
($fname:ident $reg:ident) => (
pub fn $fname (cpu: &mut Cpu) {
let result = (cpu.register.a as int) + (cpu.register.$reg as int);
cpu.register.a = (result as u8);
fz(cpu.register.a, false, cpu);
if result > 255 { cpu.register.f |= 0x10; }
cpu.register.m = 1;
cpu.register.t = 4;
}
);
)
addr!(addr_b b)
addr!(addr_c c)
addr!(addr_d d)
addr!(addr_e e)
addr!(addr_h h)
addr!(addr_l l)
addr!(addr_a a)
fn fz (i: u8, is_sub: bool, cpu: &mut Cpu) {
cpu.register.f = 0;
if i == 0 { cpu.register.f |= 0x80; }
if is_sub { cpu.register.f |= 0x40; }
}
fn hl (cpu: &mut Cpu) -> u16 {
((cpu.register.h as u16) << 8) + cpu.register.l as u16
}
// CPU operation switches.
pub fn nop (cpu: &mut Cpu) {
cpu.register.m = 1;
cpu.register.t = 4;
}
pub fn halt (cpu: &mut Cpu) {
cpu.register.halt = true;
cpu.register.m = 1;
cpu.register.t = 4;
}
pub fn di (cpu: &mut Cpu) {
cpu.register.ime = false;
cpu.register.m = 1;
cpu.register.t = 4;
}
pub fn ei (cpu: &mut Cpu) {
cpu.register.ime = true;
cpu.register.m = 1;
cpu.register.t = 4;
} |
#[doc = "Reader of register INTR_MASK"]
pub type R = crate::R<u32, super::INTR_MASK>;
#[doc = "Writer for register INTR_MASK"]
pub type W = crate::W<u32, super::INTR_MASK>;
#[doc = "Register INTR_MASK `reset()`'s with value 0"]
impl crate::ResetValue for super::INTR_MASK {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `DSM_EXIT`"]
pub type DSM_EXIT_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DSM_EXIT`"]
pub struct DSM_EXIT_W<'a> {
w: &'a mut W,
}
impl<'a> DSM_EXIT_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
self.w
}
}
#[doc = "Reader of field `DSM_ENTERED_INTR_MASK`"]
pub type DSM_ENTERED_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DSM_ENTERED_INTR_MASK`"]
pub struct DSM_ENTERED_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> DSM_ENTERED_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
self.w
}
}
#[doc = "Reader of field `DSM_EXITED_INTR_MASK`"]
pub type DSM_EXITED_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `DSM_EXITED_INTR_MASK`"]
pub struct DSM_EXITED_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> DSM_EXITED_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
self.w
}
}
#[doc = "Reader of field `XTAL_ON_INTR_MASK`"]
pub type XTAL_ON_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `XTAL_ON_INTR_MASK`"]
pub struct XTAL_ON_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> XTAL_ON_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
self.w
}
}
#[doc = "Reader of field `RCBLL_INTR_MASK`"]
pub type RCBLL_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RCBLL_INTR_MASK`"]
pub struct RCBLL_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> RCBLL_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
self.w
}
}
#[doc = "Reader of field `BLERD_ACTIVE_INTR_MASK`"]
pub type BLERD_ACTIVE_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `BLERD_ACTIVE_INTR_MASK`"]
pub struct BLERD_ACTIVE_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> BLERD_ACTIVE_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
self.w
}
}
#[doc = "Reader of field `RCB_INTR_MASK`"]
pub type RCB_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `RCB_INTR_MASK`"]
pub struct RCB_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> RCB_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
self.w
}
}
#[doc = "Reader of field `LL_INTR_MASK`"]
pub type LL_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LL_INTR_MASK`"]
pub struct LL_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> LL_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
self.w
}
}
#[doc = "Reader of field `GPIO_INTR_MASK`"]
pub type GPIO_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `GPIO_INTR_MASK`"]
pub struct GPIO_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> GPIO_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
self.w
}
}
#[doc = "Reader of field `EFUSE_INTR_MASK`"]
pub type EFUSE_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `EFUSE_INTR_MASK`"]
pub struct EFUSE_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> EFUSE_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
self.w
}
}
#[doc = "Reader of field `ENC_INTR_MASK`"]
pub type ENC_INTR_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `ENC_INTR_MASK`"]
pub struct ENC_INTR_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> ENC_INTR_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
self.w
}
}
#[doc = "Reader of field `HVLDO_LV_DETECT_POS_MASK`"]
pub type HVLDO_LV_DETECT_POS_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HVLDO_LV_DETECT_POS_MASK`"]
pub struct HVLDO_LV_DETECT_POS_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> HVLDO_LV_DETECT_POS_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
self.w
}
}
#[doc = "Reader of field `HVLDO_LV_DETECT_NEG_MASK`"]
pub type HVLDO_LV_DETECT_NEG_MASK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `HVLDO_LV_DETECT_NEG_MASK`"]
pub struct HVLDO_LV_DETECT_NEG_MASK_W<'a> {
w: &'a mut W,
}
impl<'a> HVLDO_LV_DETECT_NEG_MASK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
impl R {
#[doc = "Bit 0 - When the Link Layer is in Deep Sleep Mode, firmware can set this bit to wake the Link Layer."]
#[inline(always)]
pub fn dsm_exit(&self) -> DSM_EXIT_R {
DSM_EXIT_R::new((self.bits & 0x01) != 0)
}
#[doc = "Bit 1 - Masks the DSM Entered Interrupt, when disabled."]
#[inline(always)]
pub fn dsm_entered_intr_mask(&self) -> DSM_ENTERED_INTR_MASK_R {
DSM_ENTERED_INTR_MASK_R::new(((self.bits >> 1) & 0x01) != 0)
}
#[doc = "Bit 2 - Masks the DSM Exited Interrupt, when disabled."]
#[inline(always)]
pub fn dsm_exited_intr_mask(&self) -> DSM_EXITED_INTR_MASK_R {
DSM_EXITED_INTR_MASK_R::new(((self.bits >> 2) & 0x01) != 0)
}
#[doc = "Bit 3 - Masks the Crystal Stable Interrupt, when disabled."]
#[inline(always)]
pub fn xtal_on_intr_mask(&self) -> XTAL_ON_INTR_MASK_R {
XTAL_ON_INTR_MASK_R::new(((self.bits >> 3) & 0x01) != 0)
}
#[doc = "Bit 4 - Mask for RCBLL interrupt"]
#[inline(always)]
pub fn rcbll_intr_mask(&self) -> RCBLL_INTR_MASK_R {
RCBLL_INTR_MASK_R::new(((self.bits >> 4) & 0x01) != 0)
}
#[doc = "Bit 5 - Mask for CYBLERD55 Active Interrupt"]
#[inline(always)]
pub fn blerd_active_intr_mask(&self) -> BLERD_ACTIVE_INTR_MASK_R {
BLERD_ACTIVE_INTR_MASK_R::new(((self.bits >> 5) & 0x01) != 0)
}
#[doc = "Bit 6 - Mask for RCB interrupt"]
#[inline(always)]
pub fn rcb_intr_mask(&self) -> RCB_INTR_MASK_R {
RCB_INTR_MASK_R::new(((self.bits >> 6) & 0x01) != 0)
}
#[doc = "Bit 7 - Mask for LL interrupt"]
#[inline(always)]
pub fn ll_intr_mask(&self) -> LL_INTR_MASK_R {
LL_INTR_MASK_R::new(((self.bits >> 7) & 0x01) != 0)
}
#[doc = "Bit 8 - Mask for GPIO interrupt"]
#[inline(always)]
pub fn gpio_intr_mask(&self) -> GPIO_INTR_MASK_R {
GPIO_INTR_MASK_R::new(((self.bits >> 8) & 0x01) != 0)
}
#[doc = "Bit 9 - This bit enables the efuse interrupt to firmware"]
#[inline(always)]
pub fn efuse_intr_mask(&self) -> EFUSE_INTR_MASK_R {
EFUSE_INTR_MASK_R::new(((self.bits >> 9) & 0x01) != 0)
}
#[doc = "Bit 10 - Mask for Encryption interrupt"]
#[inline(always)]
pub fn enc_intr_mask(&self) -> ENC_INTR_MASK_R {
ENC_INTR_MASK_R::new(((self.bits >> 10) & 0x01) != 0)
}
#[doc = "Bit 11 - Mask for HVLDO LV Detector Rise edge interrupt"]
#[inline(always)]
pub fn hvldo_lv_detect_pos_mask(&self) -> HVLDO_LV_DETECT_POS_MASK_R {
HVLDO_LV_DETECT_POS_MASK_R::new(((self.bits >> 11) & 0x01) != 0)
}
#[doc = "Bit 12 - Mask for HVLDO LV Detector Fall edge interrupt"]
#[inline(always)]
pub fn hvldo_lv_detect_neg_mask(&self) -> HVLDO_LV_DETECT_NEG_MASK_R {
HVLDO_LV_DETECT_NEG_MASK_R::new(((self.bits >> 12) & 0x01) != 0)
}
}
impl W {
#[doc = "Bit 0 - When the Link Layer is in Deep Sleep Mode, firmware can set this bit to wake the Link Layer."]
#[inline(always)]
pub fn dsm_exit(&mut self) -> DSM_EXIT_W {
DSM_EXIT_W { w: self }
}
#[doc = "Bit 1 - Masks the DSM Entered Interrupt, when disabled."]
#[inline(always)]
pub fn dsm_entered_intr_mask(&mut self) -> DSM_ENTERED_INTR_MASK_W {
DSM_ENTERED_INTR_MASK_W { w: self }
}
#[doc = "Bit 2 - Masks the DSM Exited Interrupt, when disabled."]
#[inline(always)]
pub fn dsm_exited_intr_mask(&mut self) -> DSM_EXITED_INTR_MASK_W {
DSM_EXITED_INTR_MASK_W { w: self }
}
#[doc = "Bit 3 - Masks the Crystal Stable Interrupt, when disabled."]
#[inline(always)]
pub fn xtal_on_intr_mask(&mut self) -> XTAL_ON_INTR_MASK_W {
XTAL_ON_INTR_MASK_W { w: self }
}
#[doc = "Bit 4 - Mask for RCBLL interrupt"]
#[inline(always)]
pub fn rcbll_intr_mask(&mut self) -> RCBLL_INTR_MASK_W {
RCBLL_INTR_MASK_W { w: self }
}
#[doc = "Bit 5 - Mask for CYBLERD55 Active Interrupt"]
#[inline(always)]
pub fn blerd_active_intr_mask(&mut self) -> BLERD_ACTIVE_INTR_MASK_W {
BLERD_ACTIVE_INTR_MASK_W { w: self }
}
#[doc = "Bit 6 - Mask for RCB interrupt"]
#[inline(always)]
pub fn rcb_intr_mask(&mut self) -> RCB_INTR_MASK_W {
RCB_INTR_MASK_W { w: self }
}
#[doc = "Bit 7 - Mask for LL interrupt"]
#[inline(always)]
pub fn ll_intr_mask(&mut self) -> LL_INTR_MASK_W {
LL_INTR_MASK_W { w: self }
}
#[doc = "Bit 8 - Mask for GPIO interrupt"]
#[inline(always)]
pub fn gpio_intr_mask(&mut self) -> GPIO_INTR_MASK_W {
GPIO_INTR_MASK_W { w: self }
}
#[doc = "Bit 9 - This bit enables the efuse interrupt to firmware"]
#[inline(always)]
pub fn efuse_intr_mask(&mut self) -> EFUSE_INTR_MASK_W {
EFUSE_INTR_MASK_W { w: self }
}
#[doc = "Bit 10 - Mask for Encryption interrupt"]
#[inline(always)]
pub fn enc_intr_mask(&mut self) -> ENC_INTR_MASK_W {
ENC_INTR_MASK_W { w: self }
}
#[doc = "Bit 11 - Mask for HVLDO LV Detector Rise edge interrupt"]
#[inline(always)]
pub fn hvldo_lv_detect_pos_mask(&mut self) -> HVLDO_LV_DETECT_POS_MASK_W {
HVLDO_LV_DETECT_POS_MASK_W { w: self }
}
#[doc = "Bit 12 - Mask for HVLDO LV Detector Fall edge interrupt"]
#[inline(always)]
pub fn hvldo_lv_detect_neg_mask(&mut self) -> HVLDO_LV_DETECT_NEG_MASK_W {
HVLDO_LV_DETECT_NEG_MASK_W { w: self }
}
}
|
use lisp_core::lexpr;
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Debug)]
pub enum Error {
IoError(std::io::Error),
ParseError(lexpr::parse::Error),
UnexpectedType(lexpr::Value),
}
impl From<std::io::Error> for Error {
fn from(e: std::io::Error) -> Self {
Error::IoError(e)
}
}
impl From<lexpr::parse::Error> for Error {
fn from(e: lexpr::parse::Error) -> Self {
Error::ParseError(e)
}
}
|
mod config;
mod http;
mod kafka;
mod log;
mod metrics;
use crate::log::kflog;
use clap::ArgMatches;
use std::sync::Arc;
use tokio::sync::oneshot;
fn app_args<'a>() -> ArgMatches<'a> {
return clap::App::new("kprf")
.version(clap::crate_version!())
.about("Kafka Producer Proxy")
.arg(
clap::Arg::with_name("config")
.short("c")
.long("config")
.help("Config file path")
.takes_value(true),
)
.get_matches();
}
#[tokio::main]
async fn main() {
let args = app_args();
let cfg = config::KafkaProxyConfig::new(args);
let http_config = cfg.get_http_config();
let logger = kflog::new_logger(&cfg.get_output_file());
let http_server_config = http::server::Config::new(http_config.port());
let mut server = http::server::Server::new_from_config(http_server_config);
let ratelimiter = ratelimit::Limiter::new(cfg.get_ratelimit_config());
let (shutdown_tx, shutdown_rx) = oneshot::channel::<String>();
let (shutdown_metrics_tx, shutdown_metrics_rx) = oneshot::channel::<String>();
let kafka_producer = kafka::kafka::producer::new(cfg.get_kafka_config());
let metrics_server = metrics::metrics::Server::new(metrics::metrics::ServerConfig {
port: http_config.metrics_port(),
});
let metrics_shutdown_rx = metrics_server.start_server(logger.clone(), shutdown_metrics_rx);
// TODO(shmel1k): improve graceful shutdown behavior.
let main_server_shutdown_rx = server.start_server(
logger.clone(),
kafka_producer.clone(),
Arc::new(ratelimiter),
shutdown_rx,
);
tokio::select! {
_ = tokio::signal::ctrl_c() => {
slog::info!(logger, "shutting down application");
shutdown_tx.send(String::from("shutdown")).expect("failed to shutdown kafka-http server");
shutdown_metrics_tx.send(String::from("shutdown")).expect("failed to shutdown metrics-http server");
metrics_shutdown_rx.await.ok();
main_server_shutdown_rx.await.ok();
}
}
}
|
#[derive(Debug, PartialEq, Copy, Clone)]
pub enum Direction {
North,
South,
}
impl Default for Direction {
fn default() -> Direction {
Direction::North
}
}
#[derive(PartialEq, Debug, Clone)]
pub struct CardString {
pub color: String,
pub number: i32,
}
#[derive(PartialEq, Debug, Copy, Clone)]
pub enum Color {
Color1,
Color2,
Color3,
Color4,
Color5,
Color6,
}
#[derive(PartialEq, Debug, Copy, Clone)]
pub struct Card {
pub color: Color,
pub number: i32,
}
#[derive(PartialEq, Debug, Clone)]
pub enum ClaimStatus {
Unclaimed,
North,
South,
}
impl Default for ClaimStatus {
fn default() -> ClaimStatus {
ClaimStatus::Unclaimed
}
}
// #[derive(PartialEq)]
pub enum Message {
Blank,
PlayerDirection {
direction: Direction,
},
ColorNames {
colors: Vec<String>,
},
FlagClaimStatus {
flags_claimed: Vec<ClaimStatus>,
},
FlagStatus {
flag_num: u32,
direction: Direction,
cards: Vec<CardString>,
},
OpponentPlay {
number: i32,
card: CardString,
},
PlayerHand {
direction: Direction,
cards: Vec<CardString>,
},
PlayCard,
}
fn convert_direction(message: &str) -> Direction {
match message {
"north" => Direction::North,
"south" => Direction::South,
e => panic!("{} is not a direction flag.", e),
}
}
pub fn get_direction_string(direction: Direction) -> String {
match direction {
Direction::North => String::from("north"),
Direction::South => String::from("south"),
}
}
fn convert_claim_status(message: &str) -> ClaimStatus {
match message {
"north" => ClaimStatus::North,
"south" => ClaimStatus::South,
"unclaimed" => ClaimStatus::Unclaimed,
e => panic!("{} is not a Claim Status flag.", e),
}
}
fn convert_string_to_card(message: &str) -> CardString {
let split: Vec<&str> = message.split(',').collect();
let b = String::from(split[0]);
let c = split[1].parse::<i32>().unwrap();
CardString {
color: b,
number: c,
}
}
pub fn parse_message(message: String) -> Message {
let split: Vec<&str> = message.split_whitespace().collect();
match &split[..] {
&["go", "play-card"] => Message::PlayCard,
&["player", direction, "hand", ref cards..] if cards.len() <= 7 &&
(direction == "north" ||
direction == "south") => {
let mut player_cards = Vec::new();
for i in cards {
player_cards.push(convert_string_to_card(i));
}
Message::PlayerHand {
direction: convert_direction(direction),
cards: player_cards,
}
}
&["flag", flag, "cards", direction, ref cards..] if flag >= "1" && flag <= "9" &&
(direction == "north" ||
direction == "south") => {
let mut flags_cards = Vec::new();
let a = flag.parse::<u32>().unwrap();
for i in cards {
flags_cards.push(convert_string_to_card(i));
}
Message::FlagStatus {
flag_num: a,
direction: convert_direction(direction),
cards: flags_cards,
}
}
&["player", direction, "name"] if direction == "north" || direction == "south" => {
match direction {
"north" => Message::PlayerDirection { direction: Direction::North },
_ => Message::PlayerDirection { direction: Direction::South },
}
}
&["opponent", "play", flag, card] if flag >= "1" && flag <= "9" => {
let a = flag.parse::<i32>().unwrap();
Message::OpponentPlay {
number: a,
card: convert_string_to_card(card),
}
}
&["colors", ref colors..] if colors.len() == 6 => {
let mut colors_vec: Vec<String> = Vec::new();
for i in colors {
colors_vec.push(String::from(*i));
}
Message::ColorNames { colors: colors_vec }
}
&["flag", "claim-status", ref flag_claims..] if flag_claims.len() == 9 => {
let mut claims = Vec::new();
for i in flag_claims {
claims.push(convert_claim_status(i));
}
Message::FlagClaimStatus { flags_claimed: claims }
}
_ => Message::Blank,
}
}
#[cfg(test)]
mod test_parsing_messages {
use super::*;
#[test]
fn play_card_message() {
let x = parse_message(String::from("go play-card"));
match x {
Message::PlayCard => {}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn unknown_message_is_blank() {
let x = parse_message(String::from("this isn't a message"));
match x {
Message::Blank => {}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn opponent_play_message() {
let x = parse_message(String::from("opponent play 3 red,5"));
match x {
Message::OpponentPlay { number, card } => {
assert_eq!(String::from("red"), card.color);
assert_eq!(5, card.number);
assert_eq!(3, number);
}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn player_direction_message() {
let x = parse_message(String::from("player south name"));
match x {
Message::PlayerDirection { direction: Direction::South } => {}
_ => panic!("Wrong Card type."),
}
let x = parse_message(String::from("player north name"));
match x {
Message::PlayerDirection { direction: Direction::North } => {}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn color_names_message() {
let x = parse_message(String::from("colors a b c d e f"));
let color_vec = vec![String::from("a"),
String::from("b"),
String::from("c"),
String::from("d"),
String::from("e"),
String::from("f")];
match x {
Message::ColorNames { colors } => {
assert_eq!(color_vec, colors);
}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn flag_claim_message() {
let claim_vec = vec![ClaimStatus::North,
ClaimStatus::South,
ClaimStatus::Unclaimed,
ClaimStatus::Unclaimed,
ClaimStatus::South,
ClaimStatus::North,
ClaimStatus::South,
ClaimStatus::North,
ClaimStatus::Unclaimed];
let x = parse_message(String::from("flag claim-status north south unclaimed unclaimed \
south north south north unclaimed"));
match x {
Message::FlagClaimStatus { flags_claimed } => {
assert_eq!(claim_vec, flags_claimed);
}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn flag_card_message() {
let cards_vec = vec![CardString {
color: String::from("red"),
number: 3,
},
CardString {
color: String::from("blue"),
number: 9,
}];
let x = parse_message(String::from("flag 3 cards north red,3 blue,9"));
match x {
Message::FlagStatus { flag_num: 3, direction: Direction::North, cards } => {
assert_eq!(cards_vec, cards);
}
_ => panic!("Wrong Card type."),
}
}
#[test]
fn player_hand_message() {
let cards_vec = vec![CardString {
color: String::from("red"),
number: 3,
},
CardString {
color: String::from("blue"),
number: 6,
},
CardString {
color: String::from("green"),
number: 4,
}];
let x = parse_message(String::from("player north hand red,3 blue,6 green,4"));
match x {
Message::PlayerHand { direction: Direction::North, cards } => {
assert_eq!(cards_vec, cards);
}
_ => panic!("Wrong Card type."),
}
}
}
|
#![allow(clippy::wrong_self_convention)]
use super::vk;
use std::ffi::CStr;
use std::marker::PhantomData;
use std::ops::Deref;
use std::os::raw::{c_char, c_int, c_void};
use std::ptr;
pub trait Builder<'a> {
type Type;
fn builder() -> Self::Type;
}
impl<'a> Builder<'a> for vk::BaseOutStructure {
type Type = BaseOutStructureBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BaseOutStructureBuilder<'a> {
inner: vk::BaseOutStructure,
phantom: PhantomData<&'a vk::BaseOutStructure>,
}
impl<'a> BaseOutStructureBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut vk::BaseOutStructure) -> Self {
self.inner.p_next = p_next;
self
}
}
impl<'a> Deref for BaseOutStructureBuilder<'a> {
type Target = vk::BaseOutStructure;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BaseInStructure {
type Type = BaseInStructureBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BaseInStructureBuilder<'a> {
inner: vk::BaseInStructure,
phantom: PhantomData<&'a vk::BaseInStructure>,
}
impl<'a> BaseInStructureBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: &'a vk::BaseInStructure) -> Self {
self.inner.p_next = p_next;
self
}
}
impl<'a> Deref for BaseInStructureBuilder<'a> {
type Target = vk::BaseInStructure;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ApplicationInfo {
type Type = ApplicationInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ApplicationInfoBuilder<'a> {
inner: vk::ApplicationInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ApplicationInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_application_name(mut self, p_application_name: &'a CStr) -> Self {
self.inner.p_application_name = p_application_name.as_ptr();
self
}
pub fn application_version(mut self, application_version: u32) -> Self {
self.inner.application_version = application_version;
self
}
pub fn p_engine_name(mut self, p_engine_name: &'a CStr) -> Self {
self.inner.p_engine_name = p_engine_name.as_ptr();
self
}
pub fn engine_version(mut self, engine_version: u32) -> Self {
self.inner.engine_version = engine_version;
self
}
pub fn api_version(mut self, api_version: vk::Version) -> Self {
self.inner.api_version = api_version;
self
}
}
impl<'a> Deref for ApplicationInfoBuilder<'a> {
type Target = vk::ApplicationInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AllocationCallbacks {
type Type = AllocationCallbacksBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AllocationCallbacksBuilder<'a> {
inner: vk::AllocationCallbacks,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AllocationCallbacksBuilder<'a> {
pub fn p_user_data(mut self, p_user_data: *mut c_void) -> Self {
self.inner.p_user_data = p_user_data;
self
}
pub fn pfn_allocation(mut self, pfn_allocation: vk::FnAllocationFunction) -> Self {
self.inner.pfn_allocation = Some(pfn_allocation);
self
}
pub fn pfn_reallocation(mut self, pfn_reallocation: vk::FnReallocationFunction) -> Self {
self.inner.pfn_reallocation = Some(pfn_reallocation);
self
}
pub fn pfn_free(mut self, pfn_free: vk::FnFreeFunction) -> Self {
self.inner.pfn_free = Some(pfn_free);
self
}
pub fn pfn_internal_allocation(
mut self,
pfn_internal_allocation: Option<vk::FnInternalAllocationNotification>,
) -> Self {
self.inner.pfn_internal_allocation = pfn_internal_allocation;
self
}
pub fn pfn_internal_free(mut self, pfn_internal_free: Option<vk::FnInternalFreeNotification>) -> Self {
self.inner.pfn_internal_free = pfn_internal_free;
self
}
}
impl<'a> Deref for AllocationCallbacksBuilder<'a> {
type Target = vk::AllocationCallbacks;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceQueueCreateInfo {
type Type = DeviceQueueCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceQueueCreateInfoBuilder<'a> {
inner: vk::DeviceQueueCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceQueueCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DeviceQueueCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
self.inner.queue_family_index = queue_family_index;
self
}
pub fn p_queue_priorities(mut self, p_queue_priorities: &'a [f32]) -> Self {
self.inner.queue_count = p_queue_priorities.len() as u32;
self.inner.p_queue_priorities = p_queue_priorities.as_ptr();
self
}
}
impl<'a> Deref for DeviceQueueCreateInfoBuilder<'a> {
type Target = vk::DeviceQueueCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceCreateInfo {
type Type = DeviceCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceCreateInfoBuilder<'a> {
inner: vk::DeviceCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DeviceCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_queue_create_infos(mut self, p_queue_create_infos: &'a [vk::DeviceQueueCreateInfo]) -> Self {
self.inner.queue_create_info_count = p_queue_create_infos.len() as u32;
self.inner.p_queue_create_infos = p_queue_create_infos.as_ptr();
self
}
pub fn pp_enabled_layer_names(mut self, pp_enabled_layer_names: &'a [*const c_char]) -> Self {
self.inner.enabled_layer_count = pp_enabled_layer_names.len() as u32;
self.inner.pp_enabled_layer_names = pp_enabled_layer_names.as_ptr();
self
}
pub fn pp_enabled_extension_names(mut self, pp_enabled_extension_names: &'a [*const c_char]) -> Self {
self.inner.enabled_extension_count = pp_enabled_extension_names.len() as u32;
self.inner.pp_enabled_extension_names = pp_enabled_extension_names.as_ptr();
self
}
pub fn p_enabled_features(mut self, p_enabled_features: Option<&'a vk::PhysicalDeviceFeatures>) -> Self {
self.inner.p_enabled_features = p_enabled_features.map_or(ptr::null(), |p| p);
self
}
}
impl<'a> Deref for DeviceCreateInfoBuilder<'a> {
type Target = vk::DeviceCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::InstanceCreateInfo {
type Type = InstanceCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct InstanceCreateInfoBuilder<'a> {
inner: vk::InstanceCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> InstanceCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::InstanceCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_application_info(mut self, p_application_info: Option<&'a vk::ApplicationInfo>) -> Self {
self.inner.p_application_info = p_application_info.map_or(ptr::null(), |p| p);
self
}
pub fn pp_enabled_layer_names(mut self, pp_enabled_layer_names: &'a [*const c_char]) -> Self {
self.inner.enabled_layer_count = pp_enabled_layer_names.len() as u32;
self.inner.pp_enabled_layer_names = pp_enabled_layer_names.as_ptr();
self
}
pub fn pp_enabled_extension_names(mut self, pp_enabled_extension_names: &'a [*const c_char]) -> Self {
self.inner.enabled_extension_count = pp_enabled_extension_names.len() as u32;
self.inner.pp_enabled_extension_names = pp_enabled_extension_names.as_ptr();
self
}
}
impl<'a> Deref for InstanceCreateInfoBuilder<'a> {
type Target = vk::InstanceCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryAllocateInfo {
type Type = MemoryAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryAllocateInfoBuilder<'a> {
inner: vk::MemoryAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn allocation_size(mut self, allocation_size: vk::DeviceSize) -> Self {
self.inner.allocation_size = allocation_size;
self
}
pub fn memory_type_index(mut self, memory_type_index: u32) -> Self {
self.inner.memory_type_index = memory_type_index;
self
}
}
impl<'a> Deref for MemoryAllocateInfoBuilder<'a> {
type Target = vk::MemoryAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MappedMemoryRange {
type Type = MappedMemoryRangeBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MappedMemoryRangeBuilder<'a> {
inner: vk::MappedMemoryRange,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MappedMemoryRangeBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn offset(mut self, offset: vk::DeviceSize) -> Self {
self.inner.offset = offset;
self
}
pub fn size(mut self, size: vk::DeviceSize) -> Self {
self.inner.size = size;
self
}
}
impl<'a> Deref for MappedMemoryRangeBuilder<'a> {
type Target = vk::MappedMemoryRange;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::WriteDescriptorSet {
type Type = WriteDescriptorSetBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct WriteDescriptorSetBuilder<'a> {
inner: vk::WriteDescriptorSet,
phantom: PhantomData<&'a c_void>,
}
impl<'a> WriteDescriptorSetBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn dst_set(mut self, dst_set: vk::DescriptorSet) -> Self {
self.inner.dst_set = Some(dst_set);
self
}
pub fn dst_binding(mut self, dst_binding: u32) -> Self {
self.inner.dst_binding = dst_binding;
self
}
pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
self.inner.dst_array_element = dst_array_element;
self
}
pub fn p_image_info(mut self, p_image_info: &'a [vk::DescriptorImageInfo]) -> Self {
self.inner.descriptor_count = p_image_info.len() as u32;
self.inner.p_image_info = p_image_info.as_ptr();
self
}
pub fn p_buffer_info(mut self, p_buffer_info: &'a [vk::DescriptorBufferInfo]) -> Self {
self.inner.descriptor_count = p_buffer_info.len() as u32;
self.inner.p_buffer_info = p_buffer_info.as_ptr();
self
}
pub fn p_texel_buffer_view(mut self, p_texel_buffer_view: &'a [vk::BufferView]) -> Self {
self.inner.descriptor_count = p_texel_buffer_view.len() as u32;
self.inner.p_texel_buffer_view = p_texel_buffer_view.as_ptr();
self
}
pub fn descriptor_type(mut self, descriptor_type: vk::DescriptorType) -> Self {
self.inner.descriptor_type = descriptor_type;
self
}
}
impl<'a> Deref for WriteDescriptorSetBuilder<'a> {
type Target = vk::WriteDescriptorSet;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CopyDescriptorSet {
type Type = CopyDescriptorSetBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CopyDescriptorSetBuilder<'a> {
inner: vk::CopyDescriptorSet,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CopyDescriptorSetBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_set(mut self, src_set: vk::DescriptorSet) -> Self {
self.inner.src_set = Some(src_set);
self
}
pub fn src_binding(mut self, src_binding: u32) -> Self {
self.inner.src_binding = src_binding;
self
}
pub fn src_array_element(mut self, src_array_element: u32) -> Self {
self.inner.src_array_element = src_array_element;
self
}
pub fn dst_set(mut self, dst_set: vk::DescriptorSet) -> Self {
self.inner.dst_set = Some(dst_set);
self
}
pub fn dst_binding(mut self, dst_binding: u32) -> Self {
self.inner.dst_binding = dst_binding;
self
}
pub fn dst_array_element(mut self, dst_array_element: u32) -> Self {
self.inner.dst_array_element = dst_array_element;
self
}
pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
self.inner.descriptor_count = descriptor_count;
self
}
}
impl<'a> Deref for CopyDescriptorSetBuilder<'a> {
type Target = vk::CopyDescriptorSet;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferCreateInfo {
type Type = BufferCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferCreateInfoBuilder<'a> {
inner: vk::BufferCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::BufferCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn size(mut self, size: vk::DeviceSize) -> Self {
self.inner.size = size;
self
}
pub fn usage(mut self, usage: vk::BufferUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn sharing_mode(mut self, sharing_mode: vk::SharingMode) -> Self {
self.inner.sharing_mode = sharing_mode;
self
}
pub fn p_queue_family_indices(mut self, p_queue_family_indices: &'a [u32]) -> Self {
self.inner.queue_family_index_count = p_queue_family_indices.len() as u32;
self.inner.p_queue_family_indices = p_queue_family_indices.as_ptr();
self
}
}
impl<'a> Deref for BufferCreateInfoBuilder<'a> {
type Target = vk::BufferCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferViewCreateInfo {
type Type = BufferViewCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferViewCreateInfoBuilder<'a> {
inner: vk::BufferViewCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferViewCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::BufferViewCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn offset(mut self, offset: vk::DeviceSize) -> Self {
self.inner.offset = offset;
self
}
pub fn range(mut self, range: vk::DeviceSize) -> Self {
self.inner.range = range;
self
}
}
impl<'a> Deref for BufferViewCreateInfoBuilder<'a> {
type Target = vk::BufferViewCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryBarrier {
type Type = MemoryBarrierBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryBarrierBuilder<'a> {
inner: vk::MemoryBarrier,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryBarrierBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_access_mask(mut self, src_access_mask: vk::AccessFlags) -> Self {
self.inner.src_access_mask = src_access_mask;
self
}
pub fn dst_access_mask(mut self, dst_access_mask: vk::AccessFlags) -> Self {
self.inner.dst_access_mask = dst_access_mask;
self
}
}
impl<'a> Deref for MemoryBarrierBuilder<'a> {
type Target = vk::MemoryBarrier;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferMemoryBarrier {
type Type = BufferMemoryBarrierBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferMemoryBarrierBuilder<'a> {
inner: vk::BufferMemoryBarrier,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferMemoryBarrierBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_access_mask(mut self, src_access_mask: vk::AccessFlags) -> Self {
self.inner.src_access_mask = src_access_mask;
self
}
pub fn dst_access_mask(mut self, dst_access_mask: vk::AccessFlags) -> Self {
self.inner.dst_access_mask = dst_access_mask;
self
}
pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
self.inner.src_queue_family_index = src_queue_family_index;
self
}
pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
self.inner.dst_queue_family_index = dst_queue_family_index;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
pub fn offset(mut self, offset: vk::DeviceSize) -> Self {
self.inner.offset = offset;
self
}
pub fn size(mut self, size: vk::DeviceSize) -> Self {
self.inner.size = size;
self
}
}
impl<'a> Deref for BufferMemoryBarrierBuilder<'a> {
type Target = vk::BufferMemoryBarrier;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageMemoryBarrier {
type Type = ImageMemoryBarrierBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageMemoryBarrierBuilder<'a> {
inner: vk::ImageMemoryBarrier,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageMemoryBarrierBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_access_mask(mut self, src_access_mask: vk::AccessFlags) -> Self {
self.inner.src_access_mask = src_access_mask;
self
}
pub fn dst_access_mask(mut self, dst_access_mask: vk::AccessFlags) -> Self {
self.inner.dst_access_mask = dst_access_mask;
self
}
pub fn old_layout(mut self, old_layout: vk::ImageLayout) -> Self {
self.inner.old_layout = old_layout;
self
}
pub fn new_layout(mut self, new_layout: vk::ImageLayout) -> Self {
self.inner.new_layout = new_layout;
self
}
pub fn src_queue_family_index(mut self, src_queue_family_index: u32) -> Self {
self.inner.src_queue_family_index = src_queue_family_index;
self
}
pub fn dst_queue_family_index(mut self, dst_queue_family_index: u32) -> Self {
self.inner.dst_queue_family_index = dst_queue_family_index;
self
}
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
pub fn subresource_range(mut self, subresource_range: vk::ImageSubresourceRange) -> Self {
self.inner.subresource_range = subresource_range;
self
}
}
impl<'a> Deref for ImageMemoryBarrierBuilder<'a> {
type Target = vk::ImageMemoryBarrier;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageCreateInfo {
type Type = ImageCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageCreateInfoBuilder<'a> {
inner: vk::ImageCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ImageCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn image_type(mut self, image_type: vk::ImageType) -> Self {
self.inner.image_type = image_type;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn extent(mut self, extent: vk::Extent3D) -> Self {
self.inner.extent = extent;
self
}
pub fn mip_levels(mut self, mip_levels: u32) -> Self {
self.inner.mip_levels = mip_levels;
self
}
pub fn array_layers(mut self, array_layers: u32) -> Self {
self.inner.array_layers = array_layers;
self
}
pub fn samples(mut self, samples: vk::SampleCountFlags) -> Self {
self.inner.samples = samples;
self
}
pub fn tiling(mut self, tiling: vk::ImageTiling) -> Self {
self.inner.tiling = tiling;
self
}
pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn sharing_mode(mut self, sharing_mode: vk::SharingMode) -> Self {
self.inner.sharing_mode = sharing_mode;
self
}
pub fn p_queue_family_indices(mut self, p_queue_family_indices: &'a [u32]) -> Self {
self.inner.queue_family_index_count = p_queue_family_indices.len() as u32;
self.inner.p_queue_family_indices = p_queue_family_indices.as_ptr();
self
}
pub fn initial_layout(mut self, initial_layout: vk::ImageLayout) -> Self {
self.inner.initial_layout = initial_layout;
self
}
}
impl<'a> Deref for ImageCreateInfoBuilder<'a> {
type Target = vk::ImageCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageViewCreateInfo {
type Type = ImageViewCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageViewCreateInfoBuilder<'a> {
inner: vk::ImageViewCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageViewCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ImageViewCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
pub fn view_type(mut self, view_type: vk::ImageViewType) -> Self {
self.inner.view_type = view_type;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn components(mut self, components: vk::ComponentMapping) -> Self {
self.inner.components = components;
self
}
pub fn subresource_range(mut self, subresource_range: vk::ImageSubresourceRange) -> Self {
self.inner.subresource_range = subresource_range;
self
}
}
impl<'a> Deref for ImageViewCreateInfoBuilder<'a> {
type Target = vk::ImageViewCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SparseBufferMemoryBindInfo {
type Type = SparseBufferMemoryBindInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SparseBufferMemoryBindInfoBuilder<'a> {
inner: vk::SparseBufferMemoryBindInfo,
phantom: PhantomData<&'a vk::SparseMemoryBind>,
}
impl<'a> SparseBufferMemoryBindInfoBuilder<'a> {
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
pub fn p_binds(mut self, p_binds: &'a [vk::SparseMemoryBind]) -> Self {
self.inner.bind_count = p_binds.len() as u32;
self.inner.p_binds = p_binds.as_ptr();
self
}
}
impl<'a> Deref for SparseBufferMemoryBindInfoBuilder<'a> {
type Target = vk::SparseBufferMemoryBindInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SparseImageOpaqueMemoryBindInfo {
type Type = SparseImageOpaqueMemoryBindInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SparseImageOpaqueMemoryBindInfoBuilder<'a> {
inner: vk::SparseImageOpaqueMemoryBindInfo,
phantom: PhantomData<&'a vk::SparseMemoryBind>,
}
impl<'a> SparseImageOpaqueMemoryBindInfoBuilder<'a> {
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
pub fn p_binds(mut self, p_binds: &'a [vk::SparseMemoryBind]) -> Self {
self.inner.bind_count = p_binds.len() as u32;
self.inner.p_binds = p_binds.as_ptr();
self
}
}
impl<'a> Deref for SparseImageOpaqueMemoryBindInfoBuilder<'a> {
type Target = vk::SparseImageOpaqueMemoryBindInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SparseImageMemoryBindInfo {
type Type = SparseImageMemoryBindInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SparseImageMemoryBindInfoBuilder<'a> {
inner: vk::SparseImageMemoryBindInfo,
phantom: PhantomData<&'a vk::SparseImageMemoryBind>,
}
impl<'a> SparseImageMemoryBindInfoBuilder<'a> {
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
pub fn p_binds(mut self, p_binds: &'a [vk::SparseImageMemoryBind]) -> Self {
self.inner.bind_count = p_binds.len() as u32;
self.inner.p_binds = p_binds.as_ptr();
self
}
}
impl<'a> Deref for SparseImageMemoryBindInfoBuilder<'a> {
type Target = vk::SparseImageMemoryBindInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindSparseInfo {
type Type = BindSparseInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindSparseInfoBuilder<'a> {
inner: vk::BindSparseInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindSparseInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphores(mut self, p_wait_semaphores: &'a [vk::Semaphore]) -> Self {
self.inner.wait_semaphore_count = p_wait_semaphores.len() as u32;
self.inner.p_wait_semaphores = p_wait_semaphores.as_ptr();
self
}
pub fn p_buffer_binds(mut self, p_buffer_binds: &'a [vk::SparseBufferMemoryBindInfo]) -> Self {
self.inner.buffer_bind_count = p_buffer_binds.len() as u32;
self.inner.p_buffer_binds = p_buffer_binds.as_ptr();
self
}
pub fn p_image_opaque_binds(mut self, p_image_opaque_binds: &'a [vk::SparseImageOpaqueMemoryBindInfo]) -> Self {
self.inner.image_opaque_bind_count = p_image_opaque_binds.len() as u32;
self.inner.p_image_opaque_binds = p_image_opaque_binds.as_ptr();
self
}
pub fn p_image_binds(mut self, p_image_binds: &'a [vk::SparseImageMemoryBindInfo]) -> Self {
self.inner.image_bind_count = p_image_binds.len() as u32;
self.inner.p_image_binds = p_image_binds.as_ptr();
self
}
pub fn p_signal_semaphores(mut self, p_signal_semaphores: &'a [vk::Semaphore]) -> Self {
self.inner.signal_semaphore_count = p_signal_semaphores.len() as u32;
self.inner.p_signal_semaphores = p_signal_semaphores.as_ptr();
self
}
}
impl<'a> Deref for BindSparseInfoBuilder<'a> {
type Target = vk::BindSparseInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ShaderModuleCreateInfo {
type Type = ShaderModuleCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ShaderModuleCreateInfoBuilder<'a> {
inner: vk::ShaderModuleCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ShaderModuleCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ShaderModuleCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn code_size(mut self, code_size: usize) -> Self {
self.inner.code_size = code_size;
self
}
pub fn p_code(mut self, p_code: *const u32) -> Self {
self.inner.p_code = p_code;
self
}
}
impl<'a> Deref for ShaderModuleCreateInfoBuilder<'a> {
type Target = vk::ShaderModuleCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorSetLayoutBinding {
type Type = DescriptorSetLayoutBindingBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorSetLayoutBindingBuilder<'a> {
inner: vk::DescriptorSetLayoutBinding,
phantom: PhantomData<&'a Option<vk::Sampler>>,
}
impl<'a> DescriptorSetLayoutBindingBuilder<'a> {
pub fn binding(mut self, binding: u32) -> Self {
self.inner.binding = binding;
self
}
pub fn descriptor_type(mut self, descriptor_type: vk::DescriptorType) -> Self {
self.inner.descriptor_type = descriptor_type;
self
}
pub fn descriptor_count(mut self, descriptor_count: u32) -> Self {
self.inner.descriptor_count = descriptor_count;
self
}
pub fn p_immutable_samplers(mut self, p_immutable_samplers: &'a [vk::Sampler]) -> Self {
self.inner.descriptor_count = p_immutable_samplers.len() as u32;
self.inner.p_immutable_samplers = p_immutable_samplers.as_ptr();
self
}
pub fn stage_flags(mut self, stage_flags: vk::ShaderStageFlags) -> Self {
self.inner.stage_flags = stage_flags;
self
}
}
impl<'a> Deref for DescriptorSetLayoutBindingBuilder<'a> {
type Target = vk::DescriptorSetLayoutBinding;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorSetLayoutCreateInfo {
type Type = DescriptorSetLayoutCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorSetLayoutCreateInfoBuilder<'a> {
inner: vk::DescriptorSetLayoutCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorSetLayoutCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DescriptorSetLayoutCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_bindings(mut self, p_bindings: &'a [vk::DescriptorSetLayoutBinding]) -> Self {
self.inner.binding_count = p_bindings.len() as u32;
self.inner.p_bindings = p_bindings.as_ptr();
self
}
}
impl<'a> Deref for DescriptorSetLayoutCreateInfoBuilder<'a> {
type Target = vk::DescriptorSetLayoutCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorPoolCreateInfo {
type Type = DescriptorPoolCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorPoolCreateInfoBuilder<'a> {
inner: vk::DescriptorPoolCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorPoolCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DescriptorPoolCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn max_sets(mut self, max_sets: u32) -> Self {
self.inner.max_sets = max_sets;
self
}
pub fn p_pool_sizes(mut self, p_pool_sizes: &'a [vk::DescriptorPoolSize]) -> Self {
self.inner.pool_size_count = p_pool_sizes.len() as u32;
self.inner.p_pool_sizes = p_pool_sizes.as_ptr();
self
}
}
impl<'a> Deref for DescriptorPoolCreateInfoBuilder<'a> {
type Target = vk::DescriptorPoolCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorSetAllocateInfo {
type Type = DescriptorSetAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorSetAllocateInfoBuilder<'a> {
inner: vk::DescriptorSetAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorSetAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn descriptor_pool(mut self, descriptor_pool: vk::DescriptorPool) -> Self {
self.inner.descriptor_pool = Some(descriptor_pool);
self
}
pub fn p_set_layouts(mut self, p_set_layouts: &'a [vk::DescriptorSetLayout]) -> Self {
self.inner.descriptor_set_count = p_set_layouts.len() as u32;
self.inner.p_set_layouts = p_set_layouts.as_ptr();
self
}
}
impl<'a> Deref for DescriptorSetAllocateInfoBuilder<'a> {
type Target = vk::DescriptorSetAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SpecializationInfo {
type Type = SpecializationInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SpecializationInfoBuilder<'a> {
inner: vk::SpecializationInfo,
phantom: PhantomData<&'a vk::SpecializationMapEntry>,
}
impl<'a> SpecializationInfoBuilder<'a> {
pub fn p_map_entries(mut self, p_map_entries: &'a [vk::SpecializationMapEntry]) -> Self {
self.inner.map_entry_count = p_map_entries.len() as u32;
self.inner.p_map_entries = p_map_entries.as_ptr();
self
}
pub fn data_size(mut self, data_size: usize) -> Self {
self.inner.data_size = data_size;
self
}
pub fn p_data(mut self, p_data: *const c_void) -> Self {
self.inner.p_data = p_data;
self
}
}
impl<'a> Deref for SpecializationInfoBuilder<'a> {
type Target = vk::SpecializationInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineShaderStageCreateInfo {
type Type = PipelineShaderStageCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineShaderStageCreateInfoBuilder<'a> {
inner: vk::PipelineShaderStageCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineShaderStageCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineShaderStageCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn stage(mut self, stage: vk::ShaderStageFlags) -> Self {
self.inner.stage = stage;
self
}
pub fn module(mut self, module: vk::ShaderModule) -> Self {
self.inner.module = Some(module);
self
}
pub fn p_name(mut self, p_name: &'a CStr) -> Self {
self.inner.p_name = p_name.as_ptr();
self
}
pub fn p_specialization_info(mut self, p_specialization_info: Option<&'a vk::SpecializationInfo>) -> Self {
self.inner.p_specialization_info = p_specialization_info.map_or(ptr::null(), |p| p);
self
}
}
impl<'a> Deref for PipelineShaderStageCreateInfoBuilder<'a> {
type Target = vk::PipelineShaderStageCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ComputePipelineCreateInfo {
type Type = ComputePipelineCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ComputePipelineCreateInfoBuilder<'a> {
inner: vk::ComputePipelineCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ComputePipelineCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn stage(mut self, stage: vk::PipelineShaderStageCreateInfo) -> Self {
self.inner.stage = stage;
self
}
pub fn layout(mut self, layout: vk::PipelineLayout) -> Self {
self.inner.layout = Some(layout);
self
}
pub fn base_pipeline_handle(mut self, base_pipeline_handle: Option<vk::Pipeline>) -> Self {
self.inner.base_pipeline_handle = base_pipeline_handle;
self
}
pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
self.inner.base_pipeline_index = base_pipeline_index;
self
}
}
impl<'a> Deref for ComputePipelineCreateInfoBuilder<'a> {
type Target = vk::ComputePipelineCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineVertexInputStateCreateInfo {
type Type = PipelineVertexInputStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineVertexInputStateCreateInfoBuilder<'a> {
inner: vk::PipelineVertexInputStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineVertexInputStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineVertexInputStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_vertex_binding_descriptions(
mut self,
p_vertex_binding_descriptions: &'a [vk::VertexInputBindingDescription],
) -> Self {
self.inner.vertex_binding_description_count = p_vertex_binding_descriptions.len() as u32;
self.inner.p_vertex_binding_descriptions = p_vertex_binding_descriptions.as_ptr();
self
}
pub fn p_vertex_attribute_descriptions(
mut self,
p_vertex_attribute_descriptions: &'a [vk::VertexInputAttributeDescription],
) -> Self {
self.inner.vertex_attribute_description_count = p_vertex_attribute_descriptions.len() as u32;
self.inner.p_vertex_attribute_descriptions = p_vertex_attribute_descriptions.as_ptr();
self
}
}
impl<'a> Deref for PipelineVertexInputStateCreateInfoBuilder<'a> {
type Target = vk::PipelineVertexInputStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineInputAssemblyStateCreateInfo {
type Type = PipelineInputAssemblyStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineInputAssemblyStateCreateInfoBuilder<'a> {
inner: vk::PipelineInputAssemblyStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineInputAssemblyStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineInputAssemblyStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn topology(mut self, topology: vk::PrimitiveTopology) -> Self {
self.inner.topology = topology;
self
}
pub fn primitive_restart_enable(mut self, primitive_restart_enable: bool) -> Self {
self.inner.primitive_restart_enable = if primitive_restart_enable { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PipelineInputAssemblyStateCreateInfoBuilder<'a> {
type Target = vk::PipelineInputAssemblyStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineTessellationStateCreateInfo {
type Type = PipelineTessellationStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineTessellationStateCreateInfoBuilder<'a> {
inner: vk::PipelineTessellationStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineTessellationStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineTessellationStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn patch_control_points(mut self, patch_control_points: u32) -> Self {
self.inner.patch_control_points = patch_control_points;
self
}
}
impl<'a> Deref for PipelineTessellationStateCreateInfoBuilder<'a> {
type Target = vk::PipelineTessellationStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportStateCreateInfo {
type Type = PipelineViewportStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportStateCreateInfoBuilder<'a> {
inner: vk::PipelineViewportStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineViewportStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn viewport_count(mut self, viewport_count: u32) -> Self {
self.inner.viewport_count = viewport_count;
self
}
pub fn p_viewports(mut self, p_viewports: &'a [vk::Viewport]) -> Self {
self.inner.viewport_count = p_viewports.len() as u32;
self.inner.p_viewports = p_viewports.as_ptr();
self
}
pub fn scissor_count(mut self, scissor_count: u32) -> Self {
self.inner.scissor_count = scissor_count;
self
}
pub fn p_scissors(mut self, p_scissors: &'a [vk::Rect2D]) -> Self {
self.inner.scissor_count = p_scissors.len() as u32;
self.inner.p_scissors = p_scissors.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportStateCreateInfoBuilder<'a> {
type Target = vk::PipelineViewportStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationStateCreateInfo {
type Type = PipelineRasterizationStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationStateCreateInfoBuilder<'a> {
inner: vk::PipelineRasterizationStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineRasterizationStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn depth_clamp_enable(mut self, depth_clamp_enable: bool) -> Self {
self.inner.depth_clamp_enable = if depth_clamp_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn rasterizer_discard_enable(mut self, rasterizer_discard_enable: bool) -> Self {
self.inner.rasterizer_discard_enable = if rasterizer_discard_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn polygon_mode(mut self, polygon_mode: vk::PolygonMode) -> Self {
self.inner.polygon_mode = polygon_mode;
self
}
pub fn cull_mode(mut self, cull_mode: vk::CullModeFlags) -> Self {
self.inner.cull_mode = cull_mode;
self
}
pub fn front_face(mut self, front_face: vk::FrontFace) -> Self {
self.inner.front_face = front_face;
self
}
pub fn depth_bias_enable(mut self, depth_bias_enable: bool) -> Self {
self.inner.depth_bias_enable = if depth_bias_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn depth_bias_constant_factor(mut self, depth_bias_constant_factor: f32) -> Self {
self.inner.depth_bias_constant_factor = depth_bias_constant_factor;
self
}
pub fn depth_bias_clamp(mut self, depth_bias_clamp: f32) -> Self {
self.inner.depth_bias_clamp = depth_bias_clamp;
self
}
pub fn depth_bias_slope_factor(mut self, depth_bias_slope_factor: f32) -> Self {
self.inner.depth_bias_slope_factor = depth_bias_slope_factor;
self
}
pub fn line_width(mut self, line_width: f32) -> Self {
self.inner.line_width = line_width;
self
}
}
impl<'a> Deref for PipelineRasterizationStateCreateInfoBuilder<'a> {
type Target = vk::PipelineRasterizationStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineMultisampleStateCreateInfo {
type Type = PipelineMultisampleStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineMultisampleStateCreateInfoBuilder<'a> {
inner: vk::PipelineMultisampleStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineMultisampleStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineMultisampleStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn rasterization_samples(mut self, rasterization_samples: vk::SampleCountFlags) -> Self {
self.inner.rasterization_samples = rasterization_samples;
self
}
pub fn sample_shading_enable(mut self, sample_shading_enable: bool) -> Self {
self.inner.sample_shading_enable = if sample_shading_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn min_sample_shading(mut self, min_sample_shading: f32) -> Self {
self.inner.min_sample_shading = min_sample_shading;
self
}
pub fn p_sample_mask(mut self, p_sample_mask: *const vk::SampleMask) -> Self {
self.inner.p_sample_mask = p_sample_mask;
self
}
pub fn alpha_to_coverage_enable(mut self, alpha_to_coverage_enable: bool) -> Self {
self.inner.alpha_to_coverage_enable = if alpha_to_coverage_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn alpha_to_one_enable(mut self, alpha_to_one_enable: bool) -> Self {
self.inner.alpha_to_one_enable = if alpha_to_one_enable { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PipelineMultisampleStateCreateInfoBuilder<'a> {
type Target = vk::PipelineMultisampleStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineColorBlendStateCreateInfo {
type Type = PipelineColorBlendStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineColorBlendStateCreateInfoBuilder<'a> {
inner: vk::PipelineColorBlendStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineColorBlendStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineColorBlendStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn logic_op_enable(mut self, logic_op_enable: bool) -> Self {
self.inner.logic_op_enable = if logic_op_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn logic_op(mut self, logic_op: vk::LogicOp) -> Self {
self.inner.logic_op = logic_op;
self
}
pub fn p_attachments(mut self, p_attachments: &'a [vk::PipelineColorBlendAttachmentState]) -> Self {
self.inner.attachment_count = p_attachments.len() as u32;
self.inner.p_attachments = p_attachments.as_ptr();
self
}
}
impl<'a> Deref for PipelineColorBlendStateCreateInfoBuilder<'a> {
type Target = vk::PipelineColorBlendStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineDynamicStateCreateInfo {
type Type = PipelineDynamicStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineDynamicStateCreateInfoBuilder<'a> {
inner: vk::PipelineDynamicStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineDynamicStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineDynamicStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_dynamic_states(mut self, p_dynamic_states: &'a [vk::DynamicState]) -> Self {
self.inner.dynamic_state_count = p_dynamic_states.len() as u32;
self.inner.p_dynamic_states = p_dynamic_states.as_ptr();
self
}
}
impl<'a> Deref for PipelineDynamicStateCreateInfoBuilder<'a> {
type Target = vk::PipelineDynamicStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineDepthStencilStateCreateInfo {
type Type = PipelineDepthStencilStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineDepthStencilStateCreateInfoBuilder<'a> {
inner: vk::PipelineDepthStencilStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineDepthStencilStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineDepthStencilStateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn depth_test_enable(mut self, depth_test_enable: bool) -> Self {
self.inner.depth_test_enable = if depth_test_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn depth_write_enable(mut self, depth_write_enable: bool) -> Self {
self.inner.depth_write_enable = if depth_write_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn depth_compare_op(mut self, depth_compare_op: vk::CompareOp) -> Self {
self.inner.depth_compare_op = depth_compare_op;
self
}
pub fn depth_bounds_test_enable(mut self, depth_bounds_test_enable: bool) -> Self {
self.inner.depth_bounds_test_enable = if depth_bounds_test_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn stencil_test_enable(mut self, stencil_test_enable: bool) -> Self {
self.inner.stencil_test_enable = if stencil_test_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn front(mut self, front: vk::StencilOpState) -> Self {
self.inner.front = front;
self
}
pub fn back(mut self, back: vk::StencilOpState) -> Self {
self.inner.back = back;
self
}
pub fn min_depth_bounds(mut self, min_depth_bounds: f32) -> Self {
self.inner.min_depth_bounds = min_depth_bounds;
self
}
pub fn max_depth_bounds(mut self, max_depth_bounds: f32) -> Self {
self.inner.max_depth_bounds = max_depth_bounds;
self
}
}
impl<'a> Deref for PipelineDepthStencilStateCreateInfoBuilder<'a> {
type Target = vk::PipelineDepthStencilStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GraphicsPipelineCreateInfo {
type Type = GraphicsPipelineCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GraphicsPipelineCreateInfoBuilder<'a> {
inner: vk::GraphicsPipelineCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GraphicsPipelineCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_stages(mut self, p_stages: &'a [vk::PipelineShaderStageCreateInfo]) -> Self {
self.inner.stage_count = p_stages.len() as u32;
self.inner.p_stages = p_stages.as_ptr();
self
}
pub fn p_vertex_input_state(
mut self,
p_vertex_input_state: Option<&'a vk::PipelineVertexInputStateCreateInfo>,
) -> Self {
self.inner.p_vertex_input_state = p_vertex_input_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_input_assembly_state(
mut self,
p_input_assembly_state: Option<&'a vk::PipelineInputAssemblyStateCreateInfo>,
) -> Self {
self.inner.p_input_assembly_state = p_input_assembly_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_tessellation_state(
mut self,
p_tessellation_state: Option<&'a vk::PipelineTessellationStateCreateInfo>,
) -> Self {
self.inner.p_tessellation_state = p_tessellation_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_viewport_state(mut self, p_viewport_state: Option<&'a vk::PipelineViewportStateCreateInfo>) -> Self {
self.inner.p_viewport_state = p_viewport_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_rasterization_state(
mut self,
p_rasterization_state: &'a vk::PipelineRasterizationStateCreateInfo,
) -> Self {
self.inner.p_rasterization_state = p_rasterization_state;
self
}
pub fn p_multisample_state(
mut self,
p_multisample_state: Option<&'a vk::PipelineMultisampleStateCreateInfo>,
) -> Self {
self.inner.p_multisample_state = p_multisample_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_depth_stencil_state(
mut self,
p_depth_stencil_state: Option<&'a vk::PipelineDepthStencilStateCreateInfo>,
) -> Self {
self.inner.p_depth_stencil_state = p_depth_stencil_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_color_blend_state(
mut self,
p_color_blend_state: Option<&'a vk::PipelineColorBlendStateCreateInfo>,
) -> Self {
self.inner.p_color_blend_state = p_color_blend_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_dynamic_state(mut self, p_dynamic_state: Option<&'a vk::PipelineDynamicStateCreateInfo>) -> Self {
self.inner.p_dynamic_state = p_dynamic_state.map_or(ptr::null(), |p| p);
self
}
pub fn layout(mut self, layout: vk::PipelineLayout) -> Self {
self.inner.layout = Some(layout);
self
}
pub fn render_pass(mut self, render_pass: vk::RenderPass) -> Self {
self.inner.render_pass = Some(render_pass);
self
}
pub fn subpass(mut self, subpass: u32) -> Self {
self.inner.subpass = subpass;
self
}
pub fn base_pipeline_handle(mut self, base_pipeline_handle: Option<vk::Pipeline>) -> Self {
self.inner.base_pipeline_handle = base_pipeline_handle;
self
}
pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
self.inner.base_pipeline_index = base_pipeline_index;
self
}
}
impl<'a> Deref for GraphicsPipelineCreateInfoBuilder<'a> {
type Target = vk::GraphicsPipelineCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCacheCreateInfo {
type Type = PipelineCacheCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCacheCreateInfoBuilder<'a> {
inner: vk::PipelineCacheCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCacheCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCacheCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn initial_data_size(mut self, initial_data_size: usize) -> Self {
self.inner.initial_data_size = initial_data_size;
self
}
pub fn p_initial_data(mut self, p_initial_data: *const c_void) -> Self {
self.inner.p_initial_data = p_initial_data;
self
}
}
impl<'a> Deref for PipelineCacheCreateInfoBuilder<'a> {
type Target = vk::PipelineCacheCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineLayoutCreateInfo {
type Type = PipelineLayoutCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineLayoutCreateInfoBuilder<'a> {
inner: vk::PipelineLayoutCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineLayoutCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineLayoutCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_set_layouts(mut self, p_set_layouts: &'a [vk::DescriptorSetLayout]) -> Self {
self.inner.set_layout_count = p_set_layouts.len() as u32;
self.inner.p_set_layouts = p_set_layouts.as_ptr();
self
}
pub fn p_push_constant_ranges(mut self, p_push_constant_ranges: &'a [vk::PushConstantRange]) -> Self {
self.inner.push_constant_range_count = p_push_constant_ranges.len() as u32;
self.inner.p_push_constant_ranges = p_push_constant_ranges.as_ptr();
self
}
}
impl<'a> Deref for PipelineLayoutCreateInfoBuilder<'a> {
type Target = vk::PipelineLayoutCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SamplerCreateInfo {
type Type = SamplerCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SamplerCreateInfoBuilder<'a> {
inner: vk::SamplerCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SamplerCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::SamplerCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn mag_filter(mut self, mag_filter: vk::Filter) -> Self {
self.inner.mag_filter = mag_filter;
self
}
pub fn min_filter(mut self, min_filter: vk::Filter) -> Self {
self.inner.min_filter = min_filter;
self
}
pub fn mipmap_mode(mut self, mipmap_mode: vk::SamplerMipmapMode) -> Self {
self.inner.mipmap_mode = mipmap_mode;
self
}
pub fn address_mode_u(mut self, address_mode_u: vk::SamplerAddressMode) -> Self {
self.inner.address_mode_u = address_mode_u;
self
}
pub fn address_mode_v(mut self, address_mode_v: vk::SamplerAddressMode) -> Self {
self.inner.address_mode_v = address_mode_v;
self
}
pub fn address_mode_w(mut self, address_mode_w: vk::SamplerAddressMode) -> Self {
self.inner.address_mode_w = address_mode_w;
self
}
pub fn mip_lod_bias(mut self, mip_lod_bias: f32) -> Self {
self.inner.mip_lod_bias = mip_lod_bias;
self
}
pub fn anisotropy_enable(mut self, anisotropy_enable: bool) -> Self {
self.inner.anisotropy_enable = if anisotropy_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn max_anisotropy(mut self, max_anisotropy: f32) -> Self {
self.inner.max_anisotropy = max_anisotropy;
self
}
pub fn compare_enable(mut self, compare_enable: bool) -> Self {
self.inner.compare_enable = if compare_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn compare_op(mut self, compare_op: vk::CompareOp) -> Self {
self.inner.compare_op = compare_op;
self
}
pub fn min_lod(mut self, min_lod: f32) -> Self {
self.inner.min_lod = min_lod;
self
}
pub fn max_lod(mut self, max_lod: f32) -> Self {
self.inner.max_lod = max_lod;
self
}
pub fn border_color(mut self, border_color: vk::BorderColor) -> Self {
self.inner.border_color = border_color;
self
}
pub fn unnormalized_coordinates(mut self, unnormalized_coordinates: bool) -> Self {
self.inner.unnormalized_coordinates = if unnormalized_coordinates { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for SamplerCreateInfoBuilder<'a> {
type Target = vk::SamplerCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandPoolCreateInfo {
type Type = CommandPoolCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandPoolCreateInfoBuilder<'a> {
inner: vk::CommandPoolCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandPoolCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::CommandPoolCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
self.inner.queue_family_index = queue_family_index;
self
}
}
impl<'a> Deref for CommandPoolCreateInfoBuilder<'a> {
type Target = vk::CommandPoolCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandBufferAllocateInfo {
type Type = CommandBufferAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandBufferAllocateInfoBuilder<'a> {
inner: vk::CommandBufferAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandBufferAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn command_pool(mut self, command_pool: vk::CommandPool) -> Self {
self.inner.command_pool = Some(command_pool);
self
}
pub fn level(mut self, level: vk::CommandBufferLevel) -> Self {
self.inner.level = level;
self
}
pub fn command_buffer_count(mut self, command_buffer_count: u32) -> Self {
self.inner.command_buffer_count = command_buffer_count;
self
}
}
impl<'a> Deref for CommandBufferAllocateInfoBuilder<'a> {
type Target = vk::CommandBufferAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandBufferInheritanceInfo {
type Type = CommandBufferInheritanceInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandBufferInheritanceInfoBuilder<'a> {
inner: vk::CommandBufferInheritanceInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandBufferInheritanceInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn render_pass(mut self, render_pass: Option<vk::RenderPass>) -> Self {
self.inner.render_pass = render_pass;
self
}
pub fn subpass(mut self, subpass: u32) -> Self {
self.inner.subpass = subpass;
self
}
pub fn framebuffer(mut self, framebuffer: Option<vk::Framebuffer>) -> Self {
self.inner.framebuffer = framebuffer;
self
}
pub fn occlusion_query_enable(mut self, occlusion_query_enable: bool) -> Self {
self.inner.occlusion_query_enable = if occlusion_query_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn query_flags(mut self, query_flags: vk::QueryControlFlags) -> Self {
self.inner.query_flags = query_flags;
self
}
pub fn pipeline_statistics(mut self, pipeline_statistics: vk::QueryPipelineStatisticFlags) -> Self {
self.inner.pipeline_statistics = pipeline_statistics;
self
}
}
impl<'a> Deref for CommandBufferInheritanceInfoBuilder<'a> {
type Target = vk::CommandBufferInheritanceInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandBufferBeginInfo {
type Type = CommandBufferBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandBufferBeginInfoBuilder<'a> {
inner: vk::CommandBufferBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandBufferBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::CommandBufferUsageFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_inheritance_info(mut self, p_inheritance_info: Option<&'a vk::CommandBufferInheritanceInfo>) -> Self {
self.inner.p_inheritance_info = p_inheritance_info.map_or(ptr::null(), |p| p);
self
}
}
impl<'a> Deref for CommandBufferBeginInfoBuilder<'a> {
type Target = vk::CommandBufferBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassBeginInfo {
type Type = RenderPassBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassBeginInfoBuilder<'a> {
inner: vk::RenderPassBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn render_pass(mut self, render_pass: vk::RenderPass) -> Self {
self.inner.render_pass = Some(render_pass);
self
}
pub fn framebuffer(mut self, framebuffer: vk::Framebuffer) -> Self {
self.inner.framebuffer = Some(framebuffer);
self
}
pub fn render_area(mut self, render_area: vk::Rect2D) -> Self {
self.inner.render_area = render_area;
self
}
pub fn p_clear_values(mut self, p_clear_values: &'a [vk::ClearValue]) -> Self {
self.inner.clear_value_count = p_clear_values.len() as u32;
self.inner.p_clear_values = p_clear_values.as_ptr();
self
}
}
impl<'a> Deref for RenderPassBeginInfoBuilder<'a> {
type Target = vk::RenderPassBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassDescription {
type Type = SubpassDescriptionBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassDescriptionBuilder<'a> {
inner: vk::SubpassDescription,
phantom: PhantomData<&'a vk::AttachmentReference>,
}
impl<'a> SubpassDescriptionBuilder<'a> {
pub fn flags(mut self, flags: vk::SubpassDescriptionFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn pipeline_bind_point(mut self, pipeline_bind_point: vk::PipelineBindPoint) -> Self {
self.inner.pipeline_bind_point = pipeline_bind_point;
self
}
pub fn p_input_attachments(mut self, p_input_attachments: &'a [vk::AttachmentReference]) -> Self {
self.inner.input_attachment_count = p_input_attachments.len() as u32;
self.inner.p_input_attachments = p_input_attachments.as_ptr();
self
}
pub fn p_color_attachments(
mut self,
p_color_attachments: &'a [vk::AttachmentReference],
p_resolve_attachments: Option<&'a [vk::AttachmentReference]>,
) -> Self {
self.inner.color_attachment_count = p_color_attachments.len() as u32;
if let Some(s) = p_resolve_attachments {
assert_eq!(self.inner.color_attachment_count, s.len() as u32);
}
self.inner.p_color_attachments = p_color_attachments.as_ptr();
self.inner.p_resolve_attachments = p_resolve_attachments.map_or(ptr::null(), |s| s.as_ptr());
self
}
pub fn p_depth_stencil_attachment(
mut self,
p_depth_stencil_attachment: Option<&'a vk::AttachmentReference>,
) -> Self {
self.inner.p_depth_stencil_attachment = p_depth_stencil_attachment.map_or(ptr::null(), |p| p);
self
}
pub fn p_preserve_attachments(mut self, p_preserve_attachments: &'a [u32]) -> Self {
self.inner.preserve_attachment_count = p_preserve_attachments.len() as u32;
self.inner.p_preserve_attachments = p_preserve_attachments.as_ptr();
self
}
}
impl<'a> Deref for SubpassDescriptionBuilder<'a> {
type Target = vk::SubpassDescription;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassCreateInfo {
type Type = RenderPassCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassCreateInfoBuilder<'a> {
inner: vk::RenderPassCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::RenderPassCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_attachments(mut self, p_attachments: &'a [vk::AttachmentDescription]) -> Self {
self.inner.attachment_count = p_attachments.len() as u32;
self.inner.p_attachments = p_attachments.as_ptr();
self
}
pub fn p_subpasses(mut self, p_subpasses: &'a [vk::SubpassDescription]) -> Self {
self.inner.subpass_count = p_subpasses.len() as u32;
self.inner.p_subpasses = p_subpasses.as_ptr();
self
}
pub fn p_dependencies(mut self, p_dependencies: &'a [vk::SubpassDependency]) -> Self {
self.inner.dependency_count = p_dependencies.len() as u32;
self.inner.p_dependencies = p_dependencies.as_ptr();
self
}
}
impl<'a> Deref for RenderPassCreateInfoBuilder<'a> {
type Target = vk::RenderPassCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::EventCreateInfo {
type Type = EventCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct EventCreateInfoBuilder<'a> {
inner: vk::EventCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> EventCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::EventCreateFlags) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for EventCreateInfoBuilder<'a> {
type Target = vk::EventCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FenceCreateInfo {
type Type = FenceCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FenceCreateInfoBuilder<'a> {
inner: vk::FenceCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FenceCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::FenceCreateFlags) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for FenceCreateInfoBuilder<'a> {
type Target = vk::FenceCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreCreateInfo {
type Type = SemaphoreCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreCreateInfoBuilder<'a> {
inner: vk::SemaphoreCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::SemaphoreCreateFlags) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for SemaphoreCreateInfoBuilder<'a> {
type Target = vk::SemaphoreCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::QueryPoolCreateInfo {
type Type = QueryPoolCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct QueryPoolCreateInfoBuilder<'a> {
inner: vk::QueryPoolCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> QueryPoolCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::QueryPoolCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn query_type(mut self, query_type: vk::QueryType) -> Self {
self.inner.query_type = query_type;
self
}
pub fn query_count(mut self, query_count: u32) -> Self {
self.inner.query_count = query_count;
self
}
pub fn pipeline_statistics(mut self, pipeline_statistics: vk::QueryPipelineStatisticFlags) -> Self {
self.inner.pipeline_statistics = pipeline_statistics;
self
}
}
impl<'a> Deref for QueryPoolCreateInfoBuilder<'a> {
type Target = vk::QueryPoolCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FramebufferCreateInfo {
type Type = FramebufferCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FramebufferCreateInfoBuilder<'a> {
inner: vk::FramebufferCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FramebufferCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::FramebufferCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn render_pass(mut self, render_pass: vk::RenderPass) -> Self {
self.inner.render_pass = Some(render_pass);
self
}
pub fn p_attachments(mut self, p_attachments: &'a [vk::ImageView]) -> Self {
self.inner.attachment_count = p_attachments.len() as u32;
self.inner.p_attachments = p_attachments.as_ptr();
self
}
pub fn width(mut self, width: u32) -> Self {
self.inner.width = width;
self
}
pub fn height(mut self, height: u32) -> Self {
self.inner.height = height;
self
}
pub fn layers(mut self, layers: u32) -> Self {
self.inner.layers = layers;
self
}
}
impl<'a> Deref for FramebufferCreateInfoBuilder<'a> {
type Target = vk::FramebufferCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubmitInfo {
type Type = SubmitInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubmitInfoBuilder<'a> {
inner: vk::SubmitInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubmitInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphores(
mut self,
p_wait_semaphores: &'a [vk::Semaphore],
p_wait_dst_stage_mask: &'a [vk::PipelineStageFlags],
) -> Self {
self.inner.wait_semaphore_count = p_wait_semaphores.len() as u32;
assert_eq!(self.inner.wait_semaphore_count, p_wait_dst_stage_mask.len() as u32);
self.inner.p_wait_semaphores = p_wait_semaphores.as_ptr();
self.inner.p_wait_dst_stage_mask = p_wait_dst_stage_mask.as_ptr();
self
}
pub fn p_command_buffers(mut self, p_command_buffers: &'a [vk::CommandBuffer]) -> Self {
self.inner.command_buffer_count = p_command_buffers.len() as u32;
self.inner.p_command_buffers = p_command_buffers.as_ptr();
self
}
pub fn p_signal_semaphores(mut self, p_signal_semaphores: &'a [vk::Semaphore]) -> Self {
self.inner.signal_semaphore_count = p_signal_semaphores.len() as u32;
self.inner.p_signal_semaphores = p_signal_semaphores.as_ptr();
self
}
}
impl<'a> Deref for SubmitInfoBuilder<'a> {
type Target = vk::SubmitInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplayModeCreateInfoKHR {
type Type = DisplayModeCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplayModeCreateInfoKHRBuilder<'a> {
inner: vk::DisplayModeCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplayModeCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DisplayModeCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn parameters(mut self, parameters: vk::DisplayModeParametersKHR) -> Self {
self.inner.parameters = parameters;
self
}
}
impl<'a> Deref for DisplayModeCreateInfoKHRBuilder<'a> {
type Target = vk::DisplayModeCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplaySurfaceCreateInfoKHR {
type Type = DisplaySurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplaySurfaceCreateInfoKHRBuilder<'a> {
inner: vk::DisplaySurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplaySurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DisplaySurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn display_mode(mut self, display_mode: vk::DisplayModeKHR) -> Self {
self.inner.display_mode = Some(display_mode);
self
}
pub fn plane_index(mut self, plane_index: u32) -> Self {
self.inner.plane_index = plane_index;
self
}
pub fn plane_stack_index(mut self, plane_stack_index: u32) -> Self {
self.inner.plane_stack_index = plane_stack_index;
self
}
pub fn transform(mut self, transform: vk::SurfaceTransformFlagsKHR) -> Self {
self.inner.transform = transform;
self
}
pub fn global_alpha(mut self, global_alpha: f32) -> Self {
self.inner.global_alpha = global_alpha;
self
}
pub fn alpha_mode(mut self, alpha_mode: vk::DisplayPlaneAlphaFlagsKHR) -> Self {
self.inner.alpha_mode = alpha_mode;
self
}
pub fn image_extent(mut self, image_extent: vk::Extent2D) -> Self {
self.inner.image_extent = image_extent;
self
}
}
impl<'a> Deref for DisplaySurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::DisplaySurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplayPresentInfoKHR {
type Type = DisplayPresentInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplayPresentInfoKHRBuilder<'a> {
inner: vk::DisplayPresentInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplayPresentInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_rect(mut self, src_rect: vk::Rect2D) -> Self {
self.inner.src_rect = src_rect;
self
}
pub fn dst_rect(mut self, dst_rect: vk::Rect2D) -> Self {
self.inner.dst_rect = dst_rect;
self
}
pub fn persistent(mut self, persistent: bool) -> Self {
self.inner.persistent = if persistent { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for DisplayPresentInfoKHRBuilder<'a> {
type Target = vk::DisplayPresentInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AndroidSurfaceCreateInfoKHR {
type Type = AndroidSurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AndroidSurfaceCreateInfoKHRBuilder<'a> {
inner: vk::AndroidSurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AndroidSurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::AndroidSurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn window(mut self, window: *mut vk::ANativeWindow) -> Self {
self.inner.window = window;
self
}
}
impl<'a> Deref for AndroidSurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::AndroidSurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ViSurfaceCreateInfoNN {
type Type = ViSurfaceCreateInfoNNBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ViSurfaceCreateInfoNNBuilder<'a> {
inner: vk::ViSurfaceCreateInfoNN,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ViSurfaceCreateInfoNNBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ViSurfaceCreateFlagsNN) -> Self {
self.inner.flags = flags;
self
}
pub fn window(mut self, window: *mut c_void) -> Self {
self.inner.window = window;
self
}
}
impl<'a> Deref for ViSurfaceCreateInfoNNBuilder<'a> {
type Target = vk::ViSurfaceCreateInfoNN;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::WaylandSurfaceCreateInfoKHR {
type Type = WaylandSurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct WaylandSurfaceCreateInfoKHRBuilder<'a> {
inner: vk::WaylandSurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> WaylandSurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::WaylandSurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn display(mut self, display: *mut vk::wl_display) -> Self {
self.inner.display = display;
self
}
pub fn surface(mut self, surface: *mut vk::wl_surface) -> Self {
self.inner.surface = surface;
self
}
}
impl<'a> Deref for WaylandSurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::WaylandSurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::Win32SurfaceCreateInfoKHR {
type Type = Win32SurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct Win32SurfaceCreateInfoKHRBuilder<'a> {
inner: vk::Win32SurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> Win32SurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::Win32SurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn hinstance(mut self, hinstance: vk::HINSTANCE) -> Self {
self.inner.hinstance = hinstance;
self
}
pub fn hwnd(mut self, hwnd: vk::HWND) -> Self {
self.inner.hwnd = hwnd;
self
}
}
impl<'a> Deref for Win32SurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::Win32SurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::XlibSurfaceCreateInfoKHR {
type Type = XlibSurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct XlibSurfaceCreateInfoKHRBuilder<'a> {
inner: vk::XlibSurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> XlibSurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::XlibSurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn dpy(mut self, dpy: *mut vk::Display) -> Self {
self.inner.dpy = dpy;
self
}
pub fn window(mut self, window: vk::Window) -> Self {
self.inner.window = window;
self
}
}
impl<'a> Deref for XlibSurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::XlibSurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::XcbSurfaceCreateInfoKHR {
type Type = XcbSurfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct XcbSurfaceCreateInfoKHRBuilder<'a> {
inner: vk::XcbSurfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> XcbSurfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::XcbSurfaceCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn connection(mut self, connection: *mut vk::xcb_connection_t) -> Self {
self.inner.connection = connection;
self
}
pub fn window(mut self, window: vk::xcb_window_t) -> Self {
self.inner.window = window;
self
}
}
impl<'a> Deref for XcbSurfaceCreateInfoKHRBuilder<'a> {
type Target = vk::XcbSurfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImagePipeSurfaceCreateInfoFUCHSIA {
type Type = ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
inner: vk::ImagePipeSurfaceCreateInfoFUCHSIA,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ImagePipeSurfaceCreateFlagsFUCHSIA) -> Self {
self.inner.flags = flags;
self
}
pub fn image_pipe_handle(mut self, image_pipe_handle: vk::zx_handle_t) -> Self {
self.inner.image_pipe_handle = image_pipe_handle;
self
}
}
impl<'a> Deref for ImagePipeSurfaceCreateInfoFUCHSIABuilder<'a> {
type Target = vk::ImagePipeSurfaceCreateInfoFUCHSIA;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SwapchainCreateInfoKHR {
type Type = SwapchainCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SwapchainCreateInfoKHRBuilder<'a> {
inner: vk::SwapchainCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SwapchainCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::SwapchainCreateFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn surface(mut self, surface: vk::SurfaceKHR) -> Self {
self.inner.surface = Some(surface);
self
}
pub fn min_image_count(mut self, min_image_count: u32) -> Self {
self.inner.min_image_count = min_image_count;
self
}
pub fn image_format(mut self, image_format: vk::Format) -> Self {
self.inner.image_format = image_format;
self
}
pub fn image_color_space(mut self, image_color_space: vk::ColorSpaceKHR) -> Self {
self.inner.image_color_space = image_color_space;
self
}
pub fn image_extent(mut self, image_extent: vk::Extent2D) -> Self {
self.inner.image_extent = image_extent;
self
}
pub fn image_array_layers(mut self, image_array_layers: u32) -> Self {
self.inner.image_array_layers = image_array_layers;
self
}
pub fn image_usage(mut self, image_usage: vk::ImageUsageFlags) -> Self {
self.inner.image_usage = image_usage;
self
}
pub fn image_sharing_mode(mut self, image_sharing_mode: vk::SharingMode) -> Self {
self.inner.image_sharing_mode = image_sharing_mode;
self
}
pub fn p_queue_family_indices(mut self, p_queue_family_indices: &'a [u32]) -> Self {
self.inner.queue_family_index_count = p_queue_family_indices.len() as u32;
self.inner.p_queue_family_indices = p_queue_family_indices.as_ptr();
self
}
pub fn pre_transform(mut self, pre_transform: vk::SurfaceTransformFlagsKHR) -> Self {
self.inner.pre_transform = pre_transform;
self
}
pub fn composite_alpha(mut self, composite_alpha: vk::CompositeAlphaFlagsKHR) -> Self {
self.inner.composite_alpha = composite_alpha;
self
}
pub fn present_mode(mut self, present_mode: vk::PresentModeKHR) -> Self {
self.inner.present_mode = present_mode;
self
}
pub fn clipped(mut self, clipped: bool) -> Self {
self.inner.clipped = if clipped { vk::TRUE } else { vk::FALSE };
self
}
pub fn old_swapchain(mut self, old_swapchain: Option<vk::SwapchainKHR>) -> Self {
self.inner.old_swapchain = old_swapchain;
self
}
}
impl<'a> Deref for SwapchainCreateInfoKHRBuilder<'a> {
type Target = vk::SwapchainCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PresentInfoKHR {
type Type = PresentInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PresentInfoKHRBuilder<'a> {
inner: vk::PresentInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PresentInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphores(mut self, p_wait_semaphores: &'a [vk::Semaphore]) -> Self {
self.inner.wait_semaphore_count = p_wait_semaphores.len() as u32;
self.inner.p_wait_semaphores = p_wait_semaphores.as_ptr();
self
}
pub fn p_swapchains(mut self, p_swapchains: &'a [vk::SwapchainKHR], p_image_indices: &'a [u32]) -> Self {
self.inner.swapchain_count = p_swapchains.len() as u32;
assert_eq!(self.inner.swapchain_count, p_image_indices.len() as u32);
self.inner.p_swapchains = p_swapchains.as_ptr();
self.inner.p_image_indices = p_image_indices.as_ptr();
self
}
pub fn p_results(mut self, p_results: *mut vk::Result) -> Self {
self.inner.p_results = p_results;
self
}
}
impl<'a> Deref for PresentInfoKHRBuilder<'a> {
type Target = vk::PresentInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugReportCallbackCreateInfoEXT {
type Type = DebugReportCallbackCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugReportCallbackCreateInfoEXTBuilder<'a> {
inner: vk::DebugReportCallbackCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugReportCallbackCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DebugReportFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn pfn_callback(mut self, pfn_callback: vk::FnDebugReportCallbackEXT) -> Self {
self.inner.pfn_callback = Some(pfn_callback);
self
}
pub fn p_user_data(mut self, p_user_data: *mut c_void) -> Self {
self.inner.p_user_data = p_user_data;
self
}
}
impl<'a> Deref for DebugReportCallbackCreateInfoEXTBuilder<'a> {
type Target = vk::DebugReportCallbackCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ValidationFlagsEXT {
type Type = ValidationFlagsEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ValidationFlagsEXTBuilder<'a> {
inner: vk::ValidationFlagsEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ValidationFlagsEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_disabled_validation_checks(mut self, p_disabled_validation_checks: &'a [vk::ValidationCheckEXT]) -> Self {
self.inner.disabled_validation_check_count = p_disabled_validation_checks.len() as u32;
self.inner.p_disabled_validation_checks = p_disabled_validation_checks.as_ptr();
self
}
}
impl<'a> Deref for ValidationFlagsEXTBuilder<'a> {
type Target = vk::ValidationFlagsEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ValidationFeaturesEXT {
type Type = ValidationFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ValidationFeaturesEXTBuilder<'a> {
inner: vk::ValidationFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ValidationFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_enabled_validation_features(
mut self,
p_enabled_validation_features: &'a [vk::ValidationFeatureEnableEXT],
) -> Self {
self.inner.enabled_validation_feature_count = p_enabled_validation_features.len() as u32;
self.inner.p_enabled_validation_features = p_enabled_validation_features.as_ptr();
self
}
pub fn p_disabled_validation_features(
mut self,
p_disabled_validation_features: &'a [vk::ValidationFeatureDisableEXT],
) -> Self {
self.inner.disabled_validation_feature_count = p_disabled_validation_features.len() as u32;
self.inner.p_disabled_validation_features = p_disabled_validation_features.as_ptr();
self
}
}
impl<'a> Deref for ValidationFeaturesEXTBuilder<'a> {
type Target = vk::ValidationFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationStateRasterizationOrderAMD {
type Type = PipelineRasterizationStateRasterizationOrderAMDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
inner: vk::PipelineRasterizationStateRasterizationOrderAMD,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn rasterization_order(mut self, rasterization_order: vk::RasterizationOrderAMD) -> Self {
self.inner.rasterization_order = rasterization_order;
self
}
}
impl<'a> Deref for PipelineRasterizationStateRasterizationOrderAMDBuilder<'a> {
type Target = vk::PipelineRasterizationStateRasterizationOrderAMD;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugMarkerObjectNameInfoEXT {
type Type = DebugMarkerObjectNameInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugMarkerObjectNameInfoEXTBuilder<'a> {
inner: vk::DebugMarkerObjectNameInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugMarkerObjectNameInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn object_type(mut self, object_type: vk::DebugReportObjectTypeEXT) -> Self {
self.inner.object_type = object_type;
self
}
pub fn object(mut self, object: u64) -> Self {
self.inner.object = object;
self
}
pub fn p_object_name(mut self, p_object_name: &'a CStr) -> Self {
self.inner.p_object_name = p_object_name.as_ptr();
self
}
}
impl<'a> Deref for DebugMarkerObjectNameInfoEXTBuilder<'a> {
type Target = vk::DebugMarkerObjectNameInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugMarkerObjectTagInfoEXT {
type Type = DebugMarkerObjectTagInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugMarkerObjectTagInfoEXTBuilder<'a> {
inner: vk::DebugMarkerObjectTagInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugMarkerObjectTagInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn object_type(mut self, object_type: vk::DebugReportObjectTypeEXT) -> Self {
self.inner.object_type = object_type;
self
}
pub fn object(mut self, object: u64) -> Self {
self.inner.object = object;
self
}
pub fn tag_name(mut self, tag_name: u64) -> Self {
self.inner.tag_name = tag_name;
self
}
pub fn tag_size(mut self, tag_size: usize) -> Self {
self.inner.tag_size = tag_size;
self
}
pub fn p_tag(mut self, p_tag: *const c_void) -> Self {
self.inner.p_tag = p_tag;
self
}
}
impl<'a> Deref for DebugMarkerObjectTagInfoEXTBuilder<'a> {
type Target = vk::DebugMarkerObjectTagInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugMarkerMarkerInfoEXT {
type Type = DebugMarkerMarkerInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugMarkerMarkerInfoEXTBuilder<'a> {
inner: vk::DebugMarkerMarkerInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugMarkerMarkerInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_marker_name(mut self, p_marker_name: &'a CStr) -> Self {
self.inner.p_marker_name = p_marker_name.as_ptr();
self
}
}
impl<'a> Deref for DebugMarkerMarkerInfoEXTBuilder<'a> {
type Target = vk::DebugMarkerMarkerInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DedicatedAllocationImageCreateInfoNV {
type Type = DedicatedAllocationImageCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DedicatedAllocationImageCreateInfoNVBuilder<'a> {
inner: vk::DedicatedAllocationImageCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DedicatedAllocationImageCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
self.inner.dedicated_allocation = if dedicated_allocation { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for DedicatedAllocationImageCreateInfoNVBuilder<'a> {
type Target = vk::DedicatedAllocationImageCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DedicatedAllocationBufferCreateInfoNV {
type Type = DedicatedAllocationBufferCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
inner: vk::DedicatedAllocationBufferCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn dedicated_allocation(mut self, dedicated_allocation: bool) -> Self {
self.inner.dedicated_allocation = if dedicated_allocation { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for DedicatedAllocationBufferCreateInfoNVBuilder<'a> {
type Target = vk::DedicatedAllocationBufferCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DedicatedAllocationMemoryAllocateInfoNV {
type Type = DedicatedAllocationMemoryAllocateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
inner: vk::DedicatedAllocationMemoryAllocateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image(mut self, image: Option<vk::Image>) -> Self {
self.inner.image = image;
self
}
pub fn buffer(mut self, buffer: Option<vk::Buffer>) -> Self {
self.inner.buffer = buffer;
self
}
}
impl<'a> Deref for DedicatedAllocationMemoryAllocateInfoNVBuilder<'a> {
type Target = vk::DedicatedAllocationMemoryAllocateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExternalMemoryImageCreateInfoNV {
type Type = ExternalMemoryImageCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExternalMemoryImageCreateInfoNVBuilder<'a> {
inner: vk::ExternalMemoryImageCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExternalMemoryImageCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalMemoryHandleTypeFlagsNV) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExternalMemoryImageCreateInfoNVBuilder<'a> {
type Target = vk::ExternalMemoryImageCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportMemoryAllocateInfoNV {
type Type = ExportMemoryAllocateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportMemoryAllocateInfoNVBuilder<'a> {
inner: vk::ExportMemoryAllocateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportMemoryAllocateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalMemoryHandleTypeFlagsNV) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExportMemoryAllocateInfoNVBuilder<'a> {
type Target = vk::ExportMemoryAllocateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportMemoryWin32HandleInfoNV {
type Type = ImportMemoryWin32HandleInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportMemoryWin32HandleInfoNVBuilder<'a> {
inner: vk::ImportMemoryWin32HandleInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportMemoryWin32HandleInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlagsNV) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn handle(mut self, handle: vk::HANDLE) -> Self {
self.inner.handle = handle;
self
}
}
impl<'a> Deref for ImportMemoryWin32HandleInfoNVBuilder<'a> {
type Target = vk::ImportMemoryWin32HandleInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportMemoryWin32HandleInfoNV {
type Type = ExportMemoryWin32HandleInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportMemoryWin32HandleInfoNVBuilder<'a> {
inner: vk::ExportMemoryWin32HandleInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportMemoryWin32HandleInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attributes(mut self, p_attributes: Option<&'a vk::SECURITY_ATTRIBUTES>) -> Self {
self.inner.p_attributes = p_attributes.map_or(ptr::null(), |p| p);
self
}
pub fn dw_access(mut self, dw_access: vk::DWORD) -> Self {
self.inner.dw_access = dw_access;
self
}
}
impl<'a> Deref for ExportMemoryWin32HandleInfoNVBuilder<'a> {
type Target = vk::ExportMemoryWin32HandleInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::Win32KeyedMutexAcquireReleaseInfoNV {
type Type = Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
inner: vk::Win32KeyedMutexAcquireReleaseInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_acquire_syncs(
mut self,
p_acquire_syncs: &'a [vk::DeviceMemory],
p_acquire_keys: &'a [u64],
p_acquire_timeout_milliseconds: &'a [u32],
) -> Self {
self.inner.acquire_count = p_acquire_syncs.len() as u32;
assert_eq!(self.inner.acquire_count, p_acquire_keys.len() as u32);
assert_eq!(self.inner.acquire_count, p_acquire_timeout_milliseconds.len() as u32);
self.inner.p_acquire_syncs = p_acquire_syncs.as_ptr();
self.inner.p_acquire_keys = p_acquire_keys.as_ptr();
self.inner.p_acquire_timeout_milliseconds = p_acquire_timeout_milliseconds.as_ptr();
self
}
pub fn p_release_syncs(mut self, p_release_syncs: &'a [vk::DeviceMemory], p_release_keys: &'a [u64]) -> Self {
self.inner.release_count = p_release_syncs.len() as u32;
assert_eq!(self.inner.release_count, p_release_keys.len() as u32);
self.inner.p_release_syncs = p_release_syncs.as_ptr();
self.inner.p_release_keys = p_release_keys.as_ptr();
self
}
}
impl<'a> Deref for Win32KeyedMutexAcquireReleaseInfoNVBuilder<'a> {
type Target = vk::Win32KeyedMutexAcquireReleaseInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
type Type = PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_generated_commands(mut self, device_generated_commands: bool) -> Self {
self.inner.device_generated_commands = if device_generated_commands { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceDeviceGeneratedCommandsFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceDeviceGeneratedCommandsFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GraphicsShaderGroupCreateInfoNV {
type Type = GraphicsShaderGroupCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GraphicsShaderGroupCreateInfoNVBuilder<'a> {
inner: vk::GraphicsShaderGroupCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GraphicsShaderGroupCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_stages(mut self, p_stages: &'a [vk::PipelineShaderStageCreateInfo]) -> Self {
self.inner.stage_count = p_stages.len() as u32;
self.inner.p_stages = p_stages.as_ptr();
self
}
pub fn p_vertex_input_state(
mut self,
p_vertex_input_state: Option<&'a vk::PipelineVertexInputStateCreateInfo>,
) -> Self {
self.inner.p_vertex_input_state = p_vertex_input_state.map_or(ptr::null(), |p| p);
self
}
pub fn p_tessellation_state(
mut self,
p_tessellation_state: Option<&'a vk::PipelineTessellationStateCreateInfo>,
) -> Self {
self.inner.p_tessellation_state = p_tessellation_state.map_or(ptr::null(), |p| p);
self
}
}
impl<'a> Deref for GraphicsShaderGroupCreateInfoNVBuilder<'a> {
type Target = vk::GraphicsShaderGroupCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GraphicsPipelineShaderGroupsCreateInfoNV {
type Type = GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
inner: vk::GraphicsPipelineShaderGroupsCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_groups(mut self, p_groups: &'a [vk::GraphicsShaderGroupCreateInfoNV]) -> Self {
self.inner.group_count = p_groups.len() as u32;
self.inner.p_groups = p_groups.as_ptr();
self
}
pub fn p_pipelines(mut self, p_pipelines: &'a [vk::Pipeline]) -> Self {
self.inner.pipeline_count = p_pipelines.len() as u32;
self.inner.p_pipelines = p_pipelines.as_ptr();
self
}
}
impl<'a> Deref for GraphicsPipelineShaderGroupsCreateInfoNVBuilder<'a> {
type Target = vk::GraphicsPipelineShaderGroupsCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::IndirectCommandsLayoutTokenNV {
type Type = IndirectCommandsLayoutTokenNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct IndirectCommandsLayoutTokenNVBuilder<'a> {
inner: vk::IndirectCommandsLayoutTokenNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> IndirectCommandsLayoutTokenNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn token_type(mut self, token_type: vk::IndirectCommandsTokenTypeNV) -> Self {
self.inner.token_type = token_type;
self
}
pub fn stream(mut self, stream: u32) -> Self {
self.inner.stream = stream;
self
}
pub fn offset(mut self, offset: u32) -> Self {
self.inner.offset = offset;
self
}
pub fn vertex_binding_unit(mut self, vertex_binding_unit: u32) -> Self {
self.inner.vertex_binding_unit = vertex_binding_unit;
self
}
pub fn vertex_dynamic_stride(mut self, vertex_dynamic_stride: bool) -> Self {
self.inner.vertex_dynamic_stride = if vertex_dynamic_stride { vk::TRUE } else { vk::FALSE };
self
}
pub fn pushconstant_pipeline_layout(mut self, pushconstant_pipeline_layout: Option<vk::PipelineLayout>) -> Self {
self.inner.pushconstant_pipeline_layout = pushconstant_pipeline_layout;
self
}
pub fn pushconstant_shader_stage_flags(mut self, pushconstant_shader_stage_flags: vk::ShaderStageFlags) -> Self {
self.inner.pushconstant_shader_stage_flags = pushconstant_shader_stage_flags;
self
}
pub fn pushconstant_offset(mut self, pushconstant_offset: u32) -> Self {
self.inner.pushconstant_offset = pushconstant_offset;
self
}
pub fn pushconstant_size(mut self, pushconstant_size: u32) -> Self {
self.inner.pushconstant_size = pushconstant_size;
self
}
pub fn indirect_state_flags(mut self, indirect_state_flags: vk::IndirectStateFlagsNV) -> Self {
self.inner.indirect_state_flags = indirect_state_flags;
self
}
pub fn p_index_types(mut self, p_index_types: &'a [vk::IndexType], p_index_type_values: &'a [u32]) -> Self {
self.inner.index_type_count = p_index_types.len() as u32;
assert_eq!(self.inner.index_type_count, p_index_type_values.len() as u32);
self.inner.p_index_types = p_index_types.as_ptr();
self.inner.p_index_type_values = p_index_type_values.as_ptr();
self
}
}
impl<'a> Deref for IndirectCommandsLayoutTokenNVBuilder<'a> {
type Target = vk::IndirectCommandsLayoutTokenNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::IndirectCommandsLayoutCreateInfoNV {
type Type = IndirectCommandsLayoutCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
inner: vk::IndirectCommandsLayoutCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::IndirectCommandsLayoutUsageFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn pipeline_bind_point(mut self, pipeline_bind_point: vk::PipelineBindPoint) -> Self {
self.inner.pipeline_bind_point = pipeline_bind_point;
self
}
pub fn p_tokens(mut self, p_tokens: &'a [vk::IndirectCommandsLayoutTokenNV]) -> Self {
self.inner.token_count = p_tokens.len() as u32;
self.inner.p_tokens = p_tokens.as_ptr();
self
}
pub fn p_stream_strides(mut self, p_stream_strides: &'a [u32]) -> Self {
self.inner.stream_count = p_stream_strides.len() as u32;
self.inner.p_stream_strides = p_stream_strides.as_ptr();
self
}
}
impl<'a> Deref for IndirectCommandsLayoutCreateInfoNVBuilder<'a> {
type Target = vk::IndirectCommandsLayoutCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GeneratedCommandsInfoNV {
type Type = GeneratedCommandsInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GeneratedCommandsInfoNVBuilder<'a> {
inner: vk::GeneratedCommandsInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GeneratedCommandsInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn pipeline_bind_point(mut self, pipeline_bind_point: vk::PipelineBindPoint) -> Self {
self.inner.pipeline_bind_point = pipeline_bind_point;
self
}
pub fn pipeline(mut self, pipeline: vk::Pipeline) -> Self {
self.inner.pipeline = Some(pipeline);
self
}
pub fn indirect_commands_layout(mut self, indirect_commands_layout: vk::IndirectCommandsLayoutNV) -> Self {
self.inner.indirect_commands_layout = Some(indirect_commands_layout);
self
}
pub fn p_streams(mut self, p_streams: &'a [vk::IndirectCommandsStreamNV]) -> Self {
self.inner.stream_count = p_streams.len() as u32;
self.inner.p_streams = p_streams.as_ptr();
self
}
pub fn sequences_count(mut self, sequences_count: u32) -> Self {
self.inner.sequences_count = sequences_count;
self
}
pub fn preprocess_buffer(mut self, preprocess_buffer: vk::Buffer) -> Self {
self.inner.preprocess_buffer = Some(preprocess_buffer);
self
}
pub fn preprocess_offset(mut self, preprocess_offset: vk::DeviceSize) -> Self {
self.inner.preprocess_offset = preprocess_offset;
self
}
pub fn preprocess_size(mut self, preprocess_size: vk::DeviceSize) -> Self {
self.inner.preprocess_size = preprocess_size;
self
}
pub fn sequences_count_buffer(mut self, sequences_count_buffer: Option<vk::Buffer>) -> Self {
self.inner.sequences_count_buffer = sequences_count_buffer;
self
}
pub fn sequences_count_offset(mut self, sequences_count_offset: vk::DeviceSize) -> Self {
self.inner.sequences_count_offset = sequences_count_offset;
self
}
pub fn sequences_index_buffer(mut self, sequences_index_buffer: Option<vk::Buffer>) -> Self {
self.inner.sequences_index_buffer = sequences_index_buffer;
self
}
pub fn sequences_index_offset(mut self, sequences_index_offset: vk::DeviceSize) -> Self {
self.inner.sequences_index_offset = sequences_index_offset;
self
}
}
impl<'a> Deref for GeneratedCommandsInfoNVBuilder<'a> {
type Target = vk::GeneratedCommandsInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceFeatures2 {
type Type = PhysicalDeviceFeatures2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceFeatures2Builder<'a> {
inner: vk::PhysicalDeviceFeatures2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceFeatures2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn features(mut self, features: vk::PhysicalDeviceFeatures) -> Self {
self.inner.features = features;
self
}
}
impl<'a> Deref for PhysicalDeviceFeatures2Builder<'a> {
type Target = vk::PhysicalDeviceFeatures2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceImageFormatInfo2 {
type Type = PhysicalDeviceImageFormatInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceImageFormatInfo2Builder<'a> {
inner: vk::PhysicalDeviceImageFormatInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceImageFormatInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn ty(mut self, ty: vk::ImageType) -> Self {
self.inner.ty = ty;
self
}
pub fn tiling(mut self, tiling: vk::ImageTiling) -> Self {
self.inner.tiling = tiling;
self
}
pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn flags(mut self, flags: vk::ImageCreateFlags) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for PhysicalDeviceImageFormatInfo2Builder<'a> {
type Target = vk::PhysicalDeviceImageFormatInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceSparseImageFormatInfo2 {
type Type = PhysicalDeviceSparseImageFormatInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
inner: vk::PhysicalDeviceSparseImageFormatInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn ty(mut self, ty: vk::ImageType) -> Self {
self.inner.ty = ty;
self
}
pub fn samples(mut self, samples: vk::SampleCountFlags) -> Self {
self.inner.samples = samples;
self
}
pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn tiling(mut self, tiling: vk::ImageTiling) -> Self {
self.inner.tiling = tiling;
self
}
}
impl<'a> Deref for PhysicalDeviceSparseImageFormatInfo2Builder<'a> {
type Target = vk::PhysicalDeviceSparseImageFormatInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PresentRegionsKHR {
type Type = PresentRegionsKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PresentRegionsKHRBuilder<'a> {
inner: vk::PresentRegionsKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PresentRegionsKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_regions(mut self, p_regions: &'a [vk::PresentRegionKHR]) -> Self {
self.inner.swapchain_count = p_regions.len() as u32;
self.inner.p_regions = p_regions.as_ptr();
self
}
}
impl<'a> Deref for PresentRegionsKHRBuilder<'a> {
type Target = vk::PresentRegionsKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PresentRegionKHR {
type Type = PresentRegionKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PresentRegionKHRBuilder<'a> {
inner: vk::PresentRegionKHR,
phantom: PhantomData<&'a vk::RectLayerKHR>,
}
impl<'a> PresentRegionKHRBuilder<'a> {
pub fn p_rectangles(mut self, p_rectangles: &'a [vk::RectLayerKHR]) -> Self {
self.inner.rectangle_count = p_rectangles.len() as u32;
self.inner.p_rectangles = p_rectangles.as_ptr();
self
}
}
impl<'a> Deref for PresentRegionKHRBuilder<'a> {
type Target = vk::PresentRegionKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVariablePointersFeatures {
type Type = PhysicalDeviceVariablePointersFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceVariablePointersFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn variable_pointers_storage_buffer(mut self, variable_pointers_storage_buffer: bool) -> Self {
self.inner.variable_pointers_storage_buffer = if variable_pointers_storage_buffer {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
self.inner.variable_pointers = if variable_pointers { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceVariablePointersFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceVariablePointersFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceExternalImageFormatInfo {
type Type = PhysicalDeviceExternalImageFormatInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
inner: vk::PhysicalDeviceExternalImageFormatInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for PhysicalDeviceExternalImageFormatInfoBuilder<'a> {
type Target = vk::PhysicalDeviceExternalImageFormatInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceExternalBufferInfo {
type Type = PhysicalDeviceExternalBufferInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceExternalBufferInfoBuilder<'a> {
inner: vk::PhysicalDeviceExternalBufferInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceExternalBufferInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::BufferCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn usage(mut self, usage: vk::BufferUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for PhysicalDeviceExternalBufferInfoBuilder<'a> {
type Target = vk::PhysicalDeviceExternalBufferInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExternalMemoryImageCreateInfo {
type Type = ExternalMemoryImageCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExternalMemoryImageCreateInfoBuilder<'a> {
inner: vk::ExternalMemoryImageCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExternalMemoryImageCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExternalMemoryImageCreateInfoBuilder<'a> {
type Target = vk::ExternalMemoryImageCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExternalMemoryBufferCreateInfo {
type Type = ExternalMemoryBufferCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExternalMemoryBufferCreateInfoBuilder<'a> {
inner: vk::ExternalMemoryBufferCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExternalMemoryBufferCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExternalMemoryBufferCreateInfoBuilder<'a> {
type Target = vk::ExternalMemoryBufferCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportMemoryAllocateInfo {
type Type = ExportMemoryAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportMemoryAllocateInfoBuilder<'a> {
inner: vk::ExportMemoryAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportMemoryAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExportMemoryAllocateInfoBuilder<'a> {
type Target = vk::ExportMemoryAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportMemoryWin32HandleInfoKHR {
type Type = ImportMemoryWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportMemoryWin32HandleInfoKHRBuilder<'a> {
inner: vk::ImportMemoryWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportMemoryWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn handle(mut self, handle: vk::HANDLE) -> Self {
self.inner.handle = handle;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ImportMemoryWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ImportMemoryWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportMemoryWin32HandleInfoKHR {
type Type = ExportMemoryWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportMemoryWin32HandleInfoKHRBuilder<'a> {
inner: vk::ExportMemoryWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportMemoryWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attributes(mut self, p_attributes: Option<&'a vk::SECURITY_ATTRIBUTES>) -> Self {
self.inner.p_attributes = p_attributes.map_or(ptr::null(), |p| p);
self
}
pub fn dw_access(mut self, dw_access: vk::DWORD) -> Self {
self.inner.dw_access = dw_access;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ExportMemoryWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ExportMemoryWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryGetWin32HandleInfoKHR {
type Type = MemoryGetWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryGetWin32HandleInfoKHRBuilder<'a> {
inner: vk::MemoryGetWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryGetWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for MemoryGetWin32HandleInfoKHRBuilder<'a> {
type Target = vk::MemoryGetWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportMemoryFdInfoKHR {
type Type = ImportMemoryFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportMemoryFdInfoKHRBuilder<'a> {
inner: vk::ImportMemoryFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportMemoryFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn fd(mut self, fd: c_int) -> Self {
self.inner.fd = fd;
self
}
}
impl<'a> Deref for ImportMemoryFdInfoKHRBuilder<'a> {
type Target = vk::ImportMemoryFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryGetFdInfoKHR {
type Type = MemoryGetFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryGetFdInfoKHRBuilder<'a> {
inner: vk::MemoryGetFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryGetFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for MemoryGetFdInfoKHRBuilder<'a> {
type Target = vk::MemoryGetFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::Win32KeyedMutexAcquireReleaseInfoKHR {
type Type = Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
inner: vk::Win32KeyedMutexAcquireReleaseInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_acquire_syncs(
mut self,
p_acquire_syncs: &'a [vk::DeviceMemory],
p_acquire_keys: &'a [u64],
p_acquire_timeouts: &'a [u32],
) -> Self {
self.inner.acquire_count = p_acquire_syncs.len() as u32;
assert_eq!(self.inner.acquire_count, p_acquire_keys.len() as u32);
assert_eq!(self.inner.acquire_count, p_acquire_timeouts.len() as u32);
self.inner.p_acquire_syncs = p_acquire_syncs.as_ptr();
self.inner.p_acquire_keys = p_acquire_keys.as_ptr();
self.inner.p_acquire_timeouts = p_acquire_timeouts.as_ptr();
self
}
pub fn p_release_syncs(mut self, p_release_syncs: &'a [vk::DeviceMemory], p_release_keys: &'a [u64]) -> Self {
self.inner.release_count = p_release_syncs.len() as u32;
assert_eq!(self.inner.release_count, p_release_keys.len() as u32);
self.inner.p_release_syncs = p_release_syncs.as_ptr();
self.inner.p_release_keys = p_release_keys.as_ptr();
self
}
}
impl<'a> Deref for Win32KeyedMutexAcquireReleaseInfoKHRBuilder<'a> {
type Target = vk::Win32KeyedMutexAcquireReleaseInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceExternalSemaphoreInfo {
type Type = PhysicalDeviceExternalSemaphoreInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
inner: vk::PhysicalDeviceExternalSemaphoreInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for PhysicalDeviceExternalSemaphoreInfoBuilder<'a> {
type Target = vk::PhysicalDeviceExternalSemaphoreInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportSemaphoreCreateInfo {
type Type = ExportSemaphoreCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportSemaphoreCreateInfoBuilder<'a> {
inner: vk::ExportSemaphoreCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportSemaphoreCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExportSemaphoreCreateInfoBuilder<'a> {
type Target = vk::ExportSemaphoreCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportSemaphoreWin32HandleInfoKHR {
type Type = ImportSemaphoreWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
inner: vk::ImportSemaphoreWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore(mut self, semaphore: vk::Semaphore) -> Self {
self.inner.semaphore = Some(semaphore);
self
}
pub fn flags(mut self, flags: vk::SemaphoreImportFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn handle(mut self, handle: vk::HANDLE) -> Self {
self.inner.handle = handle;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ImportSemaphoreWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ImportSemaphoreWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportSemaphoreWin32HandleInfoKHR {
type Type = ExportSemaphoreWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
inner: vk::ExportSemaphoreWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attributes(mut self, p_attributes: Option<&'a vk::SECURITY_ATTRIBUTES>) -> Self {
self.inner.p_attributes = p_attributes.map_or(ptr::null(), |p| p);
self
}
pub fn dw_access(mut self, dw_access: vk::DWORD) -> Self {
self.inner.dw_access = dw_access;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ExportSemaphoreWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ExportSemaphoreWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::D3D12FenceSubmitInfoKHR {
type Type = D3D12FenceSubmitInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct D3D12FenceSubmitInfoKHRBuilder<'a> {
inner: vk::D3D12FenceSubmitInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> D3D12FenceSubmitInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphore_values(mut self, p_wait_semaphore_values: &'a [u64]) -> Self {
self.inner.wait_semaphore_values_count = p_wait_semaphore_values.len() as u32;
self.inner.p_wait_semaphore_values = p_wait_semaphore_values.as_ptr();
self
}
pub fn p_signal_semaphore_values(mut self, p_signal_semaphore_values: &'a [u64]) -> Self {
self.inner.signal_semaphore_values_count = p_signal_semaphore_values.len() as u32;
self.inner.p_signal_semaphore_values = p_signal_semaphore_values.as_ptr();
self
}
}
impl<'a> Deref for D3D12FenceSubmitInfoKHRBuilder<'a> {
type Target = vk::D3D12FenceSubmitInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreGetWin32HandleInfoKHR {
type Type = SemaphoreGetWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
inner: vk::SemaphoreGetWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore(mut self, semaphore: vk::Semaphore) -> Self {
self.inner.semaphore = Some(semaphore);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for SemaphoreGetWin32HandleInfoKHRBuilder<'a> {
type Target = vk::SemaphoreGetWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportSemaphoreFdInfoKHR {
type Type = ImportSemaphoreFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportSemaphoreFdInfoKHRBuilder<'a> {
inner: vk::ImportSemaphoreFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportSemaphoreFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore(mut self, semaphore: vk::Semaphore) -> Self {
self.inner.semaphore = Some(semaphore);
self
}
pub fn flags(mut self, flags: vk::SemaphoreImportFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn fd(mut self, fd: c_int) -> Self {
self.inner.fd = fd;
self
}
}
impl<'a> Deref for ImportSemaphoreFdInfoKHRBuilder<'a> {
type Target = vk::ImportSemaphoreFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreGetFdInfoKHR {
type Type = SemaphoreGetFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreGetFdInfoKHRBuilder<'a> {
inner: vk::SemaphoreGetFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreGetFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore(mut self, semaphore: vk::Semaphore) -> Self {
self.inner.semaphore = Some(semaphore);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalSemaphoreHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for SemaphoreGetFdInfoKHRBuilder<'a> {
type Target = vk::SemaphoreGetFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceExternalFenceInfo {
type Type = PhysicalDeviceExternalFenceInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceExternalFenceInfoBuilder<'a> {
inner: vk::PhysicalDeviceExternalFenceInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceExternalFenceInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for PhysicalDeviceExternalFenceInfoBuilder<'a> {
type Target = vk::PhysicalDeviceExternalFenceInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportFenceCreateInfo {
type Type = ExportFenceCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportFenceCreateInfoBuilder<'a> {
inner: vk::ExportFenceCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportFenceCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_types(mut self, handle_types: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_types = handle_types;
self
}
}
impl<'a> Deref for ExportFenceCreateInfoBuilder<'a> {
type Target = vk::ExportFenceCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportFenceWin32HandleInfoKHR {
type Type = ImportFenceWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportFenceWin32HandleInfoKHRBuilder<'a> {
inner: vk::ImportFenceWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportFenceWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fence(mut self, fence: vk::Fence) -> Self {
self.inner.fence = Some(fence);
self
}
pub fn flags(mut self, flags: vk::FenceImportFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn handle(mut self, handle: vk::HANDLE) -> Self {
self.inner.handle = handle;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ImportFenceWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ImportFenceWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExportFenceWin32HandleInfoKHR {
type Type = ExportFenceWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExportFenceWin32HandleInfoKHRBuilder<'a> {
inner: vk::ExportFenceWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExportFenceWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attributes(mut self, p_attributes: Option<&'a vk::SECURITY_ATTRIBUTES>) -> Self {
self.inner.p_attributes = p_attributes.map_or(ptr::null(), |p| p);
self
}
pub fn dw_access(mut self, dw_access: vk::DWORD) -> Self {
self.inner.dw_access = dw_access;
self
}
pub fn name(mut self, name: vk::LPCWSTR) -> Self {
self.inner.name = name;
self
}
}
impl<'a> Deref for ExportFenceWin32HandleInfoKHRBuilder<'a> {
type Target = vk::ExportFenceWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FenceGetWin32HandleInfoKHR {
type Type = FenceGetWin32HandleInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FenceGetWin32HandleInfoKHRBuilder<'a> {
inner: vk::FenceGetWin32HandleInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FenceGetWin32HandleInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fence(mut self, fence: vk::Fence) -> Self {
self.inner.fence = Some(fence);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for FenceGetWin32HandleInfoKHRBuilder<'a> {
type Target = vk::FenceGetWin32HandleInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportFenceFdInfoKHR {
type Type = ImportFenceFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportFenceFdInfoKHRBuilder<'a> {
inner: vk::ImportFenceFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportFenceFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fence(mut self, fence: vk::Fence) -> Self {
self.inner.fence = Some(fence);
self
}
pub fn flags(mut self, flags: vk::FenceImportFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn fd(mut self, fd: c_int) -> Self {
self.inner.fd = fd;
self
}
}
impl<'a> Deref for ImportFenceFdInfoKHRBuilder<'a> {
type Target = vk::ImportFenceFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FenceGetFdInfoKHR {
type Type = FenceGetFdInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FenceGetFdInfoKHRBuilder<'a> {
inner: vk::FenceGetFdInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FenceGetFdInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fence(mut self, fence: vk::Fence) -> Self {
self.inner.fence = Some(fence);
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalFenceHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
}
impl<'a> Deref for FenceGetFdInfoKHRBuilder<'a> {
type Target = vk::FenceGetFdInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceMultiviewFeatures {
type Type = PhysicalDeviceMultiviewFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceMultiviewFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceMultiviewFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceMultiviewFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn multiview(mut self, multiview: bool) -> Self {
self.inner.multiview = if multiview { vk::TRUE } else { vk::FALSE };
self
}
pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
self.inner.multiview_geometry_shader = if multiview_geometry_shader { vk::TRUE } else { vk::FALSE };
self
}
pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
self.inner.multiview_tessellation_shader = if multiview_tessellation_shader {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceMultiviewFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceMultiviewFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassMultiviewCreateInfo {
type Type = RenderPassMultiviewCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassMultiviewCreateInfoBuilder<'a> {
inner: vk::RenderPassMultiviewCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassMultiviewCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_view_masks(mut self, p_view_masks: &'a [u32]) -> Self {
self.inner.subpass_count = p_view_masks.len() as u32;
self.inner.p_view_masks = p_view_masks.as_ptr();
self
}
pub fn p_view_offsets(mut self, p_view_offsets: &'a [i32]) -> Self {
self.inner.dependency_count = p_view_offsets.len() as u32;
self.inner.p_view_offsets = p_view_offsets.as_ptr();
self
}
pub fn p_correlation_masks(mut self, p_correlation_masks: &'a [u32]) -> Self {
self.inner.correlation_mask_count = p_correlation_masks.len() as u32;
self.inner.p_correlation_masks = p_correlation_masks.as_ptr();
self
}
}
impl<'a> Deref for RenderPassMultiviewCreateInfoBuilder<'a> {
type Target = vk::RenderPassMultiviewCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplayPowerInfoEXT {
type Type = DisplayPowerInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplayPowerInfoEXTBuilder<'a> {
inner: vk::DisplayPowerInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplayPowerInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn power_state(mut self, power_state: vk::DisplayPowerStateEXT) -> Self {
self.inner.power_state = power_state;
self
}
}
impl<'a> Deref for DisplayPowerInfoEXTBuilder<'a> {
type Target = vk::DisplayPowerInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceEventInfoEXT {
type Type = DeviceEventInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceEventInfoEXTBuilder<'a> {
inner: vk::DeviceEventInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceEventInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_event(mut self, device_event: vk::DeviceEventTypeEXT) -> Self {
self.inner.device_event = device_event;
self
}
}
impl<'a> Deref for DeviceEventInfoEXTBuilder<'a> {
type Target = vk::DeviceEventInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplayEventInfoEXT {
type Type = DisplayEventInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplayEventInfoEXTBuilder<'a> {
inner: vk::DisplayEventInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplayEventInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn display_event(mut self, display_event: vk::DisplayEventTypeEXT) -> Self {
self.inner.display_event = display_event;
self
}
}
impl<'a> Deref for DisplayEventInfoEXTBuilder<'a> {
type Target = vk::DisplayEventInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SwapchainCounterCreateInfoEXT {
type Type = SwapchainCounterCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SwapchainCounterCreateInfoEXTBuilder<'a> {
inner: vk::SwapchainCounterCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SwapchainCounterCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn surface_counters(mut self, surface_counters: vk::SurfaceCounterFlagsEXT) -> Self {
self.inner.surface_counters = surface_counters;
self
}
}
impl<'a> Deref for SwapchainCounterCreateInfoEXTBuilder<'a> {
type Target = vk::SwapchainCounterCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryAllocateFlagsInfo {
type Type = MemoryAllocateFlagsInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryAllocateFlagsInfoBuilder<'a> {
inner: vk::MemoryAllocateFlagsInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryAllocateFlagsInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::MemoryAllocateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn device_mask(mut self, device_mask: u32) -> Self {
self.inner.device_mask = device_mask;
self
}
}
impl<'a> Deref for MemoryAllocateFlagsInfoBuilder<'a> {
type Target = vk::MemoryAllocateFlagsInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindBufferMemoryInfo {
type Type = BindBufferMemoryInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindBufferMemoryInfoBuilder<'a> {
inner: vk::BindBufferMemoryInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindBufferMemoryInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn memory_offset(mut self, memory_offset: vk::DeviceSize) -> Self {
self.inner.memory_offset = memory_offset;
self
}
}
impl<'a> Deref for BindBufferMemoryInfoBuilder<'a> {
type Target = vk::BindBufferMemoryInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindBufferMemoryDeviceGroupInfo {
type Type = BindBufferMemoryDeviceGroupInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindBufferMemoryDeviceGroupInfoBuilder<'a> {
inner: vk::BindBufferMemoryDeviceGroupInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindBufferMemoryDeviceGroupInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self {
self.inner.device_index_count = p_device_indices.len() as u32;
self.inner.p_device_indices = p_device_indices.as_ptr();
self
}
}
impl<'a> Deref for BindBufferMemoryDeviceGroupInfoBuilder<'a> {
type Target = vk::BindBufferMemoryDeviceGroupInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindImageMemoryInfo {
type Type = BindImageMemoryInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindImageMemoryInfoBuilder<'a> {
inner: vk::BindImageMemoryInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindImageMemoryInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn memory_offset(mut self, memory_offset: vk::DeviceSize) -> Self {
self.inner.memory_offset = memory_offset;
self
}
}
impl<'a> Deref for BindImageMemoryInfoBuilder<'a> {
type Target = vk::BindImageMemoryInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindImageMemoryDeviceGroupInfo {
type Type = BindImageMemoryDeviceGroupInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindImageMemoryDeviceGroupInfoBuilder<'a> {
inner: vk::BindImageMemoryDeviceGroupInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindImageMemoryDeviceGroupInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self {
self.inner.device_index_count = p_device_indices.len() as u32;
self.inner.p_device_indices = p_device_indices.as_ptr();
self
}
pub fn p_split_instance_bind_regions(mut self, p_split_instance_bind_regions: &'a [vk::Rect2D]) -> Self {
self.inner.split_instance_bind_region_count = p_split_instance_bind_regions.len() as u32;
self.inner.p_split_instance_bind_regions = p_split_instance_bind_regions.as_ptr();
self
}
}
impl<'a> Deref for BindImageMemoryDeviceGroupInfoBuilder<'a> {
type Target = vk::BindImageMemoryDeviceGroupInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupRenderPassBeginInfo {
type Type = DeviceGroupRenderPassBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupRenderPassBeginInfoBuilder<'a> {
inner: vk::DeviceGroupRenderPassBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupRenderPassBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_mask(mut self, device_mask: u32) -> Self {
self.inner.device_mask = device_mask;
self
}
pub fn p_device_render_areas(mut self, p_device_render_areas: &'a [vk::Rect2D]) -> Self {
self.inner.device_render_area_count = p_device_render_areas.len() as u32;
self.inner.p_device_render_areas = p_device_render_areas.as_ptr();
self
}
}
impl<'a> Deref for DeviceGroupRenderPassBeginInfoBuilder<'a> {
type Target = vk::DeviceGroupRenderPassBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupCommandBufferBeginInfo {
type Type = DeviceGroupCommandBufferBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupCommandBufferBeginInfoBuilder<'a> {
inner: vk::DeviceGroupCommandBufferBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupCommandBufferBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_mask(mut self, device_mask: u32) -> Self {
self.inner.device_mask = device_mask;
self
}
}
impl<'a> Deref for DeviceGroupCommandBufferBeginInfoBuilder<'a> {
type Target = vk::DeviceGroupCommandBufferBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupSubmitInfo {
type Type = DeviceGroupSubmitInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupSubmitInfoBuilder<'a> {
inner: vk::DeviceGroupSubmitInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupSubmitInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphore_device_indices(mut self, p_wait_semaphore_device_indices: &'a [u32]) -> Self {
self.inner.wait_semaphore_count = p_wait_semaphore_device_indices.len() as u32;
self.inner.p_wait_semaphore_device_indices = p_wait_semaphore_device_indices.as_ptr();
self
}
pub fn p_command_buffer_device_masks(mut self, p_command_buffer_device_masks: &'a [u32]) -> Self {
self.inner.command_buffer_count = p_command_buffer_device_masks.len() as u32;
self.inner.p_command_buffer_device_masks = p_command_buffer_device_masks.as_ptr();
self
}
pub fn p_signal_semaphore_device_indices(mut self, p_signal_semaphore_device_indices: &'a [u32]) -> Self {
self.inner.signal_semaphore_count = p_signal_semaphore_device_indices.len() as u32;
self.inner.p_signal_semaphore_device_indices = p_signal_semaphore_device_indices.as_ptr();
self
}
}
impl<'a> Deref for DeviceGroupSubmitInfoBuilder<'a> {
type Target = vk::DeviceGroupSubmitInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupBindSparseInfo {
type Type = DeviceGroupBindSparseInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupBindSparseInfoBuilder<'a> {
inner: vk::DeviceGroupBindSparseInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupBindSparseInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn resource_device_index(mut self, resource_device_index: u32) -> Self {
self.inner.resource_device_index = resource_device_index;
self
}
pub fn memory_device_index(mut self, memory_device_index: u32) -> Self {
self.inner.memory_device_index = memory_device_index;
self
}
}
impl<'a> Deref for DeviceGroupBindSparseInfoBuilder<'a> {
type Target = vk::DeviceGroupBindSparseInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageSwapchainCreateInfoKHR {
type Type = ImageSwapchainCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageSwapchainCreateInfoKHRBuilder<'a> {
inner: vk::ImageSwapchainCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageSwapchainCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn swapchain(mut self, swapchain: Option<vk::SwapchainKHR>) -> Self {
self.inner.swapchain = swapchain;
self
}
}
impl<'a> Deref for ImageSwapchainCreateInfoKHRBuilder<'a> {
type Target = vk::ImageSwapchainCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindImageMemorySwapchainInfoKHR {
type Type = BindImageMemorySwapchainInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindImageMemorySwapchainInfoKHRBuilder<'a> {
inner: vk::BindImageMemorySwapchainInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindImageMemorySwapchainInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn swapchain(mut self, swapchain: vk::SwapchainKHR) -> Self {
self.inner.swapchain = Some(swapchain);
self
}
pub fn image_index(mut self, image_index: u32) -> Self {
self.inner.image_index = image_index;
self
}
}
impl<'a> Deref for BindImageMemorySwapchainInfoKHRBuilder<'a> {
type Target = vk::BindImageMemorySwapchainInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AcquireNextImageInfoKHR {
type Type = AcquireNextImageInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AcquireNextImageInfoKHRBuilder<'a> {
inner: vk::AcquireNextImageInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AcquireNextImageInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn swapchain(mut self, swapchain: vk::SwapchainKHR) -> Self {
self.inner.swapchain = Some(swapchain);
self
}
pub fn timeout(mut self, timeout: u64) -> Self {
self.inner.timeout = timeout;
self
}
pub fn semaphore(mut self, semaphore: Option<vk::Semaphore>) -> Self {
self.inner.semaphore = semaphore;
self
}
pub fn fence(mut self, fence: Option<vk::Fence>) -> Self {
self.inner.fence = fence;
self
}
pub fn device_mask(mut self, device_mask: u32) -> Self {
self.inner.device_mask = device_mask;
self
}
}
impl<'a> Deref for AcquireNextImageInfoKHRBuilder<'a> {
type Target = vk::AcquireNextImageInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupPresentInfoKHR {
type Type = DeviceGroupPresentInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupPresentInfoKHRBuilder<'a> {
inner: vk::DeviceGroupPresentInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupPresentInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_device_masks(mut self, p_device_masks: &'a [u32]) -> Self {
self.inner.swapchain_count = p_device_masks.len() as u32;
self.inner.p_device_masks = p_device_masks.as_ptr();
self
}
pub fn mode(mut self, mode: vk::DeviceGroupPresentModeFlagsKHR) -> Self {
self.inner.mode = mode;
self
}
}
impl<'a> Deref for DeviceGroupPresentInfoKHRBuilder<'a> {
type Target = vk::DeviceGroupPresentInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupDeviceCreateInfo {
type Type = DeviceGroupDeviceCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupDeviceCreateInfoBuilder<'a> {
inner: vk::DeviceGroupDeviceCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupDeviceCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_physical_devices(mut self, p_physical_devices: &'a [vk::PhysicalDevice]) -> Self {
self.inner.physical_device_count = p_physical_devices.len() as u32;
self.inner.p_physical_devices = p_physical_devices.as_ptr();
self
}
}
impl<'a> Deref for DeviceGroupDeviceCreateInfoBuilder<'a> {
type Target = vk::DeviceGroupDeviceCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceGroupSwapchainCreateInfoKHR {
type Type = DeviceGroupSwapchainCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
inner: vk::DeviceGroupSwapchainCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn modes(mut self, modes: vk::DeviceGroupPresentModeFlagsKHR) -> Self {
self.inner.modes = modes;
self
}
}
impl<'a> Deref for DeviceGroupSwapchainCreateInfoKHRBuilder<'a> {
type Target = vk::DeviceGroupSwapchainCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorUpdateTemplateCreateInfo {
type Type = DescriptorUpdateTemplateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorUpdateTemplateCreateInfoBuilder<'a> {
inner: vk::DescriptorUpdateTemplateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorUpdateTemplateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DescriptorUpdateTemplateCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_descriptor_update_entries(
mut self,
p_descriptor_update_entries: &'a [vk::DescriptorUpdateTemplateEntry],
) -> Self {
self.inner.descriptor_update_entry_count = p_descriptor_update_entries.len() as u32;
self.inner.p_descriptor_update_entries = p_descriptor_update_entries.as_ptr();
self
}
pub fn template_type(mut self, template_type: vk::DescriptorUpdateTemplateType) -> Self {
self.inner.template_type = template_type;
self
}
pub fn descriptor_set_layout(mut self, descriptor_set_layout: vk::DescriptorSetLayout) -> Self {
self.inner.descriptor_set_layout = Some(descriptor_set_layout);
self
}
pub fn pipeline_bind_point(mut self, pipeline_bind_point: vk::PipelineBindPoint) -> Self {
self.inner.pipeline_bind_point = pipeline_bind_point;
self
}
pub fn pipeline_layout(mut self, pipeline_layout: vk::PipelineLayout) -> Self {
self.inner.pipeline_layout = Some(pipeline_layout);
self
}
pub fn set(mut self, set: u32) -> Self {
self.inner.set = set;
self
}
}
impl<'a> Deref for DescriptorUpdateTemplateCreateInfoBuilder<'a> {
type Target = vk::DescriptorUpdateTemplateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::HdrMetadataEXT {
type Type = HdrMetadataEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct HdrMetadataEXTBuilder<'a> {
inner: vk::HdrMetadataEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> HdrMetadataEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn display_primary_red(mut self, display_primary_red: vk::XYColorEXT) -> Self {
self.inner.display_primary_red = display_primary_red;
self
}
pub fn display_primary_green(mut self, display_primary_green: vk::XYColorEXT) -> Self {
self.inner.display_primary_green = display_primary_green;
self
}
pub fn display_primary_blue(mut self, display_primary_blue: vk::XYColorEXT) -> Self {
self.inner.display_primary_blue = display_primary_blue;
self
}
pub fn white_point(mut self, white_point: vk::XYColorEXT) -> Self {
self.inner.white_point = white_point;
self
}
pub fn max_luminance(mut self, max_luminance: f32) -> Self {
self.inner.max_luminance = max_luminance;
self
}
pub fn min_luminance(mut self, min_luminance: f32) -> Self {
self.inner.min_luminance = min_luminance;
self
}
pub fn max_content_light_level(mut self, max_content_light_level: f32) -> Self {
self.inner.max_content_light_level = max_content_light_level;
self
}
pub fn max_frame_average_light_level(mut self, max_frame_average_light_level: f32) -> Self {
self.inner.max_frame_average_light_level = max_frame_average_light_level;
self
}
}
impl<'a> Deref for HdrMetadataEXTBuilder<'a> {
type Target = vk::HdrMetadataEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SwapchainDisplayNativeHdrCreateInfoAMD {
type Type = SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
inner: vk::SwapchainDisplayNativeHdrCreateInfoAMD,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn local_dimming_enable(mut self, local_dimming_enable: bool) -> Self {
self.inner.local_dimming_enable = if local_dimming_enable { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for SwapchainDisplayNativeHdrCreateInfoAMDBuilder<'a> {
type Target = vk::SwapchainDisplayNativeHdrCreateInfoAMD;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PresentTimesInfoGOOGLE {
type Type = PresentTimesInfoGOOGLEBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PresentTimesInfoGOOGLEBuilder<'a> {
inner: vk::PresentTimesInfoGOOGLE,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PresentTimesInfoGOOGLEBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_times(mut self, p_times: &'a [vk::PresentTimeGOOGLE]) -> Self {
self.inner.swapchain_count = p_times.len() as u32;
self.inner.p_times = p_times.as_ptr();
self
}
}
impl<'a> Deref for PresentTimesInfoGOOGLEBuilder<'a> {
type Target = vk::PresentTimesInfoGOOGLE;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::IOSSurfaceCreateInfoMVK {
type Type = IOSSurfaceCreateInfoMVKBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct IOSSurfaceCreateInfoMVKBuilder<'a> {
inner: vk::IOSSurfaceCreateInfoMVK,
phantom: PhantomData<&'a c_void>,
}
impl<'a> IOSSurfaceCreateInfoMVKBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::IOSSurfaceCreateFlagsMVK) -> Self {
self.inner.flags = flags;
self
}
pub fn p_view(mut self, p_view: *const c_void) -> Self {
self.inner.p_view = p_view;
self
}
}
impl<'a> Deref for IOSSurfaceCreateInfoMVKBuilder<'a> {
type Target = vk::IOSSurfaceCreateInfoMVK;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MacOSSurfaceCreateInfoMVK {
type Type = MacOSSurfaceCreateInfoMVKBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MacOSSurfaceCreateInfoMVKBuilder<'a> {
inner: vk::MacOSSurfaceCreateInfoMVK,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MacOSSurfaceCreateInfoMVKBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::MacOSSurfaceCreateFlagsMVK) -> Self {
self.inner.flags = flags;
self
}
pub fn p_view(mut self, p_view: *const c_void) -> Self {
self.inner.p_view = p_view;
self
}
}
impl<'a> Deref for MacOSSurfaceCreateInfoMVKBuilder<'a> {
type Target = vk::MacOSSurfaceCreateInfoMVK;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MetalSurfaceCreateInfoEXT {
type Type = MetalSurfaceCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MetalSurfaceCreateInfoEXTBuilder<'a> {
inner: vk::MetalSurfaceCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MetalSurfaceCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::MetalSurfaceCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn p_layer(mut self, p_layer: &'a vk::CAMetalLayer) -> Self {
self.inner.p_layer = p_layer;
self
}
}
impl<'a> Deref for MetalSurfaceCreateInfoEXTBuilder<'a> {
type Target = vk::MetalSurfaceCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportWScalingStateCreateInfoNV {
type Type = PipelineViewportWScalingStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineViewportWScalingStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn viewport_w_scaling_enable(mut self, viewport_w_scaling_enable: bool) -> Self {
self.inner.viewport_w_scaling_enable = if viewport_w_scaling_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn viewport_count(mut self, viewport_count: u32) -> Self {
self.inner.viewport_count = viewport_count;
self
}
pub fn p_viewport_w_scalings(mut self, p_viewport_w_scalings: &'a [vk::ViewportWScalingNV]) -> Self {
self.inner.viewport_count = p_viewport_w_scalings.len() as u32;
self.inner.p_viewport_w_scalings = p_viewport_w_scalings.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportWScalingStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineViewportWScalingStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportSwizzleStateCreateInfoNV {
type Type = PipelineViewportSwizzleStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineViewportSwizzleStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineViewportSwizzleStateCreateFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn p_viewport_swizzles(mut self, p_viewport_swizzles: &'a [vk::ViewportSwizzleNV]) -> Self {
self.inner.viewport_count = p_viewport_swizzles.len() as u32;
self.inner.p_viewport_swizzles = p_viewport_swizzles.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportSwizzleStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineViewportSwizzleStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineDiscardRectangleStateCreateInfoEXT {
type Type = PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineDiscardRectangleStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineDiscardRectangleStateCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn discard_rectangle_mode(mut self, discard_rectangle_mode: vk::DiscardRectangleModeEXT) -> Self {
self.inner.discard_rectangle_mode = discard_rectangle_mode;
self
}
pub fn discard_rectangle_count(mut self, discard_rectangle_count: u32) -> Self {
self.inner.discard_rectangle_count = discard_rectangle_count;
self
}
pub fn p_discard_rectangles(mut self, p_discard_rectangles: &'a [vk::Rect2D]) -> Self {
self.inner.discard_rectangle_count = p_discard_rectangles.len() as u32;
self.inner.p_discard_rectangles = p_discard_rectangles.as_ptr();
self
}
}
impl<'a> Deref for PipelineDiscardRectangleStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineDiscardRectangleStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassInputAttachmentAspectCreateInfo {
type Type = RenderPassInputAttachmentAspectCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
inner: vk::RenderPassInputAttachmentAspectCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_aspect_references(mut self, p_aspect_references: &'a [vk::InputAttachmentAspectReference]) -> Self {
self.inner.aspect_reference_count = p_aspect_references.len() as u32;
self.inner.p_aspect_references = p_aspect_references.as_ptr();
self
}
}
impl<'a> Deref for RenderPassInputAttachmentAspectCreateInfoBuilder<'a> {
type Target = vk::RenderPassInputAttachmentAspectCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceSurfaceInfo2KHR {
type Type = PhysicalDeviceSurfaceInfo2KHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
inner: vk::PhysicalDeviceSurfaceInfo2KHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn surface(mut self, surface: vk::SurfaceKHR) -> Self {
self.inner.surface = Some(surface);
self
}
}
impl<'a> Deref for PhysicalDeviceSurfaceInfo2KHRBuilder<'a> {
type Target = vk::PhysicalDeviceSurfaceInfo2KHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DisplayPlaneInfo2KHR {
type Type = DisplayPlaneInfo2KHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DisplayPlaneInfo2KHRBuilder<'a> {
inner: vk::DisplayPlaneInfo2KHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DisplayPlaneInfo2KHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn mode(mut self, mode: vk::DisplayModeKHR) -> Self {
self.inner.mode = Some(mode);
self
}
pub fn plane_index(mut self, plane_index: u32) -> Self {
self.inner.plane_index = plane_index;
self
}
}
impl<'a> Deref for DisplayPlaneInfo2KHRBuilder<'a> {
type Target = vk::DisplayPlaneInfo2KHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevice16BitStorageFeatures {
type Type = PhysicalDevice16BitStorageFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevice16BitStorageFeaturesBuilder<'a> {
inner: vk::PhysicalDevice16BitStorageFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevice16BitStorageFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
self.inner.storage_buffer16_bit_access = if storage_buffer16_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn uniform_and_storage_buffer16_bit_access(mut self, uniform_and_storage_buffer16_bit_access: bool) -> Self {
self.inner.uniform_and_storage_buffer16_bit_access = if uniform_and_storage_buffer16_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
self.inner.storage_push_constant16 = if storage_push_constant16 { vk::TRUE } else { vk::FALSE };
self
}
pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
self.inner.storage_input_output16 = if storage_input_output16 { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDevice16BitStorageFeaturesBuilder<'a> {
type Target = vk::PhysicalDevice16BitStorageFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
type Type = PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceShaderSubgroupExtendedTypesFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
self.inner.shader_subgroup_extended_types = if shader_subgroup_extended_types {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceShaderSubgroupExtendedTypesFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceShaderSubgroupExtendedTypesFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferMemoryRequirementsInfo2 {
type Type = BufferMemoryRequirementsInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferMemoryRequirementsInfo2Builder<'a> {
inner: vk::BufferMemoryRequirementsInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferMemoryRequirementsInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
}
impl<'a> Deref for BufferMemoryRequirementsInfo2Builder<'a> {
type Target = vk::BufferMemoryRequirementsInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageMemoryRequirementsInfo2 {
type Type = ImageMemoryRequirementsInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageMemoryRequirementsInfo2Builder<'a> {
inner: vk::ImageMemoryRequirementsInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageMemoryRequirementsInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
}
impl<'a> Deref for ImageMemoryRequirementsInfo2Builder<'a> {
type Target = vk::ImageMemoryRequirementsInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageSparseMemoryRequirementsInfo2 {
type Type = ImageSparseMemoryRequirementsInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageSparseMemoryRequirementsInfo2Builder<'a> {
inner: vk::ImageSparseMemoryRequirementsInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageSparseMemoryRequirementsInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image(mut self, image: vk::Image) -> Self {
self.inner.image = Some(image);
self
}
}
impl<'a> Deref for ImageSparseMemoryRequirementsInfo2Builder<'a> {
type Target = vk::ImageSparseMemoryRequirementsInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryDedicatedAllocateInfo {
type Type = MemoryDedicatedAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryDedicatedAllocateInfoBuilder<'a> {
inner: vk::MemoryDedicatedAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryDedicatedAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image(mut self, image: Option<vk::Image>) -> Self {
self.inner.image = image;
self
}
pub fn buffer(mut self, buffer: Option<vk::Buffer>) -> Self {
self.inner.buffer = buffer;
self
}
}
impl<'a> Deref for MemoryDedicatedAllocateInfoBuilder<'a> {
type Target = vk::MemoryDedicatedAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageViewUsageCreateInfo {
type Type = ImageViewUsageCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageViewUsageCreateInfoBuilder<'a> {
inner: vk::ImageViewUsageCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageViewUsageCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
self.inner.usage = usage;
self
}
}
impl<'a> Deref for ImageViewUsageCreateInfoBuilder<'a> {
type Target = vk::ImageViewUsageCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineTessellationDomainOriginStateCreateInfo {
type Type = PipelineTessellationDomainOriginStateCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
inner: vk::PipelineTessellationDomainOriginStateCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn domain_origin(mut self, domain_origin: vk::TessellationDomainOrigin) -> Self {
self.inner.domain_origin = domain_origin;
self
}
}
impl<'a> Deref for PipelineTessellationDomainOriginStateCreateInfoBuilder<'a> {
type Target = vk::PipelineTessellationDomainOriginStateCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SamplerYcbcrConversionInfo {
type Type = SamplerYcbcrConversionInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SamplerYcbcrConversionInfoBuilder<'a> {
inner: vk::SamplerYcbcrConversionInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SamplerYcbcrConversionInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn conversion(mut self, conversion: vk::SamplerYcbcrConversion) -> Self {
self.inner.conversion = Some(conversion);
self
}
}
impl<'a> Deref for SamplerYcbcrConversionInfoBuilder<'a> {
type Target = vk::SamplerYcbcrConversionInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SamplerYcbcrConversionCreateInfo {
type Type = SamplerYcbcrConversionCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SamplerYcbcrConversionCreateInfoBuilder<'a> {
inner: vk::SamplerYcbcrConversionCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SamplerYcbcrConversionCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn ycbcr_model(mut self, ycbcr_model: vk::SamplerYcbcrModelConversion) -> Self {
self.inner.ycbcr_model = ycbcr_model;
self
}
pub fn ycbcr_range(mut self, ycbcr_range: vk::SamplerYcbcrRange) -> Self {
self.inner.ycbcr_range = ycbcr_range;
self
}
pub fn components(mut self, components: vk::ComponentMapping) -> Self {
self.inner.components = components;
self
}
pub fn x_chroma_offset(mut self, x_chroma_offset: vk::ChromaLocation) -> Self {
self.inner.x_chroma_offset = x_chroma_offset;
self
}
pub fn y_chroma_offset(mut self, y_chroma_offset: vk::ChromaLocation) -> Self {
self.inner.y_chroma_offset = y_chroma_offset;
self
}
pub fn chroma_filter(mut self, chroma_filter: vk::Filter) -> Self {
self.inner.chroma_filter = chroma_filter;
self
}
pub fn force_explicit_reconstruction(mut self, force_explicit_reconstruction: bool) -> Self {
self.inner.force_explicit_reconstruction = if force_explicit_reconstruction {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for SamplerYcbcrConversionCreateInfoBuilder<'a> {
type Target = vk::SamplerYcbcrConversionCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindImagePlaneMemoryInfo {
type Type = BindImagePlaneMemoryInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindImagePlaneMemoryInfoBuilder<'a> {
inner: vk::BindImagePlaneMemoryInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindImagePlaneMemoryInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn plane_aspect(mut self, plane_aspect: vk::ImageAspectFlags) -> Self {
self.inner.plane_aspect = plane_aspect;
self
}
}
impl<'a> Deref for BindImagePlaneMemoryInfoBuilder<'a> {
type Target = vk::BindImagePlaneMemoryInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImagePlaneMemoryRequirementsInfo {
type Type = ImagePlaneMemoryRequirementsInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImagePlaneMemoryRequirementsInfoBuilder<'a> {
inner: vk::ImagePlaneMemoryRequirementsInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImagePlaneMemoryRequirementsInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn plane_aspect(mut self, plane_aspect: vk::ImageAspectFlags) -> Self {
self.inner.plane_aspect = plane_aspect;
self
}
}
impl<'a> Deref for ImagePlaneMemoryRequirementsInfoBuilder<'a> {
type Target = vk::ImagePlaneMemoryRequirementsInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceSamplerYcbcrConversionFeatures {
type Type = PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceSamplerYcbcrConversionFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
self.inner.sampler_ycbcr_conversion = if sampler_ycbcr_conversion { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceSamplerYcbcrConversionFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceSamplerYcbcrConversionFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ConditionalRenderingBeginInfoEXT {
type Type = ConditionalRenderingBeginInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ConditionalRenderingBeginInfoEXTBuilder<'a> {
inner: vk::ConditionalRenderingBeginInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ConditionalRenderingBeginInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
pub fn offset(mut self, offset: vk::DeviceSize) -> Self {
self.inner.offset = offset;
self
}
pub fn flags(mut self, flags: vk::ConditionalRenderingFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for ConditionalRenderingBeginInfoEXTBuilder<'a> {
type Target = vk::ConditionalRenderingBeginInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ProtectedSubmitInfo {
type Type = ProtectedSubmitInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ProtectedSubmitInfoBuilder<'a> {
inner: vk::ProtectedSubmitInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ProtectedSubmitInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn protected_submit(mut self, protected_submit: bool) -> Self {
self.inner.protected_submit = if protected_submit { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for ProtectedSubmitInfoBuilder<'a> {
type Target = vk::ProtectedSubmitInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceProtectedMemoryFeatures {
type Type = PhysicalDeviceProtectedMemoryFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceProtectedMemoryFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn protected_memory(mut self, protected_memory: bool) -> Self {
self.inner.protected_memory = if protected_memory { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceProtectedMemoryFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceProtectedMemoryFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceQueueInfo2 {
type Type = DeviceQueueInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceQueueInfo2Builder<'a> {
inner: vk::DeviceQueueInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceQueueInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DeviceQueueCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
self.inner.queue_family_index = queue_family_index;
self
}
pub fn queue_index(mut self, queue_index: u32) -> Self {
self.inner.queue_index = queue_index;
self
}
}
impl<'a> Deref for DeviceQueueInfo2Builder<'a> {
type Target = vk::DeviceQueueInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCoverageToColorStateCreateInfoNV {
type Type = PipelineCoverageToColorStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineCoverageToColorStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCoverageToColorStateCreateFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn coverage_to_color_enable(mut self, coverage_to_color_enable: bool) -> Self {
self.inner.coverage_to_color_enable = if coverage_to_color_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn coverage_to_color_location(mut self, coverage_to_color_location: u32) -> Self {
self.inner.coverage_to_color_location = coverage_to_color_location;
self
}
}
impl<'a> Deref for PipelineCoverageToColorStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineCoverageToColorStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SampleLocationsInfoEXT {
type Type = SampleLocationsInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SampleLocationsInfoEXTBuilder<'a> {
inner: vk::SampleLocationsInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SampleLocationsInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn sample_locations_per_pixel(mut self, sample_locations_per_pixel: vk::SampleCountFlags) -> Self {
self.inner.sample_locations_per_pixel = sample_locations_per_pixel;
self
}
pub fn sample_location_grid_size(mut self, sample_location_grid_size: vk::Extent2D) -> Self {
self.inner.sample_location_grid_size = sample_location_grid_size;
self
}
pub fn p_sample_locations(mut self, p_sample_locations: &'a [vk::SampleLocationEXT]) -> Self {
self.inner.sample_locations_count = p_sample_locations.len() as u32;
self.inner.p_sample_locations = p_sample_locations.as_ptr();
self
}
}
impl<'a> Deref for SampleLocationsInfoEXTBuilder<'a> {
type Target = vk::SampleLocationsInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassSampleLocationsBeginInfoEXT {
type Type = RenderPassSampleLocationsBeginInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
inner: vk::RenderPassSampleLocationsBeginInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attachment_initial_sample_locations(
mut self,
p_attachment_initial_sample_locations: &'a [vk::AttachmentSampleLocationsEXT],
) -> Self {
self.inner.attachment_initial_sample_locations_count = p_attachment_initial_sample_locations.len() as u32;
self.inner.p_attachment_initial_sample_locations = p_attachment_initial_sample_locations.as_ptr();
self
}
pub fn p_post_subpass_sample_locations(
mut self,
p_post_subpass_sample_locations: &'a [vk::SubpassSampleLocationsEXT],
) -> Self {
self.inner.post_subpass_sample_locations_count = p_post_subpass_sample_locations.len() as u32;
self.inner.p_post_subpass_sample_locations = p_post_subpass_sample_locations.as_ptr();
self
}
}
impl<'a> Deref for RenderPassSampleLocationsBeginInfoEXTBuilder<'a> {
type Target = vk::RenderPassSampleLocationsBeginInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineSampleLocationsStateCreateInfoEXT {
type Type = PipelineSampleLocationsStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineSampleLocationsStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn sample_locations_enable(mut self, sample_locations_enable: bool) -> Self {
self.inner.sample_locations_enable = if sample_locations_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn sample_locations_info(mut self, sample_locations_info: vk::SampleLocationsInfoEXT) -> Self {
self.inner.sample_locations_info = sample_locations_info;
self
}
}
impl<'a> Deref for PipelineSampleLocationsStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineSampleLocationsStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SamplerReductionModeCreateInfo {
type Type = SamplerReductionModeCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SamplerReductionModeCreateInfoBuilder<'a> {
inner: vk::SamplerReductionModeCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SamplerReductionModeCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn reduction_mode(mut self, reduction_mode: vk::SamplerReductionMode) -> Self {
self.inner.reduction_mode = reduction_mode;
self
}
}
impl<'a> Deref for SamplerReductionModeCreateInfoBuilder<'a> {
type Target = vk::SamplerReductionModeCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
type Type = PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn advanced_blend_coherent_operations(mut self, advanced_blend_coherent_operations: bool) -> Self {
self.inner.advanced_blend_coherent_operations = if advanced_blend_coherent_operations {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceBlendOperationAdvancedFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceBlendOperationAdvancedFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineColorBlendAdvancedStateCreateInfoEXT {
type Type = PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineColorBlendAdvancedStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_premultiplied(mut self, src_premultiplied: bool) -> Self {
self.inner.src_premultiplied = if src_premultiplied { vk::TRUE } else { vk::FALSE };
self
}
pub fn dst_premultiplied(mut self, dst_premultiplied: bool) -> Self {
self.inner.dst_premultiplied = if dst_premultiplied { vk::TRUE } else { vk::FALSE };
self
}
pub fn blend_overlap(mut self, blend_overlap: vk::BlendOverlapEXT) -> Self {
self.inner.blend_overlap = blend_overlap;
self
}
}
impl<'a> Deref for PipelineColorBlendAdvancedStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineColorBlendAdvancedStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceInlineUniformBlockFeaturesEXT {
type Type = PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceInlineUniformBlockFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn inline_uniform_block(mut self, inline_uniform_block: bool) -> Self {
self.inner.inline_uniform_block = if inline_uniform_block { vk::TRUE } else { vk::FALSE };
self
}
pub fn descriptor_binding_inline_uniform_block_update_after_bind(
mut self,
descriptor_binding_inline_uniform_block_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_inline_uniform_block_update_after_bind =
if descriptor_binding_inline_uniform_block_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceInlineUniformBlockFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceInlineUniformBlockFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::WriteDescriptorSetInlineUniformBlockEXT {
type Type = WriteDescriptorSetInlineUniformBlockEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
inner: vk::WriteDescriptorSetInlineUniformBlockEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn data_size(mut self, data_size: u32) -> Self {
self.inner.data_size = data_size;
self
}
pub fn p_data(mut self, p_data: *const c_void) -> Self {
self.inner.p_data = p_data;
self
}
}
impl<'a> Deref for WriteDescriptorSetInlineUniformBlockEXTBuilder<'a> {
type Target = vk::WriteDescriptorSetInlineUniformBlockEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorPoolInlineUniformBlockCreateInfoEXT {
type Type = DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
inner: vk::DescriptorPoolInlineUniformBlockCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn max_inline_uniform_block_bindings(mut self, max_inline_uniform_block_bindings: u32) -> Self {
self.inner.max_inline_uniform_block_bindings = max_inline_uniform_block_bindings;
self
}
}
impl<'a> Deref for DescriptorPoolInlineUniformBlockCreateInfoEXTBuilder<'a> {
type Target = vk::DescriptorPoolInlineUniformBlockCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCoverageModulationStateCreateInfoNV {
type Type = PipelineCoverageModulationStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineCoverageModulationStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCoverageModulationStateCreateFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn coverage_modulation_mode(mut self, coverage_modulation_mode: vk::CoverageModulationModeNV) -> Self {
self.inner.coverage_modulation_mode = coverage_modulation_mode;
self
}
pub fn coverage_modulation_table_enable(mut self, coverage_modulation_table_enable: bool) -> Self {
self.inner.coverage_modulation_table_enable = if coverage_modulation_table_enable {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn coverage_modulation_table_count(mut self, coverage_modulation_table_count: u32) -> Self {
self.inner.coverage_modulation_table_count = coverage_modulation_table_count;
self
}
pub fn p_coverage_modulation_table(mut self, p_coverage_modulation_table: &'a [f32]) -> Self {
self.inner.coverage_modulation_table_count = p_coverage_modulation_table.len() as u32;
self.inner.p_coverage_modulation_table = p_coverage_modulation_table.as_ptr();
self
}
}
impl<'a> Deref for PipelineCoverageModulationStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineCoverageModulationStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageFormatListCreateInfo {
type Type = ImageFormatListCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageFormatListCreateInfoBuilder<'a> {
inner: vk::ImageFormatListCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageFormatListCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_view_formats(mut self, p_view_formats: &'a [vk::Format]) -> Self {
self.inner.view_format_count = p_view_formats.len() as u32;
self.inner.p_view_formats = p_view_formats.as_ptr();
self
}
}
impl<'a> Deref for ImageFormatListCreateInfoBuilder<'a> {
type Target = vk::ImageFormatListCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ValidationCacheCreateInfoEXT {
type Type = ValidationCacheCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ValidationCacheCreateInfoEXTBuilder<'a> {
inner: vk::ValidationCacheCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ValidationCacheCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ValidationCacheCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn initial_data_size(mut self, initial_data_size: usize) -> Self {
self.inner.initial_data_size = initial_data_size;
self
}
pub fn p_initial_data(mut self, p_initial_data: *const c_void) -> Self {
self.inner.p_initial_data = p_initial_data;
self
}
}
impl<'a> Deref for ValidationCacheCreateInfoEXTBuilder<'a> {
type Target = vk::ValidationCacheCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ShaderModuleValidationCacheCreateInfoEXT {
type Type = ShaderModuleValidationCacheCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
inner: vk::ShaderModuleValidationCacheCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn validation_cache(mut self, validation_cache: vk::ValidationCacheEXT) -> Self {
self.inner.validation_cache = Some(validation_cache);
self
}
}
impl<'a> Deref for ShaderModuleValidationCacheCreateInfoEXTBuilder<'a> {
type Target = vk::ShaderModuleValidationCacheCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderDrawParametersFeatures {
type Type = PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceShaderDrawParametersFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
self.inner.shader_draw_parameters = if shader_draw_parameters { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderDrawParametersFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceShaderDrawParametersFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderFloat16Int8Features {
type Type = PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
inner: vk::PhysicalDeviceShaderFloat16Int8Features,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_float16(mut self, shader_float16: bool) -> Self {
self.inner.shader_float16 = if shader_float16 { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_int8(mut self, shader_int8: bool) -> Self {
self.inner.shader_int8 = if shader_int8 { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderFloat16Int8FeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceShaderFloat16Int8Features;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceHostQueryResetFeatures {
type Type = PhysicalDeviceHostQueryResetFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceHostQueryResetFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
self.inner.host_query_reset = if host_query_reset { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceHostQueryResetFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceHostQueryResetFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::NativeBufferANDROID {
type Type = NativeBufferANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct NativeBufferANDROIDBuilder<'a> {
inner: vk::NativeBufferANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> NativeBufferANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle(mut self, handle: *const c_void) -> Self {
self.inner.handle = handle;
self
}
pub fn stride(mut self, stride: c_int) -> Self {
self.inner.stride = stride;
self
}
pub fn format(mut self, format: c_int) -> Self {
self.inner.format = format;
self
}
pub fn usage(mut self, usage: c_int) -> Self {
self.inner.usage = usage;
self
}
pub fn usage2(mut self, usage2: vk::NativeBufferUsage2ANDROID) -> Self {
self.inner.usage2 = usage2;
self
}
}
impl<'a> Deref for NativeBufferANDROIDBuilder<'a> {
type Target = vk::NativeBufferANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SwapchainImageCreateInfoANDROID {
type Type = SwapchainImageCreateInfoANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SwapchainImageCreateInfoANDROIDBuilder<'a> {
inner: vk::SwapchainImageCreateInfoANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SwapchainImageCreateInfoANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn usage(mut self, usage: vk::SwapchainImageUsageFlagsANDROID) -> Self {
self.inner.usage = usage;
self
}
}
impl<'a> Deref for SwapchainImageCreateInfoANDROIDBuilder<'a> {
type Target = vk::SwapchainImageCreateInfoANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevicePresentationPropertiesANDROID {
type Type = PhysicalDevicePresentationPropertiesANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
inner: vk::PhysicalDevicePresentationPropertiesANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shared_image(mut self, shared_image: bool) -> Self {
self.inner.shared_image = if shared_image { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDevicePresentationPropertiesANDROIDBuilder<'a> {
type Target = vk::PhysicalDevicePresentationPropertiesANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceQueueGlobalPriorityCreateInfoEXT {
type Type = DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
inner: vk::DeviceQueueGlobalPriorityCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn global_priority(mut self, global_priority: vk::QueueGlobalPriorityEXT) -> Self {
self.inner.global_priority = global_priority;
self
}
}
impl<'a> Deref for DeviceQueueGlobalPriorityCreateInfoEXTBuilder<'a> {
type Target = vk::DeviceQueueGlobalPriorityCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugUtilsObjectNameInfoEXT {
type Type = DebugUtilsObjectNameInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugUtilsObjectNameInfoEXTBuilder<'a> {
inner: vk::DebugUtilsObjectNameInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugUtilsObjectNameInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn object_type(mut self, object_type: vk::ObjectType) -> Self {
self.inner.object_type = object_type;
self
}
pub fn object_handle(mut self, object_handle: u64) -> Self {
self.inner.object_handle = object_handle;
self
}
pub fn p_object_name(mut self, p_object_name: &'a CStr) -> Self {
self.inner.p_object_name = p_object_name.as_ptr();
self
}
}
impl<'a> Deref for DebugUtilsObjectNameInfoEXTBuilder<'a> {
type Target = vk::DebugUtilsObjectNameInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugUtilsObjectTagInfoEXT {
type Type = DebugUtilsObjectTagInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugUtilsObjectTagInfoEXTBuilder<'a> {
inner: vk::DebugUtilsObjectTagInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugUtilsObjectTagInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn object_type(mut self, object_type: vk::ObjectType) -> Self {
self.inner.object_type = object_type;
self
}
pub fn object_handle(mut self, object_handle: u64) -> Self {
self.inner.object_handle = object_handle;
self
}
pub fn tag_name(mut self, tag_name: u64) -> Self {
self.inner.tag_name = tag_name;
self
}
pub fn tag_size(mut self, tag_size: usize) -> Self {
self.inner.tag_size = tag_size;
self
}
pub fn p_tag(mut self, p_tag: *const c_void) -> Self {
self.inner.p_tag = p_tag;
self
}
}
impl<'a> Deref for DebugUtilsObjectTagInfoEXTBuilder<'a> {
type Target = vk::DebugUtilsObjectTagInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugUtilsLabelEXT {
type Type = DebugUtilsLabelEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugUtilsLabelEXTBuilder<'a> {
inner: vk::DebugUtilsLabelEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugUtilsLabelEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_label_name(mut self, p_label_name: &'a CStr) -> Self {
self.inner.p_label_name = p_label_name.as_ptr();
self
}
}
impl<'a> Deref for DebugUtilsLabelEXTBuilder<'a> {
type Target = vk::DebugUtilsLabelEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugUtilsMessengerCreateInfoEXT {
type Type = DebugUtilsMessengerCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
inner: vk::DebugUtilsMessengerCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DebugUtilsMessengerCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn message_severity(mut self, message_severity: vk::DebugUtilsMessageSeverityFlagsEXT) -> Self {
self.inner.message_severity = message_severity;
self
}
pub fn message_type(mut self, message_type: vk::DebugUtilsMessageTypeFlagsEXT) -> Self {
self.inner.message_type = message_type;
self
}
pub fn pfn_user_callback(mut self, pfn_user_callback: vk::FnDebugUtilsMessengerCallbackEXT) -> Self {
self.inner.pfn_user_callback = Some(pfn_user_callback);
self
}
pub fn p_user_data(mut self, p_user_data: *mut c_void) -> Self {
self.inner.p_user_data = p_user_data;
self
}
}
impl<'a> Deref for DebugUtilsMessengerCreateInfoEXTBuilder<'a> {
type Target = vk::DebugUtilsMessengerCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DebugUtilsMessengerCallbackDataEXT {
type Type = DebugUtilsMessengerCallbackDataEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
inner: vk::DebugUtilsMessengerCallbackDataEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DebugUtilsMessengerCallbackDataFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn p_message_id_name(mut self, p_message_id_name: &'a CStr) -> Self {
self.inner.p_message_id_name = p_message_id_name.as_ptr();
self
}
pub fn message_id_number(mut self, message_id_number: i32) -> Self {
self.inner.message_id_number = message_id_number;
self
}
pub fn p_message(mut self, p_message: &'a CStr) -> Self {
self.inner.p_message = p_message.as_ptr();
self
}
pub fn p_queue_labels(mut self, p_queue_labels: &'a [vk::DebugUtilsLabelEXT]) -> Self {
self.inner.queue_label_count = p_queue_labels.len() as u32;
self.inner.p_queue_labels = p_queue_labels.as_ptr();
self
}
pub fn p_cmd_buf_labels(mut self, p_cmd_buf_labels: &'a [vk::DebugUtilsLabelEXT]) -> Self {
self.inner.cmd_buf_label_count = p_cmd_buf_labels.len() as u32;
self.inner.p_cmd_buf_labels = p_cmd_buf_labels.as_ptr();
self
}
pub fn p_objects(mut self, p_objects: &'a [vk::DebugUtilsObjectNameInfoEXT]) -> Self {
self.inner.object_count = p_objects.len() as u32;
self.inner.p_objects = p_objects.as_ptr();
self
}
}
impl<'a> Deref for DebugUtilsMessengerCallbackDataEXTBuilder<'a> {
type Target = vk::DebugUtilsMessengerCallbackDataEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportMemoryHostPointerInfoEXT {
type Type = ImportMemoryHostPointerInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportMemoryHostPointerInfoEXTBuilder<'a> {
inner: vk::ImportMemoryHostPointerInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportMemoryHostPointerInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn handle_type(mut self, handle_type: vk::ExternalMemoryHandleTypeFlags) -> Self {
self.inner.handle_type = handle_type;
self
}
pub fn p_host_pointer(mut self, p_host_pointer: *mut c_void) -> Self {
self.inner.p_host_pointer = p_host_pointer;
self
}
}
impl<'a> Deref for ImportMemoryHostPointerInfoEXTBuilder<'a> {
type Target = vk::ImportMemoryHostPointerInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CalibratedTimestampInfoEXT {
type Type = CalibratedTimestampInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CalibratedTimestampInfoEXTBuilder<'a> {
inner: vk::CalibratedTimestampInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CalibratedTimestampInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn time_domain(mut self, time_domain: vk::TimeDomainEXT) -> Self {
self.inner.time_domain = time_domain;
self
}
}
impl<'a> Deref for CalibratedTimestampInfoEXTBuilder<'a> {
type Target = vk::CalibratedTimestampInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationConservativeStateCreateInfoEXT {
type Type = PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineRasterizationConservativeStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineRasterizationConservativeStateCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn conservative_rasterization_mode(
mut self,
conservative_rasterization_mode: vk::ConservativeRasterizationModeEXT,
) -> Self {
self.inner.conservative_rasterization_mode = conservative_rasterization_mode;
self
}
pub fn extra_primitive_overestimation_size(mut self, extra_primitive_overestimation_size: f32) -> Self {
self.inner.extra_primitive_overestimation_size = extra_primitive_overestimation_size;
self
}
}
impl<'a> Deref for PipelineRasterizationConservativeStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineRasterizationConservativeStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceDescriptorIndexingFeatures {
type Type = PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceDescriptorIndexingFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_input_attachment_array_dynamic_indexing(
mut self,
shader_input_attachment_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_input_attachment_array_dynamic_indexing = if shader_input_attachment_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
mut self,
shader_uniform_texel_buffer_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_uniform_texel_buffer_array_dynamic_indexing =
if shader_uniform_texel_buffer_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_texel_buffer_array_dynamic_indexing(
mut self,
shader_storage_texel_buffer_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_storage_texel_buffer_array_dynamic_indexing =
if shader_storage_texel_buffer_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_buffer_array_non_uniform_indexing(
mut self,
shader_uniform_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_uniform_buffer_array_non_uniform_indexing =
if shader_uniform_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_sampled_image_array_non_uniform_indexing(
mut self,
shader_sampled_image_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_sampled_image_array_non_uniform_indexing = if shader_sampled_image_array_non_uniform_indexing
{
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_buffer_array_non_uniform_indexing(
mut self,
shader_storage_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_buffer_array_non_uniform_indexing =
if shader_storage_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_image_array_non_uniform_indexing(
mut self,
shader_storage_image_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_image_array_non_uniform_indexing = if shader_storage_image_array_non_uniform_indexing
{
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_input_attachment_array_non_uniform_indexing(
mut self,
shader_input_attachment_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_input_attachment_array_non_uniform_indexing =
if shader_input_attachment_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
mut self,
shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_uniform_texel_buffer_array_non_uniform_indexing =
if shader_uniform_texel_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
mut self,
shader_storage_texel_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_texel_buffer_array_non_uniform_indexing =
if shader_storage_texel_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_uniform_buffer_update_after_bind(
mut self,
descriptor_binding_uniform_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_uniform_buffer_update_after_bind =
if descriptor_binding_uniform_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_sampled_image_update_after_bind(
mut self,
descriptor_binding_sampled_image_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_sampled_image_update_after_bind =
if descriptor_binding_sampled_image_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_image_update_after_bind(
mut self,
descriptor_binding_storage_image_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_image_update_after_bind =
if descriptor_binding_storage_image_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_buffer_update_after_bind(
mut self,
descriptor_binding_storage_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_buffer_update_after_bind =
if descriptor_binding_storage_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
mut self,
descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_uniform_texel_buffer_update_after_bind =
if descriptor_binding_uniform_texel_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
mut self,
descriptor_binding_storage_texel_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_texel_buffer_update_after_bind =
if descriptor_binding_storage_texel_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_update_unused_while_pending(
mut self,
descriptor_binding_update_unused_while_pending: bool,
) -> Self {
self.inner.descriptor_binding_update_unused_while_pending = if descriptor_binding_update_unused_while_pending {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_partially_bound(mut self, descriptor_binding_partially_bound: bool) -> Self {
self.inner.descriptor_binding_partially_bound = if descriptor_binding_partially_bound {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_variable_descriptor_count(
mut self,
descriptor_binding_variable_descriptor_count: bool,
) -> Self {
self.inner.descriptor_binding_variable_descriptor_count = if descriptor_binding_variable_descriptor_count {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
self.inner.runtime_descriptor_array = if runtime_descriptor_array { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceDescriptorIndexingFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceDescriptorIndexingFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorSetLayoutBindingFlagsCreateInfo {
type Type = DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
inner: vk::DescriptorSetLayoutBindingFlagsCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_binding_flags(mut self, p_binding_flags: &'a [vk::DescriptorBindingFlags]) -> Self {
self.inner.binding_count = p_binding_flags.len() as u32;
self.inner.p_binding_flags = p_binding_flags.as_ptr();
self
}
}
impl<'a> Deref for DescriptorSetLayoutBindingFlagsCreateInfoBuilder<'a> {
type Target = vk::DescriptorSetLayoutBindingFlagsCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DescriptorSetVariableDescriptorCountAllocateInfo {
type Type = DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
inner: vk::DescriptorSetVariableDescriptorCountAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_descriptor_counts(mut self, p_descriptor_counts: &'a [u32]) -> Self {
self.inner.descriptor_set_count = p_descriptor_counts.len() as u32;
self.inner.p_descriptor_counts = p_descriptor_counts.as_ptr();
self
}
}
impl<'a> Deref for DescriptorSetVariableDescriptorCountAllocateInfoBuilder<'a> {
type Target = vk::DescriptorSetVariableDescriptorCountAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AttachmentDescription2 {
type Type = AttachmentDescription2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AttachmentDescription2Builder<'a> {
inner: vk::AttachmentDescription2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AttachmentDescription2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::AttachmentDescriptionFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn format(mut self, format: vk::Format) -> Self {
self.inner.format = format;
self
}
pub fn samples(mut self, samples: vk::SampleCountFlags) -> Self {
self.inner.samples = samples;
self
}
pub fn load_op(mut self, load_op: vk::AttachmentLoadOp) -> Self {
self.inner.load_op = load_op;
self
}
pub fn store_op(mut self, store_op: vk::AttachmentStoreOp) -> Self {
self.inner.store_op = store_op;
self
}
pub fn stencil_load_op(mut self, stencil_load_op: vk::AttachmentLoadOp) -> Self {
self.inner.stencil_load_op = stencil_load_op;
self
}
pub fn stencil_store_op(mut self, stencil_store_op: vk::AttachmentStoreOp) -> Self {
self.inner.stencil_store_op = stencil_store_op;
self
}
pub fn initial_layout(mut self, initial_layout: vk::ImageLayout) -> Self {
self.inner.initial_layout = initial_layout;
self
}
pub fn final_layout(mut self, final_layout: vk::ImageLayout) -> Self {
self.inner.final_layout = final_layout;
self
}
}
impl<'a> Deref for AttachmentDescription2Builder<'a> {
type Target = vk::AttachmentDescription2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AttachmentReference2 {
type Type = AttachmentReference2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AttachmentReference2Builder<'a> {
inner: vk::AttachmentReference2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AttachmentReference2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn attachment(mut self, attachment: u32) -> Self {
self.inner.attachment = attachment;
self
}
pub fn layout(mut self, layout: vk::ImageLayout) -> Self {
self.inner.layout = layout;
self
}
pub fn aspect_mask(mut self, aspect_mask: vk::ImageAspectFlags) -> Self {
self.inner.aspect_mask = aspect_mask;
self
}
}
impl<'a> Deref for AttachmentReference2Builder<'a> {
type Target = vk::AttachmentReference2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassDescription2 {
type Type = SubpassDescription2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassDescription2Builder<'a> {
inner: vk::SubpassDescription2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubpassDescription2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::SubpassDescriptionFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn pipeline_bind_point(mut self, pipeline_bind_point: vk::PipelineBindPoint) -> Self {
self.inner.pipeline_bind_point = pipeline_bind_point;
self
}
pub fn view_mask(mut self, view_mask: u32) -> Self {
self.inner.view_mask = view_mask;
self
}
pub fn p_input_attachments(mut self, p_input_attachments: &'a [vk::AttachmentReference2]) -> Self {
self.inner.input_attachment_count = p_input_attachments.len() as u32;
self.inner.p_input_attachments = p_input_attachments.as_ptr();
self
}
pub fn p_color_attachments(
mut self,
p_color_attachments: &'a [vk::AttachmentReference2],
p_resolve_attachments: Option<&'a [vk::AttachmentReference2]>,
) -> Self {
self.inner.color_attachment_count = p_color_attachments.len() as u32;
if let Some(s) = p_resolve_attachments {
assert_eq!(self.inner.color_attachment_count, s.len() as u32);
}
self.inner.p_color_attachments = p_color_attachments.as_ptr();
self.inner.p_resolve_attachments = p_resolve_attachments.map_or(ptr::null(), |s| s.as_ptr());
self
}
pub fn p_depth_stencil_attachment(
mut self,
p_depth_stencil_attachment: Option<&'a vk::AttachmentReference2>,
) -> Self {
self.inner.p_depth_stencil_attachment = p_depth_stencil_attachment.map_or(ptr::null(), |p| p);
self
}
pub fn p_preserve_attachments(mut self, p_preserve_attachments: &'a [u32]) -> Self {
self.inner.preserve_attachment_count = p_preserve_attachments.len() as u32;
self.inner.p_preserve_attachments = p_preserve_attachments.as_ptr();
self
}
}
impl<'a> Deref for SubpassDescription2Builder<'a> {
type Target = vk::SubpassDescription2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassDependency2 {
type Type = SubpassDependency2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassDependency2Builder<'a> {
inner: vk::SubpassDependency2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubpassDependency2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src_subpass(mut self, src_subpass: u32) -> Self {
self.inner.src_subpass = src_subpass;
self
}
pub fn dst_subpass(mut self, dst_subpass: u32) -> Self {
self.inner.dst_subpass = dst_subpass;
self
}
pub fn src_stage_mask(mut self, src_stage_mask: vk::PipelineStageFlags) -> Self {
self.inner.src_stage_mask = src_stage_mask;
self
}
pub fn dst_stage_mask(mut self, dst_stage_mask: vk::PipelineStageFlags) -> Self {
self.inner.dst_stage_mask = dst_stage_mask;
self
}
pub fn src_access_mask(mut self, src_access_mask: vk::AccessFlags) -> Self {
self.inner.src_access_mask = src_access_mask;
self
}
pub fn dst_access_mask(mut self, dst_access_mask: vk::AccessFlags) -> Self {
self.inner.dst_access_mask = dst_access_mask;
self
}
pub fn dependency_flags(mut self, dependency_flags: vk::DependencyFlags) -> Self {
self.inner.dependency_flags = dependency_flags;
self
}
pub fn view_offset(mut self, view_offset: i32) -> Self {
self.inner.view_offset = view_offset;
self
}
}
impl<'a> Deref for SubpassDependency2Builder<'a> {
type Target = vk::SubpassDependency2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassCreateInfo2 {
type Type = RenderPassCreateInfo2Builder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassCreateInfo2Builder<'a> {
inner: vk::RenderPassCreateInfo2,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassCreateInfo2Builder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::RenderPassCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_attachments(mut self, p_attachments: &'a [vk::AttachmentDescription2]) -> Self {
self.inner.attachment_count = p_attachments.len() as u32;
self.inner.p_attachments = p_attachments.as_ptr();
self
}
pub fn p_subpasses(mut self, p_subpasses: &'a [vk::SubpassDescription2]) -> Self {
self.inner.subpass_count = p_subpasses.len() as u32;
self.inner.p_subpasses = p_subpasses.as_ptr();
self
}
pub fn p_dependencies(mut self, p_dependencies: &'a [vk::SubpassDependency2]) -> Self {
self.inner.dependency_count = p_dependencies.len() as u32;
self.inner.p_dependencies = p_dependencies.as_ptr();
self
}
pub fn p_correlated_view_masks(mut self, p_correlated_view_masks: &'a [u32]) -> Self {
self.inner.correlated_view_mask_count = p_correlated_view_masks.len() as u32;
self.inner.p_correlated_view_masks = p_correlated_view_masks.as_ptr();
self
}
}
impl<'a> Deref for RenderPassCreateInfo2Builder<'a> {
type Target = vk::RenderPassCreateInfo2;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassBeginInfo {
type Type = SubpassBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassBeginInfoBuilder<'a> {
inner: vk::SubpassBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubpassBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn contents(mut self, contents: vk::SubpassContents) -> Self {
self.inner.contents = contents;
self
}
}
impl<'a> Deref for SubpassBeginInfoBuilder<'a> {
type Target = vk::SubpassBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassEndInfo {
type Type = SubpassEndInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassEndInfoBuilder<'a> {
inner: vk::SubpassEndInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubpassEndInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
}
impl<'a> Deref for SubpassEndInfoBuilder<'a> {
type Target = vk::SubpassEndInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceTimelineSemaphoreFeatures {
type Type = PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceTimelineSemaphoreFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
self.inner.timeline_semaphore = if timeline_semaphore { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceTimelineSemaphoreFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceTimelineSemaphoreFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreTypeCreateInfo {
type Type = SemaphoreTypeCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreTypeCreateInfoBuilder<'a> {
inner: vk::SemaphoreTypeCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreTypeCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore_type(mut self, semaphore_type: vk::SemaphoreType) -> Self {
self.inner.semaphore_type = semaphore_type;
self
}
pub fn initial_value(mut self, initial_value: u64) -> Self {
self.inner.initial_value = initial_value;
self
}
}
impl<'a> Deref for SemaphoreTypeCreateInfoBuilder<'a> {
type Target = vk::SemaphoreTypeCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::TimelineSemaphoreSubmitInfo {
type Type = TimelineSemaphoreSubmitInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct TimelineSemaphoreSubmitInfoBuilder<'a> {
inner: vk::TimelineSemaphoreSubmitInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> TimelineSemaphoreSubmitInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_wait_semaphore_values(mut self, p_wait_semaphore_values: &'a [u64]) -> Self {
self.inner.wait_semaphore_value_count = p_wait_semaphore_values.len() as u32;
self.inner.p_wait_semaphore_values = p_wait_semaphore_values.as_ptr();
self
}
pub fn p_signal_semaphore_values(mut self, p_signal_semaphore_values: &'a [u64]) -> Self {
self.inner.signal_semaphore_value_count = p_signal_semaphore_values.len() as u32;
self.inner.p_signal_semaphore_values = p_signal_semaphore_values.as_ptr();
self
}
}
impl<'a> Deref for TimelineSemaphoreSubmitInfoBuilder<'a> {
type Target = vk::TimelineSemaphoreSubmitInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreWaitInfo {
type Type = SemaphoreWaitInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreWaitInfoBuilder<'a> {
inner: vk::SemaphoreWaitInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreWaitInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::SemaphoreWaitFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_semaphores(mut self, p_semaphores: &'a [vk::Semaphore], p_values: &'a [u64]) -> Self {
self.inner.semaphore_count = p_semaphores.len() as u32;
assert_eq!(self.inner.semaphore_count, p_values.len() as u32);
self.inner.p_semaphores = p_semaphores.as_ptr();
self.inner.p_values = p_values.as_ptr();
self
}
}
impl<'a> Deref for SemaphoreWaitInfoBuilder<'a> {
type Target = vk::SemaphoreWaitInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SemaphoreSignalInfo {
type Type = SemaphoreSignalInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SemaphoreSignalInfoBuilder<'a> {
inner: vk::SemaphoreSignalInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SemaphoreSignalInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn semaphore(mut self, semaphore: vk::Semaphore) -> Self {
self.inner.semaphore = Some(semaphore);
self
}
pub fn value(mut self, value: u64) -> Self {
self.inner.value = value;
self
}
}
impl<'a> Deref for SemaphoreSignalInfoBuilder<'a> {
type Target = vk::SemaphoreSignalInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineVertexInputDivisorStateCreateInfoEXT {
type Type = PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineVertexInputDivisorStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_vertex_binding_divisors(
mut self,
p_vertex_binding_divisors: &'a [vk::VertexInputBindingDivisorDescriptionEXT],
) -> Self {
self.inner.vertex_binding_divisor_count = p_vertex_binding_divisors.len() as u32;
self.inner.p_vertex_binding_divisors = p_vertex_binding_divisors.as_ptr();
self
}
}
impl<'a> Deref for PipelineVertexInputDivisorStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineVertexInputDivisorStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImportAndroidHardwareBufferInfoANDROID {
type Type = ImportAndroidHardwareBufferInfoANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
inner: vk::ImportAndroidHardwareBufferInfoANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer(mut self, buffer: *mut vk::AHardwareBuffer) -> Self {
self.inner.buffer = buffer;
self
}
}
impl<'a> Deref for ImportAndroidHardwareBufferInfoANDROIDBuilder<'a> {
type Target = vk::ImportAndroidHardwareBufferInfoANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryGetAndroidHardwareBufferInfoANDROID {
type Type = MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
inner: vk::MemoryGetAndroidHardwareBufferInfoANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
}
impl<'a> Deref for MemoryGetAndroidHardwareBufferInfoANDROIDBuilder<'a> {
type Target = vk::MemoryGetAndroidHardwareBufferInfoANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandBufferInheritanceConditionalRenderingInfoEXT {
type Type = CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
inner: vk::CommandBufferInheritanceConditionalRenderingInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn conditional_rendering_enable(mut self, conditional_rendering_enable: bool) -> Self {
self.inner.conditional_rendering_enable = if conditional_rendering_enable {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for CommandBufferInheritanceConditionalRenderingInfoEXTBuilder<'a> {
type Target = vk::CommandBufferInheritanceConditionalRenderingInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ExternalFormatANDROID {
type Type = ExternalFormatANDROIDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ExternalFormatANDROIDBuilder<'a> {
inner: vk::ExternalFormatANDROID,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ExternalFormatANDROIDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn external_format(mut self, external_format: u64) -> Self {
self.inner.external_format = external_format;
self
}
}
impl<'a> Deref for ExternalFormatANDROIDBuilder<'a> {
type Target = vk::ExternalFormatANDROID;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevice8BitStorageFeatures {
type Type = PhysicalDevice8BitStorageFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevice8BitStorageFeaturesBuilder<'a> {
inner: vk::PhysicalDevice8BitStorageFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevice8BitStorageFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
self.inner.storage_buffer8_bit_access = if storage_buffer8_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn uniform_and_storage_buffer8_bit_access(mut self, uniform_and_storage_buffer8_bit_access: bool) -> Self {
self.inner.uniform_and_storage_buffer8_bit_access = if uniform_and_storage_buffer8_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
self.inner.storage_push_constant8 = if storage_push_constant8 { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDevice8BitStorageFeaturesBuilder<'a> {
type Target = vk::PhysicalDevice8BitStorageFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceConditionalRenderingFeaturesEXT {
type Type = PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceConditionalRenderingFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn conditional_rendering(mut self, conditional_rendering: bool) -> Self {
self.inner.conditional_rendering = if conditional_rendering { vk::TRUE } else { vk::FALSE };
self
}
pub fn inherited_conditional_rendering(mut self, inherited_conditional_rendering: bool) -> Self {
self.inner.inherited_conditional_rendering = if inherited_conditional_rendering {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceConditionalRenderingFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceConditionalRenderingFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVulkanMemoryModelFeatures {
type Type = PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceVulkanMemoryModelFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
self.inner.vulkan_memory_model = if vulkan_memory_model { vk::TRUE } else { vk::FALSE };
self
}
pub fn vulkan_memory_model_device_scope(mut self, vulkan_memory_model_device_scope: bool) -> Self {
self.inner.vulkan_memory_model_device_scope = if vulkan_memory_model_device_scope {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn vulkan_memory_model_availability_visibility_chains(
mut self,
vulkan_memory_model_availability_visibility_chains: bool,
) -> Self {
self.inner.vulkan_memory_model_availability_visibility_chains =
if vulkan_memory_model_availability_visibility_chains {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceVulkanMemoryModelFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceVulkanMemoryModelFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderAtomicInt64Features {
type Type = PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
inner: vk::PhysicalDeviceShaderAtomicInt64Features,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
self.inner.shader_buffer_int64_atomics = if shader_buffer_int64_atomics {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
self.inner.shader_shared_int64_atomics = if shader_shared_int64_atomics {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceShaderAtomicInt64FeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceShaderAtomicInt64Features;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
type Type = PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn vertex_attribute_instance_rate_divisor(mut self, vertex_attribute_instance_rate_divisor: bool) -> Self {
self.inner.vertex_attribute_instance_rate_divisor = if vertex_attribute_instance_rate_divisor {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn vertex_attribute_instance_rate_zero_divisor(
mut self,
vertex_attribute_instance_rate_zero_divisor: bool,
) -> Self {
self.inner.vertex_attribute_instance_rate_zero_divisor = if vertex_attribute_instance_rate_zero_divisor {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceVertexAttributeDivisorFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceVertexAttributeDivisorFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SubpassDescriptionDepthStencilResolve {
type Type = SubpassDescriptionDepthStencilResolveBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SubpassDescriptionDepthStencilResolveBuilder<'a> {
inner: vk::SubpassDescriptionDepthStencilResolve,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SubpassDescriptionDepthStencilResolveBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn depth_resolve_mode(mut self, depth_resolve_mode: vk::ResolveModeFlags) -> Self {
self.inner.depth_resolve_mode = depth_resolve_mode;
self
}
pub fn stencil_resolve_mode(mut self, stencil_resolve_mode: vk::ResolveModeFlags) -> Self {
self.inner.stencil_resolve_mode = stencil_resolve_mode;
self
}
pub fn p_depth_stencil_resolve_attachment(
mut self,
p_depth_stencil_resolve_attachment: Option<&'a vk::AttachmentReference2>,
) -> Self {
self.inner.p_depth_stencil_resolve_attachment = p_depth_stencil_resolve_attachment.map_or(ptr::null(), |p| p);
self
}
}
impl<'a> Deref for SubpassDescriptionDepthStencilResolveBuilder<'a> {
type Target = vk::SubpassDescriptionDepthStencilResolve;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageViewASTCDecodeModeEXT {
type Type = ImageViewASTCDecodeModeEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageViewASTCDecodeModeEXTBuilder<'a> {
inner: vk::ImageViewASTCDecodeModeEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageViewASTCDecodeModeEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn decode_mode(mut self, decode_mode: vk::Format) -> Self {
self.inner.decode_mode = decode_mode;
self
}
}
impl<'a> Deref for ImageViewASTCDecodeModeEXTBuilder<'a> {
type Target = vk::ImageViewASTCDecodeModeEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceASTCDecodeFeaturesEXT {
type Type = PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceASTCDecodeFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn decode_mode_shared_exponent(mut self, decode_mode_shared_exponent: bool) -> Self {
self.inner.decode_mode_shared_exponent = if decode_mode_shared_exponent {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceASTCDecodeFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceASTCDecodeFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceTransformFeedbackFeaturesEXT {
type Type = PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceTransformFeedbackFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn transform_feedback(mut self, transform_feedback: bool) -> Self {
self.inner.transform_feedback = if transform_feedback { vk::TRUE } else { vk::FALSE };
self
}
pub fn geometry_streams(mut self, geometry_streams: bool) -> Self {
self.inner.geometry_streams = if geometry_streams { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceTransformFeedbackFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceTransformFeedbackFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationStateStreamCreateInfoEXT {
type Type = PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
inner: vk::PipelineRasterizationStateStreamCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineRasterizationStateStreamCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn rasterization_stream(mut self, rasterization_stream: u32) -> Self {
self.inner.rasterization_stream = rasterization_stream;
self
}
}
impl<'a> Deref for PipelineRasterizationStateStreamCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineRasterizationStateStreamCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
type Type = PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn representative_fragment_test(mut self, representative_fragment_test: bool) -> Self {
self.inner.representative_fragment_test = if representative_fragment_test {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceRepresentativeFragmentTestFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceRepresentativeFragmentTestFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRepresentativeFragmentTestStateCreateInfoNV {
type Type = PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineRepresentativeFragmentTestStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn representative_fragment_test_enable(mut self, representative_fragment_test_enable: bool) -> Self {
self.inner.representative_fragment_test_enable = if representative_fragment_test_enable {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PipelineRepresentativeFragmentTestStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineRepresentativeFragmentTestStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceExclusiveScissorFeaturesNV {
type Type = PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceExclusiveScissorFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn exclusive_scissor(mut self, exclusive_scissor: bool) -> Self {
self.inner.exclusive_scissor = if exclusive_scissor { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceExclusiveScissorFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceExclusiveScissorFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportExclusiveScissorStateCreateInfoNV {
type Type = PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineViewportExclusiveScissorStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_exclusive_scissors(mut self, p_exclusive_scissors: &'a [vk::Rect2D]) -> Self {
self.inner.exclusive_scissor_count = p_exclusive_scissors.len() as u32;
self.inner.p_exclusive_scissors = p_exclusive_scissors.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportExclusiveScissorStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineViewportExclusiveScissorStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceCornerSampledImageFeaturesNV {
type Type = PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceCornerSampledImageFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn corner_sampled_image(mut self, corner_sampled_image: bool) -> Self {
self.inner.corner_sampled_image = if corner_sampled_image { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceCornerSampledImageFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceCornerSampledImageFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV {
type Type = PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn compute_derivative_group_quads(mut self, compute_derivative_group_quads: bool) -> Self {
self.inner.compute_derivative_group_quads = if compute_derivative_group_quads {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn compute_derivative_group_linear(mut self, compute_derivative_group_linear: bool) -> Self {
self.inner.compute_derivative_group_linear = if compute_derivative_group_linear {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceComputeShaderDerivativesFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceComputeShaderDerivativesFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
type Type = PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fragment_shader_barycentric(mut self, fragment_shader_barycentric: bool) -> Self {
self.inner.fragment_shader_barycentric = if fragment_shader_barycentric {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceFragmentShaderBarycentricFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceFragmentShaderBarycentricFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderImageFootprintFeaturesNV {
type Type = PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceShaderImageFootprintFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image_footprint(mut self, image_footprint: bool) -> Self {
self.inner.image_footprint = if image_footprint { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderImageFootprintFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceShaderImageFootprintFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
type Type = PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn dedicated_allocation_image_aliasing(mut self, dedicated_allocation_image_aliasing: bool) -> Self {
self.inner.dedicated_allocation_image_aliasing = if dedicated_allocation_image_aliasing {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ShadingRatePaletteNV {
type Type = ShadingRatePaletteNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ShadingRatePaletteNVBuilder<'a> {
inner: vk::ShadingRatePaletteNV,
phantom: PhantomData<&'a vk::ShadingRatePaletteEntryNV>,
}
impl<'a> ShadingRatePaletteNVBuilder<'a> {
pub fn p_shading_rate_palette_entries(
mut self,
p_shading_rate_palette_entries: &'a [vk::ShadingRatePaletteEntryNV],
) -> Self {
self.inner.shading_rate_palette_entry_count = p_shading_rate_palette_entries.len() as u32;
self.inner.p_shading_rate_palette_entries = p_shading_rate_palette_entries.as_ptr();
self
}
}
impl<'a> Deref for ShadingRatePaletteNVBuilder<'a> {
type Target = vk::ShadingRatePaletteNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportShadingRateImageStateCreateInfoNV {
type Type = PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineViewportShadingRateImageStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shading_rate_image_enable(mut self, shading_rate_image_enable: bool) -> Self {
self.inner.shading_rate_image_enable = if shading_rate_image_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn p_shading_rate_palettes(mut self, p_shading_rate_palettes: &'a [vk::ShadingRatePaletteNV]) -> Self {
self.inner.viewport_count = p_shading_rate_palettes.len() as u32;
self.inner.p_shading_rate_palettes = p_shading_rate_palettes.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportShadingRateImageStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineViewportShadingRateImageStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShadingRateImageFeaturesNV {
type Type = PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceShadingRateImageFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shading_rate_image(mut self, shading_rate_image: bool) -> Self {
self.inner.shading_rate_image = if shading_rate_image { vk::TRUE } else { vk::FALSE };
self
}
pub fn shading_rate_coarse_sample_order(mut self, shading_rate_coarse_sample_order: bool) -> Self {
self.inner.shading_rate_coarse_sample_order = if shading_rate_coarse_sample_order {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceShadingRateImageFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceShadingRateImageFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CoarseSampleOrderCustomNV {
type Type = CoarseSampleOrderCustomNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CoarseSampleOrderCustomNVBuilder<'a> {
inner: vk::CoarseSampleOrderCustomNV,
phantom: PhantomData<&'a vk::CoarseSampleLocationNV>,
}
impl<'a> CoarseSampleOrderCustomNVBuilder<'a> {
pub fn shading_rate(mut self, shading_rate: vk::ShadingRatePaletteEntryNV) -> Self {
self.inner.shading_rate = shading_rate;
self
}
pub fn sample_count(mut self, sample_count: u32) -> Self {
self.inner.sample_count = sample_count;
self
}
pub fn p_sample_locations(mut self, p_sample_locations: &'a [vk::CoarseSampleLocationNV]) -> Self {
self.inner.sample_location_count = p_sample_locations.len() as u32;
self.inner.p_sample_locations = p_sample_locations.as_ptr();
self
}
}
impl<'a> Deref for CoarseSampleOrderCustomNVBuilder<'a> {
type Target = vk::CoarseSampleOrderCustomNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV {
type Type = PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn sample_order_type(mut self, sample_order_type: vk::CoarseSampleOrderTypeNV) -> Self {
self.inner.sample_order_type = sample_order_type;
self
}
pub fn p_custom_sample_orders(mut self, p_custom_sample_orders: &'a [vk::CoarseSampleOrderCustomNV]) -> Self {
self.inner.custom_sample_order_count = p_custom_sample_orders.len() as u32;
self.inner.p_custom_sample_orders = p_custom_sample_orders.as_ptr();
self
}
}
impl<'a> Deref for PipelineViewportCoarseSampleOrderStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineViewportCoarseSampleOrderStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceMeshShaderFeaturesNV {
type Type = PhysicalDeviceMeshShaderFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceMeshShaderFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn task_shader(mut self, task_shader: bool) -> Self {
self.inner.task_shader = if task_shader { vk::TRUE } else { vk::FALSE };
self
}
pub fn mesh_shader(mut self, mesh_shader: bool) -> Self {
self.inner.mesh_shader = if mesh_shader { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceMeshShaderFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceMeshShaderFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RayTracingShaderGroupCreateInfoNV {
type Type = RayTracingShaderGroupCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RayTracingShaderGroupCreateInfoNVBuilder<'a> {
inner: vk::RayTracingShaderGroupCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RayTracingShaderGroupCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::RayTracingShaderGroupTypeKHR) -> Self {
self.inner.ty = ty;
self
}
pub fn general_shader(mut self, general_shader: u32) -> Self {
self.inner.general_shader = general_shader;
self
}
pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
self.inner.closest_hit_shader = closest_hit_shader;
self
}
pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
self.inner.any_hit_shader = any_hit_shader;
self
}
pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
self.inner.intersection_shader = intersection_shader;
self
}
}
impl<'a> Deref for RayTracingShaderGroupCreateInfoNVBuilder<'a> {
type Target = vk::RayTracingShaderGroupCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RayTracingShaderGroupCreateInfoKHR {
type Type = RayTracingShaderGroupCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
inner: vk::RayTracingShaderGroupCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::RayTracingShaderGroupTypeKHR) -> Self {
self.inner.ty = ty;
self
}
pub fn general_shader(mut self, general_shader: u32) -> Self {
self.inner.general_shader = general_shader;
self
}
pub fn closest_hit_shader(mut self, closest_hit_shader: u32) -> Self {
self.inner.closest_hit_shader = closest_hit_shader;
self
}
pub fn any_hit_shader(mut self, any_hit_shader: u32) -> Self {
self.inner.any_hit_shader = any_hit_shader;
self
}
pub fn intersection_shader(mut self, intersection_shader: u32) -> Self {
self.inner.intersection_shader = intersection_shader;
self
}
pub fn p_shader_group_capture_replay_handle(mut self, p_shader_group_capture_replay_handle: *const c_void) -> Self {
self.inner.p_shader_group_capture_replay_handle = p_shader_group_capture_replay_handle;
self
}
}
impl<'a> Deref for RayTracingShaderGroupCreateInfoKHRBuilder<'a> {
type Target = vk::RayTracingShaderGroupCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RayTracingPipelineCreateInfoNV {
type Type = RayTracingPipelineCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RayTracingPipelineCreateInfoNVBuilder<'a> {
inner: vk::RayTracingPipelineCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RayTracingPipelineCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_stages(mut self, p_stages: &'a [vk::PipelineShaderStageCreateInfo]) -> Self {
self.inner.stage_count = p_stages.len() as u32;
self.inner.p_stages = p_stages.as_ptr();
self
}
pub fn p_groups(mut self, p_groups: &'a [vk::RayTracingShaderGroupCreateInfoNV]) -> Self {
self.inner.group_count = p_groups.len() as u32;
self.inner.p_groups = p_groups.as_ptr();
self
}
pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
self.inner.max_recursion_depth = max_recursion_depth;
self
}
pub fn layout(mut self, layout: vk::PipelineLayout) -> Self {
self.inner.layout = Some(layout);
self
}
pub fn base_pipeline_handle(mut self, base_pipeline_handle: Option<vk::Pipeline>) -> Self {
self.inner.base_pipeline_handle = base_pipeline_handle;
self
}
pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
self.inner.base_pipeline_index = base_pipeline_index;
self
}
}
impl<'a> Deref for RayTracingPipelineCreateInfoNVBuilder<'a> {
type Target = vk::RayTracingPipelineCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RayTracingPipelineCreateInfoKHR {
type Type = RayTracingPipelineCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RayTracingPipelineCreateInfoKHRBuilder<'a> {
inner: vk::RayTracingPipelineCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RayTracingPipelineCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn p_stages(mut self, p_stages: &'a [vk::PipelineShaderStageCreateInfo]) -> Self {
self.inner.stage_count = p_stages.len() as u32;
self.inner.p_stages = p_stages.as_ptr();
self
}
pub fn p_groups(mut self, p_groups: &'a [vk::RayTracingShaderGroupCreateInfoKHR]) -> Self {
self.inner.group_count = p_groups.len() as u32;
self.inner.p_groups = p_groups.as_ptr();
self
}
pub fn max_recursion_depth(mut self, max_recursion_depth: u32) -> Self {
self.inner.max_recursion_depth = max_recursion_depth;
self
}
pub fn libraries(mut self, libraries: vk::PipelineLibraryCreateInfoKHR) -> Self {
self.inner.libraries = libraries;
self
}
pub fn p_library_interface(
mut self,
p_library_interface: Option<&'a vk::RayTracingPipelineInterfaceCreateInfoKHR>,
) -> Self {
self.inner.p_library_interface = p_library_interface.map_or(ptr::null(), |p| p);
self
}
pub fn layout(mut self, layout: vk::PipelineLayout) -> Self {
self.inner.layout = Some(layout);
self
}
pub fn base_pipeline_handle(mut self, base_pipeline_handle: Option<vk::Pipeline>) -> Self {
self.inner.base_pipeline_handle = base_pipeline_handle;
self
}
pub fn base_pipeline_index(mut self, base_pipeline_index: i32) -> Self {
self.inner.base_pipeline_index = base_pipeline_index;
self
}
}
impl<'a> Deref for RayTracingPipelineCreateInfoKHRBuilder<'a> {
type Target = vk::RayTracingPipelineCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GeometryTrianglesNV {
type Type = GeometryTrianglesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GeometryTrianglesNVBuilder<'a> {
inner: vk::GeometryTrianglesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GeometryTrianglesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn vertex_data(mut self, vertex_data: Option<vk::Buffer>) -> Self {
self.inner.vertex_data = vertex_data;
self
}
pub fn vertex_offset(mut self, vertex_offset: vk::DeviceSize) -> Self {
self.inner.vertex_offset = vertex_offset;
self
}
pub fn vertex_count(mut self, vertex_count: u32) -> Self {
self.inner.vertex_count = vertex_count;
self
}
pub fn vertex_stride(mut self, vertex_stride: vk::DeviceSize) -> Self {
self.inner.vertex_stride = vertex_stride;
self
}
pub fn vertex_format(mut self, vertex_format: vk::Format) -> Self {
self.inner.vertex_format = vertex_format;
self
}
pub fn index_data(mut self, index_data: Option<vk::Buffer>) -> Self {
self.inner.index_data = index_data;
self
}
pub fn index_offset(mut self, index_offset: vk::DeviceSize) -> Self {
self.inner.index_offset = index_offset;
self
}
pub fn index_count(mut self, index_count: u32) -> Self {
self.inner.index_count = index_count;
self
}
pub fn index_type(mut self, index_type: vk::IndexType) -> Self {
self.inner.index_type = index_type;
self
}
pub fn transform_data(mut self, transform_data: Option<vk::Buffer>) -> Self {
self.inner.transform_data = transform_data;
self
}
pub fn transform_offset(mut self, transform_offset: vk::DeviceSize) -> Self {
self.inner.transform_offset = transform_offset;
self
}
}
impl<'a> Deref for GeometryTrianglesNVBuilder<'a> {
type Target = vk::GeometryTrianglesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GeometryAABBNV {
type Type = GeometryAABBNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GeometryAABBNVBuilder<'a> {
inner: vk::GeometryAABBNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GeometryAABBNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn aabb_data(mut self, aabb_data: Option<vk::Buffer>) -> Self {
self.inner.aabb_data = aabb_data;
self
}
pub fn num_aab_bs(mut self, num_aab_bs: u32) -> Self {
self.inner.num_aab_bs = num_aab_bs;
self
}
pub fn stride(mut self, stride: u32) -> Self {
self.inner.stride = stride;
self
}
pub fn offset(mut self, offset: vk::DeviceSize) -> Self {
self.inner.offset = offset;
self
}
}
impl<'a> Deref for GeometryAABBNVBuilder<'a> {
type Target = vk::GeometryAABBNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::GeometryNV {
type Type = GeometryNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct GeometryNVBuilder<'a> {
inner: vk::GeometryNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> GeometryNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn geometry_type(mut self, geometry_type: vk::GeometryTypeKHR) -> Self {
self.inner.geometry_type = geometry_type;
self
}
pub fn geometry(mut self, geometry: vk::GeometryDataNV) -> Self {
self.inner.geometry = geometry;
self
}
pub fn flags(mut self, flags: vk::GeometryFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for GeometryNVBuilder<'a> {
type Target = vk::GeometryNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureInfoNV {
type Type = AccelerationStructureInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureInfoNVBuilder<'a> {
inner: vk::AccelerationStructureInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::AccelerationStructureTypeNV) -> Self {
self.inner.ty = ty;
self
}
pub fn flags(mut self, flags: vk::BuildAccelerationStructureFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn instance_count(mut self, instance_count: u32) -> Self {
self.inner.instance_count = instance_count;
self
}
pub fn p_geometries(mut self, p_geometries: &'a [vk::GeometryNV]) -> Self {
self.inner.geometry_count = p_geometries.len() as u32;
self.inner.p_geometries = p_geometries.as_ptr();
self
}
}
impl<'a> Deref for AccelerationStructureInfoNVBuilder<'a> {
type Target = vk::AccelerationStructureInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureCreateInfoNV {
type Type = AccelerationStructureCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureCreateInfoNVBuilder<'a> {
inner: vk::AccelerationStructureCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn compacted_size(mut self, compacted_size: vk::DeviceSize) -> Self {
self.inner.compacted_size = compacted_size;
self
}
pub fn info(mut self, info: vk::AccelerationStructureInfoNV) -> Self {
self.inner.info = info;
self
}
}
impl<'a> Deref for AccelerationStructureCreateInfoNVBuilder<'a> {
type Target = vk::AccelerationStructureCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BindAccelerationStructureMemoryInfoKHR {
type Type = BindAccelerationStructureMemoryInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
inner: vk::BindAccelerationStructureMemoryInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn acceleration_structure(mut self, acceleration_structure: vk::AccelerationStructureKHR) -> Self {
self.inner.acceleration_structure = Some(acceleration_structure);
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
pub fn memory_offset(mut self, memory_offset: vk::DeviceSize) -> Self {
self.inner.memory_offset = memory_offset;
self
}
pub fn p_device_indices(mut self, p_device_indices: &'a [u32]) -> Self {
self.inner.device_index_count = p_device_indices.len() as u32;
self.inner.p_device_indices = p_device_indices.as_ptr();
self
}
}
impl<'a> Deref for BindAccelerationStructureMemoryInfoKHRBuilder<'a> {
type Target = vk::BindAccelerationStructureMemoryInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::WriteDescriptorSetAccelerationStructureKHR {
type Type = WriteDescriptorSetAccelerationStructureKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
inner: vk::WriteDescriptorSetAccelerationStructureKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_acceleration_structures(mut self, p_acceleration_structures: &'a [vk::AccelerationStructureKHR]) -> Self {
self.inner.acceleration_structure_count = p_acceleration_structures.len() as u32;
self.inner.p_acceleration_structures = p_acceleration_structures.as_ptr();
self
}
}
impl<'a> Deref for WriteDescriptorSetAccelerationStructureKHRBuilder<'a> {
type Target = vk::WriteDescriptorSetAccelerationStructureKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureMemoryRequirementsInfoKHR {
type Type = AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
inner: vk::AccelerationStructureMemoryRequirementsInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::AccelerationStructureMemoryRequirementsTypeKHR) -> Self {
self.inner.ty = ty;
self
}
pub fn build_type(mut self, build_type: vk::AccelerationStructureBuildTypeKHR) -> Self {
self.inner.build_type = build_type;
self
}
pub fn acceleration_structure(mut self, acceleration_structure: vk::AccelerationStructureKHR) -> Self {
self.inner.acceleration_structure = Some(acceleration_structure);
self
}
}
impl<'a> Deref for AccelerationStructureMemoryRequirementsInfoKHRBuilder<'a> {
type Target = vk::AccelerationStructureMemoryRequirementsInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureMemoryRequirementsInfoNV {
type Type = AccelerationStructureMemoryRequirementsInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
inner: vk::AccelerationStructureMemoryRequirementsInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::AccelerationStructureMemoryRequirementsTypeNV) -> Self {
self.inner.ty = ty;
self
}
pub fn acceleration_structure(mut self, acceleration_structure: vk::AccelerationStructureNV) -> Self {
self.inner.acceleration_structure = Some(acceleration_structure);
self
}
}
impl<'a> Deref for AccelerationStructureMemoryRequirementsInfoNVBuilder<'a> {
type Target = vk::AccelerationStructureMemoryRequirementsInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceRayTracingFeaturesKHR {
type Type = PhysicalDeviceRayTracingFeaturesKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
inner: vk::PhysicalDeviceRayTracingFeaturesKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ray_tracing(mut self, ray_tracing: bool) -> Self {
self.inner.ray_tracing = if ray_tracing { vk::TRUE } else { vk::FALSE };
self
}
pub fn ray_tracing_shader_group_handle_capture_replay(
mut self,
ray_tracing_shader_group_handle_capture_replay: bool,
) -> Self {
self.inner.ray_tracing_shader_group_handle_capture_replay = if ray_tracing_shader_group_handle_capture_replay {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_tracing_shader_group_handle_capture_replay_mixed(
mut self,
ray_tracing_shader_group_handle_capture_replay_mixed: bool,
) -> Self {
self.inner.ray_tracing_shader_group_handle_capture_replay_mixed =
if ray_tracing_shader_group_handle_capture_replay_mixed {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_tracing_acceleration_structure_capture_replay(
mut self,
ray_tracing_acceleration_structure_capture_replay: bool,
) -> Self {
self.inner.ray_tracing_acceleration_structure_capture_replay =
if ray_tracing_acceleration_structure_capture_replay {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_tracing_indirect_trace_rays(mut self, ray_tracing_indirect_trace_rays: bool) -> Self {
self.inner.ray_tracing_indirect_trace_rays = if ray_tracing_indirect_trace_rays {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_tracing_indirect_acceleration_structure_build(
mut self,
ray_tracing_indirect_acceleration_structure_build: bool,
) -> Self {
self.inner.ray_tracing_indirect_acceleration_structure_build =
if ray_tracing_indirect_acceleration_structure_build {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_tracing_host_acceleration_structure_commands(
mut self,
ray_tracing_host_acceleration_structure_commands: bool,
) -> Self {
self.inner.ray_tracing_host_acceleration_structure_commands =
if ray_tracing_host_acceleration_structure_commands {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn ray_query(mut self, ray_query: bool) -> Self {
self.inner.ray_query = if ray_query { vk::TRUE } else { vk::FALSE };
self
}
pub fn ray_tracing_primitive_culling(mut self, ray_tracing_primitive_culling: bool) -> Self {
self.inner.ray_tracing_primitive_culling = if ray_tracing_primitive_culling {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceRayTracingFeaturesKHRBuilder<'a> {
type Target = vk::PhysicalDeviceRayTracingFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceImageDrmFormatModifierInfoEXT {
type Type = PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
inner: vk::PhysicalDeviceImageDrmFormatModifierInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
self.inner.drm_format_modifier = drm_format_modifier;
self
}
pub fn sharing_mode(mut self, sharing_mode: vk::SharingMode) -> Self {
self.inner.sharing_mode = sharing_mode;
self
}
pub fn p_queue_family_indices(mut self, p_queue_family_indices: &'a [u32]) -> Self {
self.inner.queue_family_index_count = p_queue_family_indices.len() as u32;
self.inner.p_queue_family_indices = p_queue_family_indices.as_ptr();
self
}
}
impl<'a> Deref for PhysicalDeviceImageDrmFormatModifierInfoEXTBuilder<'a> {
type Target = vk::PhysicalDeviceImageDrmFormatModifierInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageDrmFormatModifierListCreateInfoEXT {
type Type = ImageDrmFormatModifierListCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
inner: vk::ImageDrmFormatModifierListCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_drm_format_modifiers(mut self, p_drm_format_modifiers: &'a [u64]) -> Self {
self.inner.drm_format_modifier_count = p_drm_format_modifiers.len() as u32;
self.inner.p_drm_format_modifiers = p_drm_format_modifiers.as_ptr();
self
}
}
impl<'a> Deref for ImageDrmFormatModifierListCreateInfoEXTBuilder<'a> {
type Target = vk::ImageDrmFormatModifierListCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageDrmFormatModifierExplicitCreateInfoEXT {
type Type = ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
inner: vk::ImageDrmFormatModifierExplicitCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn drm_format_modifier(mut self, drm_format_modifier: u64) -> Self {
self.inner.drm_format_modifier = drm_format_modifier;
self
}
pub fn p_plane_layouts(mut self, p_plane_layouts: &'a [vk::SubresourceLayout]) -> Self {
self.inner.drm_format_modifier_plane_count = p_plane_layouts.len() as u32;
self.inner.p_plane_layouts = p_plane_layouts.as_ptr();
self
}
}
impl<'a> Deref for ImageDrmFormatModifierExplicitCreateInfoEXTBuilder<'a> {
type Target = vk::ImageDrmFormatModifierExplicitCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageStencilUsageCreateInfo {
type Type = ImageStencilUsageCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageStencilUsageCreateInfoBuilder<'a> {
inner: vk::ImageStencilUsageCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageStencilUsageCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn stencil_usage(mut self, stencil_usage: vk::ImageUsageFlags) -> Self {
self.inner.stencil_usage = stencil_usage;
self
}
}
impl<'a> Deref for ImageStencilUsageCreateInfoBuilder<'a> {
type Target = vk::ImageStencilUsageCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceMemoryOverallocationCreateInfoAMD {
type Type = DeviceMemoryOverallocationCreateInfoAMDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
inner: vk::DeviceMemoryOverallocationCreateInfoAMD,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn overallocation_behavior(mut self, overallocation_behavior: vk::MemoryOverallocationBehaviorAMD) -> Self {
self.inner.overallocation_behavior = overallocation_behavior;
self
}
}
impl<'a> Deref for DeviceMemoryOverallocationCreateInfoAMDBuilder<'a> {
type Target = vk::DeviceMemoryOverallocationCreateInfoAMD;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassFragmentDensityMapCreateInfoEXT {
type Type = RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
inner: vk::RenderPassFragmentDensityMapCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fragment_density_map_attachment(mut self, fragment_density_map_attachment: vk::AttachmentReference) -> Self {
self.inner.fragment_density_map_attachment = fragment_density_map_attachment;
self
}
}
impl<'a> Deref for RenderPassFragmentDensityMapCreateInfoEXTBuilder<'a> {
type Target = vk::RenderPassFragmentDensityMapCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceScalarBlockLayoutFeatures {
type Type = PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceScalarBlockLayoutFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
self.inner.scalar_block_layout = if scalar_block_layout { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceScalarBlockLayoutFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceScalarBlockLayoutFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SurfaceProtectedCapabilitiesKHR {
type Type = SurfaceProtectedCapabilitiesKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SurfaceProtectedCapabilitiesKHRBuilder<'a> {
inner: vk::SurfaceProtectedCapabilitiesKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SurfaceProtectedCapabilitiesKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn supports_protected(mut self, supports_protected: bool) -> Self {
self.inner.supports_protected = if supports_protected { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for SurfaceProtectedCapabilitiesKHRBuilder<'a> {
type Target = vk::SurfaceProtectedCapabilitiesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceUniformBufferStandardLayoutFeatures {
type Type = PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceUniformBufferStandardLayoutFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
self.inner.uniform_buffer_standard_layout = if uniform_buffer_standard_layout {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceUniformBufferStandardLayoutFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceUniformBufferStandardLayoutFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceDepthClipEnableFeaturesEXT {
type Type = PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceDepthClipEnableFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
self.inner.depth_clip_enable = if depth_clip_enable { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceDepthClipEnableFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceDepthClipEnableFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationDepthClipStateCreateInfoEXT {
type Type = PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineRasterizationDepthClipStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineRasterizationDepthClipStateCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
pub fn depth_clip_enable(mut self, depth_clip_enable: bool) -> Self {
self.inner.depth_clip_enable = if depth_clip_enable { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PipelineRasterizationDepthClipStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineRasterizationDepthClipStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceMemoryPriorityFeaturesEXT {
type Type = PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceMemoryPriorityFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory_priority(mut self, memory_priority: bool) -> Self {
self.inner.memory_priority = if memory_priority { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceMemoryPriorityFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceMemoryPriorityFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryPriorityAllocateInfoEXT {
type Type = MemoryPriorityAllocateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryPriorityAllocateInfoEXTBuilder<'a> {
inner: vk::MemoryPriorityAllocateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryPriorityAllocateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn priority(mut self, priority: f32) -> Self {
self.inner.priority = priority;
self
}
}
impl<'a> Deref for MemoryPriorityAllocateInfoEXTBuilder<'a> {
type Target = vk::MemoryPriorityAllocateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceBufferDeviceAddressFeatures {
type Type = PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceBufferDeviceAddressFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
self.inner.buffer_device_address = if buffer_device_address { vk::TRUE } else { vk::FALSE };
self
}
pub fn buffer_device_address_capture_replay(mut self, buffer_device_address_capture_replay: bool) -> Self {
self.inner.buffer_device_address_capture_replay = if buffer_device_address_capture_replay {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn buffer_device_address_multi_device(mut self, buffer_device_address_multi_device: bool) -> Self {
self.inner.buffer_device_address_multi_device = if buffer_device_address_multi_device {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceBufferDeviceAddressFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceBufferDeviceAddressFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT {
type Type = PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
self.inner.buffer_device_address = if buffer_device_address { vk::TRUE } else { vk::FALSE };
self
}
pub fn buffer_device_address_capture_replay(mut self, buffer_device_address_capture_replay: bool) -> Self {
self.inner.buffer_device_address_capture_replay = if buffer_device_address_capture_replay {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn buffer_device_address_multi_device(mut self, buffer_device_address_multi_device: bool) -> Self {
self.inner.buffer_device_address_multi_device = if buffer_device_address_multi_device {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceBufferDeviceAddressFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceBufferDeviceAddressFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferDeviceAddressInfo {
type Type = BufferDeviceAddressInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferDeviceAddressInfoBuilder<'a> {
inner: vk::BufferDeviceAddressInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferDeviceAddressInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn buffer(mut self, buffer: vk::Buffer) -> Self {
self.inner.buffer = Some(buffer);
self
}
}
impl<'a> Deref for BufferDeviceAddressInfoBuilder<'a> {
type Target = vk::BufferDeviceAddressInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferOpaqueCaptureAddressCreateInfo {
type Type = BufferOpaqueCaptureAddressCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
inner: vk::BufferOpaqueCaptureAddressCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
self.inner.opaque_capture_address = opaque_capture_address;
self
}
}
impl<'a> Deref for BufferOpaqueCaptureAddressCreateInfoBuilder<'a> {
type Target = vk::BufferOpaqueCaptureAddressCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::BufferDeviceAddressCreateInfoEXT {
type Type = BufferDeviceAddressCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct BufferDeviceAddressCreateInfoEXTBuilder<'a> {
inner: vk::BufferDeviceAddressCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> BufferDeviceAddressCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_address(mut self, device_address: vk::DeviceAddress) -> Self {
self.inner.device_address = device_address;
self
}
}
impl<'a> Deref for BufferDeviceAddressCreateInfoEXTBuilder<'a> {
type Target = vk::BufferDeviceAddressCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceImageViewImageFormatInfoEXT {
type Type = PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
inner: vk::PhysicalDeviceImageViewImageFormatInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image_view_type(mut self, image_view_type: vk::ImageViewType) -> Self {
self.inner.image_view_type = image_view_type;
self
}
}
impl<'a> Deref for PhysicalDeviceImageViewImageFormatInfoEXTBuilder<'a> {
type Target = vk::PhysicalDeviceImageViewImageFormatInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceImagelessFramebufferFeatures {
type Type = PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceImagelessFramebufferFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
self.inner.imageless_framebuffer = if imageless_framebuffer { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceImagelessFramebufferFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceImagelessFramebufferFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FramebufferAttachmentsCreateInfo {
type Type = FramebufferAttachmentsCreateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FramebufferAttachmentsCreateInfoBuilder<'a> {
inner: vk::FramebufferAttachmentsCreateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FramebufferAttachmentsCreateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attachment_image_infos(
mut self,
p_attachment_image_infos: &'a [vk::FramebufferAttachmentImageInfo],
) -> Self {
self.inner.attachment_image_info_count = p_attachment_image_infos.len() as u32;
self.inner.p_attachment_image_infos = p_attachment_image_infos.as_ptr();
self
}
}
impl<'a> Deref for FramebufferAttachmentsCreateInfoBuilder<'a> {
type Target = vk::FramebufferAttachmentsCreateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::FramebufferAttachmentImageInfo {
type Type = FramebufferAttachmentImageInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct FramebufferAttachmentImageInfoBuilder<'a> {
inner: vk::FramebufferAttachmentImageInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> FramebufferAttachmentImageInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::ImageCreateFlags) -> Self {
self.inner.flags = flags;
self
}
pub fn usage(mut self, usage: vk::ImageUsageFlags) -> Self {
self.inner.usage = usage;
self
}
pub fn width(mut self, width: u32) -> Self {
self.inner.width = width;
self
}
pub fn height(mut self, height: u32) -> Self {
self.inner.height = height;
self
}
pub fn layer_count(mut self, layer_count: u32) -> Self {
self.inner.layer_count = layer_count;
self
}
pub fn p_view_formats(mut self, p_view_formats: &'a [vk::Format]) -> Self {
self.inner.view_format_count = p_view_formats.len() as u32;
self.inner.p_view_formats = p_view_formats.as_ptr();
self
}
}
impl<'a> Deref for FramebufferAttachmentImageInfoBuilder<'a> {
type Target = vk::FramebufferAttachmentImageInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassAttachmentBeginInfo {
type Type = RenderPassAttachmentBeginInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassAttachmentBeginInfoBuilder<'a> {
inner: vk::RenderPassAttachmentBeginInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassAttachmentBeginInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_attachments(mut self, p_attachments: &'a [vk::ImageView]) -> Self {
self.inner.attachment_count = p_attachments.len() as u32;
self.inner.p_attachments = p_attachments.as_ptr();
self
}
}
impl<'a> Deref for RenderPassAttachmentBeginInfoBuilder<'a> {
type Target = vk::RenderPassAttachmentBeginInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
type Type = PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn texture_compression_astc_hdr(mut self, texture_compression_astc_hdr: bool) -> Self {
self.inner.texture_compression_astc_hdr = if texture_compression_astc_hdr {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceTextureCompressionASTCHDRFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceCooperativeMatrixFeaturesNV {
type Type = PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceCooperativeMatrixFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn cooperative_matrix(mut self, cooperative_matrix: bool) -> Self {
self.inner.cooperative_matrix = if cooperative_matrix { vk::TRUE } else { vk::FALSE };
self
}
pub fn cooperative_matrix_robust_buffer_access(mut self, cooperative_matrix_robust_buffer_access: bool) -> Self {
self.inner.cooperative_matrix_robust_buffer_access = if cooperative_matrix_robust_buffer_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceCooperativeMatrixFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceCooperativeMatrixFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CooperativeMatrixPropertiesNV {
type Type = CooperativeMatrixPropertiesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CooperativeMatrixPropertiesNVBuilder<'a> {
inner: vk::CooperativeMatrixPropertiesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CooperativeMatrixPropertiesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn m_size(mut self, m_size: u32) -> Self {
self.inner.m_size = m_size;
self
}
pub fn n_size(mut self, n_size: u32) -> Self {
self.inner.n_size = n_size;
self
}
pub fn k_size(mut self, k_size: u32) -> Self {
self.inner.k_size = k_size;
self
}
pub fn a_type(mut self, a_type: vk::ComponentTypeNV) -> Self {
self.inner.a_type = a_type;
self
}
pub fn b_type(mut self, b_type: vk::ComponentTypeNV) -> Self {
self.inner.b_type = b_type;
self
}
pub fn c_type(mut self, c_type: vk::ComponentTypeNV) -> Self {
self.inner.c_type = c_type;
self
}
pub fn d_type(mut self, d_type: vk::ComponentTypeNV) -> Self {
self.inner.d_type = d_type;
self
}
pub fn scope(mut self, scope: vk::ScopeNV) -> Self {
self.inner.scope = scope;
self
}
}
impl<'a> Deref for CooperativeMatrixPropertiesNVBuilder<'a> {
type Target = vk::CooperativeMatrixPropertiesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT {
type Type = PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ycbcr_image_arrays(mut self, ycbcr_image_arrays: bool) -> Self {
self.inner.ycbcr_image_arrays = if ycbcr_image_arrays { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceYcbcrImageArraysFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceYcbcrImageArraysFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::ImageViewHandleInfoNVX {
type Type = ImageViewHandleInfoNVXBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct ImageViewHandleInfoNVXBuilder<'a> {
inner: vk::ImageViewHandleInfoNVX,
phantom: PhantomData<&'a c_void>,
}
impl<'a> ImageViewHandleInfoNVXBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn image_view(mut self, image_view: vk::ImageView) -> Self {
self.inner.image_view = Some(image_view);
self
}
pub fn descriptor_type(mut self, descriptor_type: vk::DescriptorType) -> Self {
self.inner.descriptor_type = descriptor_type;
self
}
pub fn sampler(mut self, sampler: Option<vk::Sampler>) -> Self {
self.inner.sampler = sampler;
self
}
}
impl<'a> Deref for ImageViewHandleInfoNVXBuilder<'a> {
type Target = vk::ImageViewHandleInfoNVX;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCreationFeedbackCreateInfoEXT {
type Type = PipelineCreationFeedbackCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
inner: vk::PipelineCreationFeedbackCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_pipeline_creation_feedback(
mut self,
p_pipeline_creation_feedback: *mut vk::PipelineCreationFeedbackEXT,
) -> Self {
self.inner.p_pipeline_creation_feedback = p_pipeline_creation_feedback;
self
}
pub fn pipeline_stage_creation_feedback_count(mut self, pipeline_stage_creation_feedback_count: u32) -> Self {
self.inner.pipeline_stage_creation_feedback_count = pipeline_stage_creation_feedback_count;
self
}
pub fn p_pipeline_stage_creation_feedbacks(
mut self,
p_pipeline_stage_creation_feedbacks: *mut vk::PipelineCreationFeedbackEXT,
) -> Self {
self.inner.p_pipeline_stage_creation_feedbacks = p_pipeline_stage_creation_feedbacks;
self
}
}
impl<'a> Deref for PipelineCreationFeedbackCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineCreationFeedbackCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SurfaceFullScreenExclusiveInfoEXT {
type Type = SurfaceFullScreenExclusiveInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
inner: vk::SurfaceFullScreenExclusiveInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn full_screen_exclusive(mut self, full_screen_exclusive: vk::FullScreenExclusiveEXT) -> Self {
self.inner.full_screen_exclusive = full_screen_exclusive;
self
}
}
impl<'a> Deref for SurfaceFullScreenExclusiveInfoEXTBuilder<'a> {
type Target = vk::SurfaceFullScreenExclusiveInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SurfaceFullScreenExclusiveWin32InfoEXT {
type Type = SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
inner: vk::SurfaceFullScreenExclusiveWin32InfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn hmonitor(mut self, hmonitor: vk::HMONITOR) -> Self {
self.inner.hmonitor = hmonitor;
self
}
}
impl<'a> Deref for SurfaceFullScreenExclusiveWin32InfoEXTBuilder<'a> {
type Target = vk::SurfaceFullScreenExclusiveWin32InfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::SurfaceCapabilitiesFullScreenExclusiveEXT {
type Type = SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
inner: vk::SurfaceCapabilitiesFullScreenExclusiveEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn full_screen_exclusive_supported(mut self, full_screen_exclusive_supported: bool) -> Self {
self.inner.full_screen_exclusive_supported = if full_screen_exclusive_supported {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for SurfaceCapabilitiesFullScreenExclusiveEXTBuilder<'a> {
type Target = vk::SurfaceCapabilitiesFullScreenExclusiveEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevicePerformanceQueryFeaturesKHR {
type Type = PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
inner: vk::PhysicalDevicePerformanceQueryFeaturesKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn performance_counter_query_pools(mut self, performance_counter_query_pools: bool) -> Self {
self.inner.performance_counter_query_pools = if performance_counter_query_pools {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn performance_counter_multiple_query_pools(mut self, performance_counter_multiple_query_pools: bool) -> Self {
self.inner.performance_counter_multiple_query_pools = if performance_counter_multiple_query_pools {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDevicePerformanceQueryFeaturesKHRBuilder<'a> {
type Target = vk::PhysicalDevicePerformanceQueryFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::QueryPoolPerformanceCreateInfoKHR {
type Type = QueryPoolPerformanceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
inner: vk::QueryPoolPerformanceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn queue_family_index(mut self, queue_family_index: u32) -> Self {
self.inner.queue_family_index = queue_family_index;
self
}
pub fn p_counter_indices(mut self, p_counter_indices: &'a [u32]) -> Self {
self.inner.counter_index_count = p_counter_indices.len() as u32;
self.inner.p_counter_indices = p_counter_indices.as_ptr();
self
}
}
impl<'a> Deref for QueryPoolPerformanceCreateInfoKHRBuilder<'a> {
type Target = vk::QueryPoolPerformanceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AcquireProfilingLockInfoKHR {
type Type = AcquireProfilingLockInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AcquireProfilingLockInfoKHRBuilder<'a> {
inner: vk::AcquireProfilingLockInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AcquireProfilingLockInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::AcquireProfilingLockFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn timeout(mut self, timeout: u64) -> Self {
self.inner.timeout = timeout;
self
}
}
impl<'a> Deref for AcquireProfilingLockInfoKHRBuilder<'a> {
type Target = vk::AcquireProfilingLockInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PerformanceQuerySubmitInfoKHR {
type Type = PerformanceQuerySubmitInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PerformanceQuerySubmitInfoKHRBuilder<'a> {
inner: vk::PerformanceQuerySubmitInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PerformanceQuerySubmitInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn counter_pass_index(mut self, counter_pass_index: u32) -> Self {
self.inner.counter_pass_index = counter_pass_index;
self
}
}
impl<'a> Deref for PerformanceQuerySubmitInfoKHRBuilder<'a> {
type Target = vk::PerformanceQuerySubmitInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::HeadlessSurfaceCreateInfoEXT {
type Type = HeadlessSurfaceCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct HeadlessSurfaceCreateInfoEXTBuilder<'a> {
inner: vk::HeadlessSurfaceCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> HeadlessSurfaceCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::HeadlessSurfaceCreateFlagsEXT) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for HeadlessSurfaceCreateInfoEXTBuilder<'a> {
type Target = vk::HeadlessSurfaceCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceCoverageReductionModeFeaturesNV {
type Type = PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceCoverageReductionModeFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: bool) -> Self {
self.inner.coverage_reduction_mode = if coverage_reduction_mode { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceCoverageReductionModeFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceCoverageReductionModeFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCoverageReductionStateCreateInfoNV {
type Type = PipelineCoverageReductionStateCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
inner: vk::PipelineCoverageReductionStateCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::PipelineCoverageReductionStateCreateFlagsNV) -> Self {
self.inner.flags = flags;
self
}
pub fn coverage_reduction_mode(mut self, coverage_reduction_mode: vk::CoverageReductionModeNV) -> Self {
self.inner.coverage_reduction_mode = coverage_reduction_mode;
self
}
}
impl<'a> Deref for PipelineCoverageReductionStateCreateInfoNVBuilder<'a> {
type Target = vk::PipelineCoverageReductionStateCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
type Type = PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
inner: vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_integer_functions2(mut self, shader_integer_functions2: bool) -> Self {
self.inner.shader_integer_functions2 = if shader_integer_functions2 { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderIntegerFunctions2FeaturesINTELBuilder<'a> {
type Target = vk::PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::InitializePerformanceApiInfoINTEL {
type Type = InitializePerformanceApiInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct InitializePerformanceApiInfoINTELBuilder<'a> {
inner: vk::InitializePerformanceApiInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> InitializePerformanceApiInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_user_data(mut self, p_user_data: *mut c_void) -> Self {
self.inner.p_user_data = p_user_data;
self
}
}
impl<'a> Deref for InitializePerformanceApiInfoINTELBuilder<'a> {
type Target = vk::InitializePerformanceApiInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::QueryPoolPerformanceQueryCreateInfoINTEL {
type Type = QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
inner: vk::QueryPoolPerformanceQueryCreateInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn performance_counters_sampling(
mut self,
performance_counters_sampling: vk::QueryPoolSamplingModeINTEL,
) -> Self {
self.inner.performance_counters_sampling = performance_counters_sampling;
self
}
}
impl<'a> Deref for QueryPoolPerformanceQueryCreateInfoINTELBuilder<'a> {
type Target = vk::QueryPoolPerformanceQueryCreateInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PerformanceMarkerInfoINTEL {
type Type = PerformanceMarkerInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PerformanceMarkerInfoINTELBuilder<'a> {
inner: vk::PerformanceMarkerInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PerformanceMarkerInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn marker(mut self, marker: u64) -> Self {
self.inner.marker = marker;
self
}
}
impl<'a> Deref for PerformanceMarkerInfoINTELBuilder<'a> {
type Target = vk::PerformanceMarkerInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PerformanceStreamMarkerInfoINTEL {
type Type = PerformanceStreamMarkerInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PerformanceStreamMarkerInfoINTELBuilder<'a> {
inner: vk::PerformanceStreamMarkerInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PerformanceStreamMarkerInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn marker(mut self, marker: u32) -> Self {
self.inner.marker = marker;
self
}
}
impl<'a> Deref for PerformanceStreamMarkerInfoINTELBuilder<'a> {
type Target = vk::PerformanceStreamMarkerInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PerformanceOverrideInfoINTEL {
type Type = PerformanceOverrideInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PerformanceOverrideInfoINTELBuilder<'a> {
inner: vk::PerformanceOverrideInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PerformanceOverrideInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::PerformanceOverrideTypeINTEL) -> Self {
self.inner.ty = ty;
self
}
pub fn enable(mut self, enable: bool) -> Self {
self.inner.enable = if enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn parameter(mut self, parameter: u64) -> Self {
self.inner.parameter = parameter;
self
}
}
impl<'a> Deref for PerformanceOverrideInfoINTELBuilder<'a> {
type Target = vk::PerformanceOverrideInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PerformanceConfigurationAcquireInfoINTEL {
type Type = PerformanceConfigurationAcquireInfoINTELBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
inner: vk::PerformanceConfigurationAcquireInfoINTEL,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::PerformanceConfigurationTypeINTEL) -> Self {
self.inner.ty = ty;
self
}
}
impl<'a> Deref for PerformanceConfigurationAcquireInfoINTELBuilder<'a> {
type Target = vk::PerformanceConfigurationAcquireInfoINTEL;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderClockFeaturesKHR {
type Type = PhysicalDeviceShaderClockFeaturesKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
inner: vk::PhysicalDeviceShaderClockFeaturesKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_subgroup_clock(mut self, shader_subgroup_clock: bool) -> Self {
self.inner.shader_subgroup_clock = if shader_subgroup_clock { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_device_clock(mut self, shader_device_clock: bool) -> Self {
self.inner.shader_device_clock = if shader_device_clock { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderClockFeaturesKHRBuilder<'a> {
type Target = vk::PhysicalDeviceShaderClockFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceIndexTypeUint8FeaturesEXT {
type Type = PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceIndexTypeUint8FeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn index_type_uint8(mut self, index_type_uint8: bool) -> Self {
self.inner.index_type_uint8 = if index_type_uint8 { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceIndexTypeUint8FeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceIndexTypeUint8FeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV {
type Type = PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_sm_builtins(mut self, shader_sm_builtins: bool) -> Self {
self.inner.shader_sm_builtins = if shader_sm_builtins { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceShaderSMBuiltinsFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceShaderSMBuiltinsFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
type Type = PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn fragment_shader_sample_interlock(mut self, fragment_shader_sample_interlock: bool) -> Self {
self.inner.fragment_shader_sample_interlock = if fragment_shader_sample_interlock {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn fragment_shader_pixel_interlock(mut self, fragment_shader_pixel_interlock: bool) -> Self {
self.inner.fragment_shader_pixel_interlock = if fragment_shader_pixel_interlock {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn fragment_shader_shading_rate_interlock(mut self, fragment_shader_shading_rate_interlock: bool) -> Self {
self.inner.fragment_shader_shading_rate_interlock = if fragment_shader_shading_rate_interlock {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceFragmentShaderInterlockFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceFragmentShaderInterlockFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
type Type = PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
inner: vk::PhysicalDeviceSeparateDepthStencilLayoutsFeatures,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
self.inner.separate_depth_stencil_layouts = if separate_depth_stencil_layouts {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceSeparateDepthStencilLayoutsFeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceSeparateDepthStencilLayoutsFeatures;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AttachmentReferenceStencilLayout {
type Type = AttachmentReferenceStencilLayoutBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AttachmentReferenceStencilLayoutBuilder<'a> {
inner: vk::AttachmentReferenceStencilLayout,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AttachmentReferenceStencilLayoutBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn stencil_layout(mut self, stencil_layout: vk::ImageLayout) -> Self {
self.inner.stencil_layout = stencil_layout;
self
}
}
impl<'a> Deref for AttachmentReferenceStencilLayoutBuilder<'a> {
type Target = vk::AttachmentReferenceStencilLayout;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AttachmentDescriptionStencilLayout {
type Type = AttachmentDescriptionStencilLayoutBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AttachmentDescriptionStencilLayoutBuilder<'a> {
inner: vk::AttachmentDescriptionStencilLayout,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AttachmentDescriptionStencilLayoutBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn stencil_initial_layout(mut self, stencil_initial_layout: vk::ImageLayout) -> Self {
self.inner.stencil_initial_layout = stencil_initial_layout;
self
}
pub fn stencil_final_layout(mut self, stencil_final_layout: vk::ImageLayout) -> Self {
self.inner.stencil_final_layout = stencil_final_layout;
self
}
}
impl<'a> Deref for AttachmentDescriptionStencilLayoutBuilder<'a> {
type Target = vk::AttachmentDescriptionStencilLayout;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
type Type = PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
inner: vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn pipeline_executable_info(mut self, pipeline_executable_info: bool) -> Self {
self.inner.pipeline_executable_info = if pipeline_executable_info { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDevicePipelineExecutablePropertiesFeaturesKHRBuilder<'a> {
type Target = vk::PhysicalDevicePipelineExecutablePropertiesFeaturesKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineInfoKHR {
type Type = PipelineInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineInfoKHRBuilder<'a> {
inner: vk::PipelineInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn pipeline(mut self, pipeline: vk::Pipeline) -> Self {
self.inner.pipeline = Some(pipeline);
self
}
}
impl<'a> Deref for PipelineInfoKHRBuilder<'a> {
type Target = vk::PipelineInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineExecutableInfoKHR {
type Type = PipelineExecutableInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineExecutableInfoKHRBuilder<'a> {
inner: vk::PipelineExecutableInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineExecutableInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn pipeline(mut self, pipeline: vk::Pipeline) -> Self {
self.inner.pipeline = Some(pipeline);
self
}
pub fn executable_index(mut self, executable_index: u32) -> Self {
self.inner.executable_index = executable_index;
self
}
}
impl<'a> Deref for PipelineExecutableInfoKHRBuilder<'a> {
type Target = vk::PipelineExecutableInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
type Type = PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn shader_demote_to_helper_invocation(mut self, shader_demote_to_helper_invocation: bool) -> Self {
self.inner.shader_demote_to_helper_invocation = if shader_demote_to_helper_invocation {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
type Type = PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn texel_buffer_alignment(mut self, texel_buffer_alignment: bool) -> Self {
self.inner.texel_buffer_alignment = if texel_buffer_alignment { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceTexelBufferAlignmentFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceTexelBufferAlignmentFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT {
type Type = PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn subgroup_size_control(mut self, subgroup_size_control: bool) -> Self {
self.inner.subgroup_size_control = if subgroup_size_control { vk::TRUE } else { vk::FALSE };
self
}
pub fn compute_full_subgroups(mut self, compute_full_subgroups: bool) -> Self {
self.inner.compute_full_subgroups = if compute_full_subgroups { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceSubgroupSizeControlFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceSubgroupSizeControlFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::MemoryOpaqueCaptureAddressAllocateInfo {
type Type = MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
inner: vk::MemoryOpaqueCaptureAddressAllocateInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn opaque_capture_address(mut self, opaque_capture_address: u64) -> Self {
self.inner.opaque_capture_address = opaque_capture_address;
self
}
}
impl<'a> Deref for MemoryOpaqueCaptureAddressAllocateInfoBuilder<'a> {
type Target = vk::MemoryOpaqueCaptureAddressAllocateInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceMemoryOpaqueCaptureAddressInfo {
type Type = DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
inner: vk::DeviceMemoryOpaqueCaptureAddressInfo,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn memory(mut self, memory: vk::DeviceMemory) -> Self {
self.inner.memory = Some(memory);
self
}
}
impl<'a> Deref for DeviceMemoryOpaqueCaptureAddressInfoBuilder<'a> {
type Target = vk::DeviceMemoryOpaqueCaptureAddressInfo;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceLineRasterizationFeaturesEXT {
type Type = PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDeviceLineRasterizationFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn rectangular_lines(mut self, rectangular_lines: bool) -> Self {
self.inner.rectangular_lines = if rectangular_lines { vk::TRUE } else { vk::FALSE };
self
}
pub fn bresenham_lines(mut self, bresenham_lines: bool) -> Self {
self.inner.bresenham_lines = if bresenham_lines { vk::TRUE } else { vk::FALSE };
self
}
pub fn smooth_lines(mut self, smooth_lines: bool) -> Self {
self.inner.smooth_lines = if smooth_lines { vk::TRUE } else { vk::FALSE };
self
}
pub fn stippled_rectangular_lines(mut self, stippled_rectangular_lines: bool) -> Self {
self.inner.stippled_rectangular_lines = if stippled_rectangular_lines {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn stippled_bresenham_lines(mut self, stippled_bresenham_lines: bool) -> Self {
self.inner.stippled_bresenham_lines = if stippled_bresenham_lines { vk::TRUE } else { vk::FALSE };
self
}
pub fn stippled_smooth_lines(mut self, stippled_smooth_lines: bool) -> Self {
self.inner.stippled_smooth_lines = if stippled_smooth_lines { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceLineRasterizationFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDeviceLineRasterizationFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineRasterizationLineStateCreateInfoEXT {
type Type = PipelineRasterizationLineStateCreateInfoEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
inner: vk::PipelineRasterizationLineStateCreateInfoEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn line_rasterization_mode(mut self, line_rasterization_mode: vk::LineRasterizationModeEXT) -> Self {
self.inner.line_rasterization_mode = line_rasterization_mode;
self
}
pub fn stippled_line_enable(mut self, stippled_line_enable: bool) -> Self {
self.inner.stippled_line_enable = if stippled_line_enable { vk::TRUE } else { vk::FALSE };
self
}
pub fn line_stipple_factor(mut self, line_stipple_factor: u32) -> Self {
self.inner.line_stipple_factor = line_stipple_factor;
self
}
pub fn line_stipple_pattern(mut self, line_stipple_pattern: u16) -> Self {
self.inner.line_stipple_pattern = line_stipple_pattern;
self
}
}
impl<'a> Deref for PipelineRasterizationLineStateCreateInfoEXTBuilder<'a> {
type Target = vk::PipelineRasterizationLineStateCreateInfoEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
type Type = PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
inner: vk::PhysicalDevicePipelineCreationCacheControlFeaturesEXT,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn pipeline_creation_cache_control(mut self, pipeline_creation_cache_control: bool) -> Self {
self.inner.pipeline_creation_cache_control = if pipeline_creation_cache_control {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDevicePipelineCreationCacheControlFeaturesEXTBuilder<'a> {
type Target = vk::PhysicalDevicePipelineCreationCacheControlFeaturesEXT;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVulkan11Features {
type Type = PhysicalDeviceVulkan11FeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVulkan11FeaturesBuilder<'a> {
inner: vk::PhysicalDeviceVulkan11Features,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVulkan11FeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn storage_buffer16_bit_access(mut self, storage_buffer16_bit_access: bool) -> Self {
self.inner.storage_buffer16_bit_access = if storage_buffer16_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn uniform_and_storage_buffer16_bit_access(mut self, uniform_and_storage_buffer16_bit_access: bool) -> Self {
self.inner.uniform_and_storage_buffer16_bit_access = if uniform_and_storage_buffer16_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn storage_push_constant16(mut self, storage_push_constant16: bool) -> Self {
self.inner.storage_push_constant16 = if storage_push_constant16 { vk::TRUE } else { vk::FALSE };
self
}
pub fn storage_input_output16(mut self, storage_input_output16: bool) -> Self {
self.inner.storage_input_output16 = if storage_input_output16 { vk::TRUE } else { vk::FALSE };
self
}
pub fn multiview(mut self, multiview: bool) -> Self {
self.inner.multiview = if multiview { vk::TRUE } else { vk::FALSE };
self
}
pub fn multiview_geometry_shader(mut self, multiview_geometry_shader: bool) -> Self {
self.inner.multiview_geometry_shader = if multiview_geometry_shader { vk::TRUE } else { vk::FALSE };
self
}
pub fn multiview_tessellation_shader(mut self, multiview_tessellation_shader: bool) -> Self {
self.inner.multiview_tessellation_shader = if multiview_tessellation_shader {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn variable_pointers_storage_buffer(mut self, variable_pointers_storage_buffer: bool) -> Self {
self.inner.variable_pointers_storage_buffer = if variable_pointers_storage_buffer {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn variable_pointers(mut self, variable_pointers: bool) -> Self {
self.inner.variable_pointers = if variable_pointers { vk::TRUE } else { vk::FALSE };
self
}
pub fn protected_memory(mut self, protected_memory: bool) -> Self {
self.inner.protected_memory = if protected_memory { vk::TRUE } else { vk::FALSE };
self
}
pub fn sampler_ycbcr_conversion(mut self, sampler_ycbcr_conversion: bool) -> Self {
self.inner.sampler_ycbcr_conversion = if sampler_ycbcr_conversion { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_draw_parameters(mut self, shader_draw_parameters: bool) -> Self {
self.inner.shader_draw_parameters = if shader_draw_parameters { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceVulkan11FeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceVulkan11Features;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVulkan11Properties {
type Type = PhysicalDeviceVulkan11PropertiesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVulkan11PropertiesBuilder<'a> {
inner: vk::PhysicalDeviceVulkan11Properties,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVulkan11PropertiesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_node_mask(mut self, device_node_mask: u32) -> Self {
self.inner.device_node_mask = device_node_mask;
self
}
pub fn device_luid_valid(mut self, device_luid_valid: bool) -> Self {
self.inner.device_luid_valid = if device_luid_valid { vk::TRUE } else { vk::FALSE };
self
}
pub fn subgroup_size(mut self, subgroup_size: u32) -> Self {
self.inner.subgroup_size = subgroup_size;
self
}
pub fn subgroup_supported_stages(mut self, subgroup_supported_stages: vk::ShaderStageFlags) -> Self {
self.inner.subgroup_supported_stages = subgroup_supported_stages;
self
}
pub fn subgroup_supported_operations(mut self, subgroup_supported_operations: vk::SubgroupFeatureFlags) -> Self {
self.inner.subgroup_supported_operations = subgroup_supported_operations;
self
}
pub fn subgroup_quad_operations_in_all_stages(mut self, subgroup_quad_operations_in_all_stages: bool) -> Self {
self.inner.subgroup_quad_operations_in_all_stages = if subgroup_quad_operations_in_all_stages {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn point_clipping_behavior(mut self, point_clipping_behavior: vk::PointClippingBehavior) -> Self {
self.inner.point_clipping_behavior = point_clipping_behavior;
self
}
pub fn max_multiview_view_count(mut self, max_multiview_view_count: u32) -> Self {
self.inner.max_multiview_view_count = max_multiview_view_count;
self
}
pub fn max_multiview_instance_index(mut self, max_multiview_instance_index: u32) -> Self {
self.inner.max_multiview_instance_index = max_multiview_instance_index;
self
}
pub fn protected_no_fault(mut self, protected_no_fault: bool) -> Self {
self.inner.protected_no_fault = if protected_no_fault { vk::TRUE } else { vk::FALSE };
self
}
pub fn max_per_set_descriptors(mut self, max_per_set_descriptors: u32) -> Self {
self.inner.max_per_set_descriptors = max_per_set_descriptors;
self
}
pub fn max_memory_allocation_size(mut self, max_memory_allocation_size: vk::DeviceSize) -> Self {
self.inner.max_memory_allocation_size = max_memory_allocation_size;
self
}
}
impl<'a> Deref for PhysicalDeviceVulkan11PropertiesBuilder<'a> {
type Target = vk::PhysicalDeviceVulkan11Properties;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVulkan12Features {
type Type = PhysicalDeviceVulkan12FeaturesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVulkan12FeaturesBuilder<'a> {
inner: vk::PhysicalDeviceVulkan12Features,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVulkan12FeaturesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn sampler_mirror_clamp_to_edge(mut self, sampler_mirror_clamp_to_edge: bool) -> Self {
self.inner.sampler_mirror_clamp_to_edge = if sampler_mirror_clamp_to_edge {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn draw_indirect_count(mut self, draw_indirect_count: bool) -> Self {
self.inner.draw_indirect_count = if draw_indirect_count { vk::TRUE } else { vk::FALSE };
self
}
pub fn storage_buffer8_bit_access(mut self, storage_buffer8_bit_access: bool) -> Self {
self.inner.storage_buffer8_bit_access = if storage_buffer8_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn uniform_and_storage_buffer8_bit_access(mut self, uniform_and_storage_buffer8_bit_access: bool) -> Self {
self.inner.uniform_and_storage_buffer8_bit_access = if uniform_and_storage_buffer8_bit_access {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn storage_push_constant8(mut self, storage_push_constant8: bool) -> Self {
self.inner.storage_push_constant8 = if storage_push_constant8 { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_buffer_int64_atomics(mut self, shader_buffer_int64_atomics: bool) -> Self {
self.inner.shader_buffer_int64_atomics = if shader_buffer_int64_atomics {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_shared_int64_atomics(mut self, shader_shared_int64_atomics: bool) -> Self {
self.inner.shader_shared_int64_atomics = if shader_shared_int64_atomics {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_float16(mut self, shader_float16: bool) -> Self {
self.inner.shader_float16 = if shader_float16 { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_int8(mut self, shader_int8: bool) -> Self {
self.inner.shader_int8 = if shader_int8 { vk::TRUE } else { vk::FALSE };
self
}
pub fn descriptor_indexing(mut self, descriptor_indexing: bool) -> Self {
self.inner.descriptor_indexing = if descriptor_indexing { vk::TRUE } else { vk::FALSE };
self
}
pub fn shader_input_attachment_array_dynamic_indexing(
mut self,
shader_input_attachment_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_input_attachment_array_dynamic_indexing = if shader_input_attachment_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_texel_buffer_array_dynamic_indexing(
mut self,
shader_uniform_texel_buffer_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_uniform_texel_buffer_array_dynamic_indexing =
if shader_uniform_texel_buffer_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_texel_buffer_array_dynamic_indexing(
mut self,
shader_storage_texel_buffer_array_dynamic_indexing: bool,
) -> Self {
self.inner.shader_storage_texel_buffer_array_dynamic_indexing =
if shader_storage_texel_buffer_array_dynamic_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_buffer_array_non_uniform_indexing(
mut self,
shader_uniform_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_uniform_buffer_array_non_uniform_indexing =
if shader_uniform_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_sampled_image_array_non_uniform_indexing(
mut self,
shader_sampled_image_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_sampled_image_array_non_uniform_indexing = if shader_sampled_image_array_non_uniform_indexing
{
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_buffer_array_non_uniform_indexing(
mut self,
shader_storage_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_buffer_array_non_uniform_indexing =
if shader_storage_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_image_array_non_uniform_indexing(
mut self,
shader_storage_image_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_image_array_non_uniform_indexing = if shader_storage_image_array_non_uniform_indexing
{
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_input_attachment_array_non_uniform_indexing(
mut self,
shader_input_attachment_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_input_attachment_array_non_uniform_indexing =
if shader_input_attachment_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_uniform_texel_buffer_array_non_uniform_indexing(
mut self,
shader_uniform_texel_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_uniform_texel_buffer_array_non_uniform_indexing =
if shader_uniform_texel_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_texel_buffer_array_non_uniform_indexing(
mut self,
shader_storage_texel_buffer_array_non_uniform_indexing: bool,
) -> Self {
self.inner.shader_storage_texel_buffer_array_non_uniform_indexing =
if shader_storage_texel_buffer_array_non_uniform_indexing {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_uniform_buffer_update_after_bind(
mut self,
descriptor_binding_uniform_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_uniform_buffer_update_after_bind =
if descriptor_binding_uniform_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_sampled_image_update_after_bind(
mut self,
descriptor_binding_sampled_image_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_sampled_image_update_after_bind =
if descriptor_binding_sampled_image_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_image_update_after_bind(
mut self,
descriptor_binding_storage_image_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_image_update_after_bind =
if descriptor_binding_storage_image_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_buffer_update_after_bind(
mut self,
descriptor_binding_storage_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_buffer_update_after_bind =
if descriptor_binding_storage_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_uniform_texel_buffer_update_after_bind(
mut self,
descriptor_binding_uniform_texel_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_uniform_texel_buffer_update_after_bind =
if descriptor_binding_uniform_texel_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_storage_texel_buffer_update_after_bind(
mut self,
descriptor_binding_storage_texel_buffer_update_after_bind: bool,
) -> Self {
self.inner.descriptor_binding_storage_texel_buffer_update_after_bind =
if descriptor_binding_storage_texel_buffer_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_update_unused_while_pending(
mut self,
descriptor_binding_update_unused_while_pending: bool,
) -> Self {
self.inner.descriptor_binding_update_unused_while_pending = if descriptor_binding_update_unused_while_pending {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_partially_bound(mut self, descriptor_binding_partially_bound: bool) -> Self {
self.inner.descriptor_binding_partially_bound = if descriptor_binding_partially_bound {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn descriptor_binding_variable_descriptor_count(
mut self,
descriptor_binding_variable_descriptor_count: bool,
) -> Self {
self.inner.descriptor_binding_variable_descriptor_count = if descriptor_binding_variable_descriptor_count {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn runtime_descriptor_array(mut self, runtime_descriptor_array: bool) -> Self {
self.inner.runtime_descriptor_array = if runtime_descriptor_array { vk::TRUE } else { vk::FALSE };
self
}
pub fn sampler_filter_minmax(mut self, sampler_filter_minmax: bool) -> Self {
self.inner.sampler_filter_minmax = if sampler_filter_minmax { vk::TRUE } else { vk::FALSE };
self
}
pub fn scalar_block_layout(mut self, scalar_block_layout: bool) -> Self {
self.inner.scalar_block_layout = if scalar_block_layout { vk::TRUE } else { vk::FALSE };
self
}
pub fn imageless_framebuffer(mut self, imageless_framebuffer: bool) -> Self {
self.inner.imageless_framebuffer = if imageless_framebuffer { vk::TRUE } else { vk::FALSE };
self
}
pub fn uniform_buffer_standard_layout(mut self, uniform_buffer_standard_layout: bool) -> Self {
self.inner.uniform_buffer_standard_layout = if uniform_buffer_standard_layout {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_subgroup_extended_types(mut self, shader_subgroup_extended_types: bool) -> Self {
self.inner.shader_subgroup_extended_types = if shader_subgroup_extended_types {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn separate_depth_stencil_layouts(mut self, separate_depth_stencil_layouts: bool) -> Self {
self.inner.separate_depth_stencil_layouts = if separate_depth_stencil_layouts {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn host_query_reset(mut self, host_query_reset: bool) -> Self {
self.inner.host_query_reset = if host_query_reset { vk::TRUE } else { vk::FALSE };
self
}
pub fn timeline_semaphore(mut self, timeline_semaphore: bool) -> Self {
self.inner.timeline_semaphore = if timeline_semaphore { vk::TRUE } else { vk::FALSE };
self
}
pub fn buffer_device_address(mut self, buffer_device_address: bool) -> Self {
self.inner.buffer_device_address = if buffer_device_address { vk::TRUE } else { vk::FALSE };
self
}
pub fn buffer_device_address_capture_replay(mut self, buffer_device_address_capture_replay: bool) -> Self {
self.inner.buffer_device_address_capture_replay = if buffer_device_address_capture_replay {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn buffer_device_address_multi_device(mut self, buffer_device_address_multi_device: bool) -> Self {
self.inner.buffer_device_address_multi_device = if buffer_device_address_multi_device {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn vulkan_memory_model(mut self, vulkan_memory_model: bool) -> Self {
self.inner.vulkan_memory_model = if vulkan_memory_model { vk::TRUE } else { vk::FALSE };
self
}
pub fn vulkan_memory_model_device_scope(mut self, vulkan_memory_model_device_scope: bool) -> Self {
self.inner.vulkan_memory_model_device_scope = if vulkan_memory_model_device_scope {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn vulkan_memory_model_availability_visibility_chains(
mut self,
vulkan_memory_model_availability_visibility_chains: bool,
) -> Self {
self.inner.vulkan_memory_model_availability_visibility_chains =
if vulkan_memory_model_availability_visibility_chains {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_output_viewport_index(mut self, shader_output_viewport_index: bool) -> Self {
self.inner.shader_output_viewport_index = if shader_output_viewport_index {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_output_layer(mut self, shader_output_layer: bool) -> Self {
self.inner.shader_output_layer = if shader_output_layer { vk::TRUE } else { vk::FALSE };
self
}
pub fn subgroup_broadcast_dynamic_id(mut self, subgroup_broadcast_dynamic_id: bool) -> Self {
self.inner.subgroup_broadcast_dynamic_id = if subgroup_broadcast_dynamic_id {
vk::TRUE
} else {
vk::FALSE
};
self
}
}
impl<'a> Deref for PhysicalDeviceVulkan12FeaturesBuilder<'a> {
type Target = vk::PhysicalDeviceVulkan12Features;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceVulkan12Properties {
type Type = PhysicalDeviceVulkan12PropertiesBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceVulkan12PropertiesBuilder<'a> {
inner: vk::PhysicalDeviceVulkan12Properties,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceVulkan12PropertiesBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn driver_id(mut self, driver_id: vk::DriverId) -> Self {
self.inner.driver_id = driver_id;
self
}
pub fn conformance_version(mut self, conformance_version: vk::ConformanceVersion) -> Self {
self.inner.conformance_version = conformance_version;
self
}
pub fn denorm_behavior_independence(
mut self,
denorm_behavior_independence: vk::ShaderFloatControlsIndependence,
) -> Self {
self.inner.denorm_behavior_independence = denorm_behavior_independence;
self
}
pub fn rounding_mode_independence(
mut self,
rounding_mode_independence: vk::ShaderFloatControlsIndependence,
) -> Self {
self.inner.rounding_mode_independence = rounding_mode_independence;
self
}
pub fn shader_signed_zero_inf_nan_preserve_float16(
mut self,
shader_signed_zero_inf_nan_preserve_float16: bool,
) -> Self {
self.inner.shader_signed_zero_inf_nan_preserve_float16 = if shader_signed_zero_inf_nan_preserve_float16 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_signed_zero_inf_nan_preserve_float32(
mut self,
shader_signed_zero_inf_nan_preserve_float32: bool,
) -> Self {
self.inner.shader_signed_zero_inf_nan_preserve_float32 = if shader_signed_zero_inf_nan_preserve_float32 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_signed_zero_inf_nan_preserve_float64(
mut self,
shader_signed_zero_inf_nan_preserve_float64: bool,
) -> Self {
self.inner.shader_signed_zero_inf_nan_preserve_float64 = if shader_signed_zero_inf_nan_preserve_float64 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_preserve_float16(mut self, shader_denorm_preserve_float16: bool) -> Self {
self.inner.shader_denorm_preserve_float16 = if shader_denorm_preserve_float16 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_preserve_float32(mut self, shader_denorm_preserve_float32: bool) -> Self {
self.inner.shader_denorm_preserve_float32 = if shader_denorm_preserve_float32 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_preserve_float64(mut self, shader_denorm_preserve_float64: bool) -> Self {
self.inner.shader_denorm_preserve_float64 = if shader_denorm_preserve_float64 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_flush_to_zero_float16(mut self, shader_denorm_flush_to_zero_float16: bool) -> Self {
self.inner.shader_denorm_flush_to_zero_float16 = if shader_denorm_flush_to_zero_float16 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_flush_to_zero_float32(mut self, shader_denorm_flush_to_zero_float32: bool) -> Self {
self.inner.shader_denorm_flush_to_zero_float32 = if shader_denorm_flush_to_zero_float32 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_denorm_flush_to_zero_float64(mut self, shader_denorm_flush_to_zero_float64: bool) -> Self {
self.inner.shader_denorm_flush_to_zero_float64 = if shader_denorm_flush_to_zero_float64 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rte_float16(mut self, shader_rounding_mode_rte_float16: bool) -> Self {
self.inner.shader_rounding_mode_rte_float16 = if shader_rounding_mode_rte_float16 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rte_float32(mut self, shader_rounding_mode_rte_float32: bool) -> Self {
self.inner.shader_rounding_mode_rte_float32 = if shader_rounding_mode_rte_float32 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rte_float64(mut self, shader_rounding_mode_rte_float64: bool) -> Self {
self.inner.shader_rounding_mode_rte_float64 = if shader_rounding_mode_rte_float64 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rtz_float16(mut self, shader_rounding_mode_rtz_float16: bool) -> Self {
self.inner.shader_rounding_mode_rtz_float16 = if shader_rounding_mode_rtz_float16 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rtz_float32(mut self, shader_rounding_mode_rtz_float32: bool) -> Self {
self.inner.shader_rounding_mode_rtz_float32 = if shader_rounding_mode_rtz_float32 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_rounding_mode_rtz_float64(mut self, shader_rounding_mode_rtz_float64: bool) -> Self {
self.inner.shader_rounding_mode_rtz_float64 = if shader_rounding_mode_rtz_float64 {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn max_update_after_bind_descriptors_in_all_pools(
mut self,
max_update_after_bind_descriptors_in_all_pools: u32,
) -> Self {
self.inner.max_update_after_bind_descriptors_in_all_pools = max_update_after_bind_descriptors_in_all_pools;
self
}
pub fn shader_uniform_buffer_array_non_uniform_indexing_native(
mut self,
shader_uniform_buffer_array_non_uniform_indexing_native: bool,
) -> Self {
self.inner.shader_uniform_buffer_array_non_uniform_indexing_native =
if shader_uniform_buffer_array_non_uniform_indexing_native {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_sampled_image_array_non_uniform_indexing_native(
mut self,
shader_sampled_image_array_non_uniform_indexing_native: bool,
) -> Self {
self.inner.shader_sampled_image_array_non_uniform_indexing_native =
if shader_sampled_image_array_non_uniform_indexing_native {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_buffer_array_non_uniform_indexing_native(
mut self,
shader_storage_buffer_array_non_uniform_indexing_native: bool,
) -> Self {
self.inner.shader_storage_buffer_array_non_uniform_indexing_native =
if shader_storage_buffer_array_non_uniform_indexing_native {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_storage_image_array_non_uniform_indexing_native(
mut self,
shader_storage_image_array_non_uniform_indexing_native: bool,
) -> Self {
self.inner.shader_storage_image_array_non_uniform_indexing_native =
if shader_storage_image_array_non_uniform_indexing_native {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn shader_input_attachment_array_non_uniform_indexing_native(
mut self,
shader_input_attachment_array_non_uniform_indexing_native: bool,
) -> Self {
self.inner.shader_input_attachment_array_non_uniform_indexing_native =
if shader_input_attachment_array_non_uniform_indexing_native {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn robust_buffer_access_update_after_bind(mut self, robust_buffer_access_update_after_bind: bool) -> Self {
self.inner.robust_buffer_access_update_after_bind = if robust_buffer_access_update_after_bind {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn quad_divergent_implicit_lod(mut self, quad_divergent_implicit_lod: bool) -> Self {
self.inner.quad_divergent_implicit_lod = if quad_divergent_implicit_lod {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn max_per_stage_descriptor_update_after_bind_samplers(
mut self,
max_per_stage_descriptor_update_after_bind_samplers: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_samplers =
max_per_stage_descriptor_update_after_bind_samplers;
self
}
pub fn max_per_stage_descriptor_update_after_bind_uniform_buffers(
mut self,
max_per_stage_descriptor_update_after_bind_uniform_buffers: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_uniform_buffers =
max_per_stage_descriptor_update_after_bind_uniform_buffers;
self
}
pub fn max_per_stage_descriptor_update_after_bind_storage_buffers(
mut self,
max_per_stage_descriptor_update_after_bind_storage_buffers: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_storage_buffers =
max_per_stage_descriptor_update_after_bind_storage_buffers;
self
}
pub fn max_per_stage_descriptor_update_after_bind_sampled_images(
mut self,
max_per_stage_descriptor_update_after_bind_sampled_images: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_sampled_images =
max_per_stage_descriptor_update_after_bind_sampled_images;
self
}
pub fn max_per_stage_descriptor_update_after_bind_storage_images(
mut self,
max_per_stage_descriptor_update_after_bind_storage_images: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_storage_images =
max_per_stage_descriptor_update_after_bind_storage_images;
self
}
pub fn max_per_stage_descriptor_update_after_bind_input_attachments(
mut self,
max_per_stage_descriptor_update_after_bind_input_attachments: u32,
) -> Self {
self.inner.max_per_stage_descriptor_update_after_bind_input_attachments =
max_per_stage_descriptor_update_after_bind_input_attachments;
self
}
pub fn max_per_stage_update_after_bind_resources(mut self, max_per_stage_update_after_bind_resources: u32) -> Self {
self.inner.max_per_stage_update_after_bind_resources = max_per_stage_update_after_bind_resources;
self
}
pub fn max_descriptor_set_update_after_bind_samplers(
mut self,
max_descriptor_set_update_after_bind_samplers: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_samplers = max_descriptor_set_update_after_bind_samplers;
self
}
pub fn max_descriptor_set_update_after_bind_uniform_buffers(
mut self,
max_descriptor_set_update_after_bind_uniform_buffers: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_uniform_buffers =
max_descriptor_set_update_after_bind_uniform_buffers;
self
}
pub fn max_descriptor_set_update_after_bind_uniform_buffers_dynamic(
mut self,
max_descriptor_set_update_after_bind_uniform_buffers_dynamic: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_uniform_buffers_dynamic =
max_descriptor_set_update_after_bind_uniform_buffers_dynamic;
self
}
pub fn max_descriptor_set_update_after_bind_storage_buffers(
mut self,
max_descriptor_set_update_after_bind_storage_buffers: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_storage_buffers =
max_descriptor_set_update_after_bind_storage_buffers;
self
}
pub fn max_descriptor_set_update_after_bind_storage_buffers_dynamic(
mut self,
max_descriptor_set_update_after_bind_storage_buffers_dynamic: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_storage_buffers_dynamic =
max_descriptor_set_update_after_bind_storage_buffers_dynamic;
self
}
pub fn max_descriptor_set_update_after_bind_sampled_images(
mut self,
max_descriptor_set_update_after_bind_sampled_images: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_sampled_images =
max_descriptor_set_update_after_bind_sampled_images;
self
}
pub fn max_descriptor_set_update_after_bind_storage_images(
mut self,
max_descriptor_set_update_after_bind_storage_images: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_storage_images =
max_descriptor_set_update_after_bind_storage_images;
self
}
pub fn max_descriptor_set_update_after_bind_input_attachments(
mut self,
max_descriptor_set_update_after_bind_input_attachments: u32,
) -> Self {
self.inner.max_descriptor_set_update_after_bind_input_attachments =
max_descriptor_set_update_after_bind_input_attachments;
self
}
pub fn supported_depth_resolve_modes(mut self, supported_depth_resolve_modes: vk::ResolveModeFlags) -> Self {
self.inner.supported_depth_resolve_modes = supported_depth_resolve_modes;
self
}
pub fn supported_stencil_resolve_modes(mut self, supported_stencil_resolve_modes: vk::ResolveModeFlags) -> Self {
self.inner.supported_stencil_resolve_modes = supported_stencil_resolve_modes;
self
}
pub fn independent_resolve_none(mut self, independent_resolve_none: bool) -> Self {
self.inner.independent_resolve_none = if independent_resolve_none { vk::TRUE } else { vk::FALSE };
self
}
pub fn independent_resolve(mut self, independent_resolve: bool) -> Self {
self.inner.independent_resolve = if independent_resolve { vk::TRUE } else { vk::FALSE };
self
}
pub fn filter_minmax_single_component_formats(mut self, filter_minmax_single_component_formats: bool) -> Self {
self.inner.filter_minmax_single_component_formats = if filter_minmax_single_component_formats {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn filter_minmax_image_component_mapping(mut self, filter_minmax_image_component_mapping: bool) -> Self {
self.inner.filter_minmax_image_component_mapping = if filter_minmax_image_component_mapping {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn max_timeline_semaphore_value_difference(mut self, max_timeline_semaphore_value_difference: u64) -> Self {
self.inner.max_timeline_semaphore_value_difference = max_timeline_semaphore_value_difference;
self
}
pub fn framebuffer_integer_color_sample_counts(
mut self,
framebuffer_integer_color_sample_counts: vk::SampleCountFlags,
) -> Self {
self.inner.framebuffer_integer_color_sample_counts = framebuffer_integer_color_sample_counts;
self
}
}
impl<'a> Deref for PhysicalDeviceVulkan12PropertiesBuilder<'a> {
type Target = vk::PhysicalDeviceVulkan12Properties;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineCompilerControlCreateInfoAMD {
type Type = PipelineCompilerControlCreateInfoAMDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineCompilerControlCreateInfoAMDBuilder<'a> {
inner: vk::PipelineCompilerControlCreateInfoAMD,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineCompilerControlCreateInfoAMDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn compiler_control_flags(mut self, compiler_control_flags: vk::PipelineCompilerControlFlagsAMD) -> Self {
self.inner.compiler_control_flags = compiler_control_flags;
self
}
}
impl<'a> Deref for PipelineCompilerControlCreateInfoAMDBuilder<'a> {
type Target = vk::PipelineCompilerControlCreateInfoAMD;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceCoherentMemoryFeaturesAMD {
type Type = PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
inner: vk::PhysicalDeviceCoherentMemoryFeaturesAMD,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn device_coherent_memory(mut self, device_coherent_memory: bool) -> Self {
self.inner.device_coherent_memory = if device_coherent_memory { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceCoherentMemoryFeaturesAMDBuilder<'a> {
type Target = vk::PhysicalDeviceCoherentMemoryFeaturesAMD;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureGeometryTrianglesDataKHR {
type Type = AccelerationStructureGeometryTrianglesDataKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
inner: vk::AccelerationStructureGeometryTrianglesDataKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn vertex_format(mut self, vertex_format: vk::Format) -> Self {
self.inner.vertex_format = vertex_format;
self
}
pub fn vertex_data(mut self, vertex_data: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.vertex_data = vertex_data;
self
}
pub fn vertex_stride(mut self, vertex_stride: vk::DeviceSize) -> Self {
self.inner.vertex_stride = vertex_stride;
self
}
pub fn index_type(mut self, index_type: vk::IndexType) -> Self {
self.inner.index_type = index_type;
self
}
pub fn index_data(mut self, index_data: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.index_data = index_data;
self
}
pub fn transform_data(mut self, transform_data: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.transform_data = transform_data;
self
}
}
impl<'a> Deref for AccelerationStructureGeometryTrianglesDataKHRBuilder<'a> {
type Target = vk::AccelerationStructureGeometryTrianglesDataKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureGeometryAabbsDataKHR {
type Type = AccelerationStructureGeometryAabbsDataKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
inner: vk::AccelerationStructureGeometryAabbsDataKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn data(mut self, data: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.data = data;
self
}
pub fn stride(mut self, stride: vk::DeviceSize) -> Self {
self.inner.stride = stride;
self
}
}
impl<'a> Deref for AccelerationStructureGeometryAabbsDataKHRBuilder<'a> {
type Target = vk::AccelerationStructureGeometryAabbsDataKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureGeometryInstancesDataKHR {
type Type = AccelerationStructureGeometryInstancesDataKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
inner: vk::AccelerationStructureGeometryInstancesDataKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn array_of_pointers(mut self, array_of_pointers: bool) -> Self {
self.inner.array_of_pointers = if array_of_pointers { vk::TRUE } else { vk::FALSE };
self
}
pub fn data(mut self, data: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.data = data;
self
}
}
impl<'a> Deref for AccelerationStructureGeometryInstancesDataKHRBuilder<'a> {
type Target = vk::AccelerationStructureGeometryInstancesDataKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureGeometryKHR {
type Type = AccelerationStructureGeometryKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureGeometryKHRBuilder<'a> {
inner: vk::AccelerationStructureGeometryKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureGeometryKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn geometry_type(mut self, geometry_type: vk::GeometryTypeKHR) -> Self {
self.inner.geometry_type = geometry_type;
self
}
pub fn geometry(mut self, geometry: vk::AccelerationStructureGeometryDataKHR) -> Self {
self.inner.geometry = geometry;
self
}
pub fn flags(mut self, flags: vk::GeometryFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for AccelerationStructureGeometryKHRBuilder<'a> {
type Target = vk::AccelerationStructureGeometryKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureBuildGeometryInfoKHR {
type Type = AccelerationStructureBuildGeometryInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
inner: vk::AccelerationStructureBuildGeometryInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn ty(mut self, ty: vk::AccelerationStructureTypeKHR) -> Self {
self.inner.ty = ty;
self
}
pub fn flags(mut self, flags: vk::BuildAccelerationStructureFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn update(mut self, update: bool) -> Self {
self.inner.update = if update { vk::TRUE } else { vk::FALSE };
self
}
pub fn src_acceleration_structure(
mut self,
src_acceleration_structure: Option<vk::AccelerationStructureKHR>,
) -> Self {
self.inner.src_acceleration_structure = src_acceleration_structure;
self
}
pub fn dst_acceleration_structure(mut self, dst_acceleration_structure: vk::AccelerationStructureKHR) -> Self {
self.inner.dst_acceleration_structure = Some(dst_acceleration_structure);
self
}
pub fn geometry_array_of_pointers(mut self, geometry_array_of_pointers: bool) -> Self {
self.inner.geometry_array_of_pointers = if geometry_array_of_pointers {
vk::TRUE
} else {
vk::FALSE
};
self
}
pub fn geometry_count(mut self, geometry_count: u32) -> Self {
self.inner.geometry_count = geometry_count;
self
}
pub fn pp_geometries(mut self, pp_geometries: *const *const vk::AccelerationStructureGeometryKHR) -> Self {
self.inner.pp_geometries = pp_geometries;
self
}
pub fn scratch_data(mut self, scratch_data: vk::DeviceOrHostAddressKHR) -> Self {
self.inner.scratch_data = scratch_data;
self
}
}
impl<'a> Deref for AccelerationStructureBuildGeometryInfoKHRBuilder<'a> {
type Target = vk::AccelerationStructureBuildGeometryInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureCreateGeometryTypeInfoKHR {
type Type = AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
inner: vk::AccelerationStructureCreateGeometryTypeInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn geometry_type(mut self, geometry_type: vk::GeometryTypeKHR) -> Self {
self.inner.geometry_type = geometry_type;
self
}
pub fn max_primitive_count(mut self, max_primitive_count: u32) -> Self {
self.inner.max_primitive_count = max_primitive_count;
self
}
pub fn index_type(mut self, index_type: vk::IndexType) -> Self {
self.inner.index_type = index_type;
self
}
pub fn max_vertex_count(mut self, max_vertex_count: u32) -> Self {
self.inner.max_vertex_count = max_vertex_count;
self
}
pub fn vertex_format(mut self, vertex_format: vk::Format) -> Self {
self.inner.vertex_format = vertex_format;
self
}
pub fn allows_transforms(mut self, allows_transforms: bool) -> Self {
self.inner.allows_transforms = if allows_transforms { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for AccelerationStructureCreateGeometryTypeInfoKHRBuilder<'a> {
type Target = vk::AccelerationStructureCreateGeometryTypeInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureCreateInfoKHR {
type Type = AccelerationStructureCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureCreateInfoKHRBuilder<'a> {
inner: vk::AccelerationStructureCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn compacted_size(mut self, compacted_size: vk::DeviceSize) -> Self {
self.inner.compacted_size = compacted_size;
self
}
pub fn ty(mut self, ty: vk::AccelerationStructureTypeKHR) -> Self {
self.inner.ty = ty;
self
}
pub fn flags(mut self, flags: vk::BuildAccelerationStructureFlagsKHR) -> Self {
self.inner.flags = flags;
self
}
pub fn p_geometry_infos(
mut self,
p_geometry_infos: &'a [vk::AccelerationStructureCreateGeometryTypeInfoKHR],
) -> Self {
self.inner.max_geometry_count = p_geometry_infos.len() as u32;
self.inner.p_geometry_infos = p_geometry_infos.as_ptr();
self
}
pub fn device_address(mut self, device_address: vk::DeviceAddress) -> Self {
self.inner.device_address = device_address;
self
}
}
impl<'a> Deref for AccelerationStructureCreateInfoKHRBuilder<'a> {
type Target = vk::AccelerationStructureCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureDeviceAddressInfoKHR {
type Type = AccelerationStructureDeviceAddressInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
inner: vk::AccelerationStructureDeviceAddressInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn acceleration_structure(mut self, acceleration_structure: vk::AccelerationStructureKHR) -> Self {
self.inner.acceleration_structure = Some(acceleration_structure);
self
}
}
impl<'a> Deref for AccelerationStructureDeviceAddressInfoKHRBuilder<'a> {
type Target = vk::AccelerationStructureDeviceAddressInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::AccelerationStructureVersionKHR {
type Type = AccelerationStructureVersionKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct AccelerationStructureVersionKHRBuilder<'a> {
inner: vk::AccelerationStructureVersionKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> AccelerationStructureVersionKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn version_data(mut self, version_data: *const u8) -> Self {
self.inner.version_data = version_data;
self
}
}
impl<'a> Deref for AccelerationStructureVersionKHRBuilder<'a> {
type Target = vk::AccelerationStructureVersionKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CopyAccelerationStructureInfoKHR {
type Type = CopyAccelerationStructureInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CopyAccelerationStructureInfoKHRBuilder<'a> {
inner: vk::CopyAccelerationStructureInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CopyAccelerationStructureInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src(mut self, src: vk::AccelerationStructureKHR) -> Self {
self.inner.src = Some(src);
self
}
pub fn dst(mut self, dst: vk::AccelerationStructureKHR) -> Self {
self.inner.dst = Some(dst);
self
}
pub fn mode(mut self, mode: vk::CopyAccelerationStructureModeKHR) -> Self {
self.inner.mode = mode;
self
}
}
impl<'a> Deref for CopyAccelerationStructureInfoKHRBuilder<'a> {
type Target = vk::CopyAccelerationStructureInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CopyAccelerationStructureToMemoryInfoKHR {
type Type = CopyAccelerationStructureToMemoryInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
inner: vk::CopyAccelerationStructureToMemoryInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src(mut self, src: vk::AccelerationStructureKHR) -> Self {
self.inner.src = Some(src);
self
}
pub fn dst(mut self, dst: vk::DeviceOrHostAddressKHR) -> Self {
self.inner.dst = dst;
self
}
pub fn mode(mut self, mode: vk::CopyAccelerationStructureModeKHR) -> Self {
self.inner.mode = mode;
self
}
}
impl<'a> Deref for CopyAccelerationStructureToMemoryInfoKHRBuilder<'a> {
type Target = vk::CopyAccelerationStructureToMemoryInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CopyMemoryToAccelerationStructureInfoKHR {
type Type = CopyMemoryToAccelerationStructureInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
inner: vk::CopyMemoryToAccelerationStructureInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn src(mut self, src: vk::DeviceOrHostAddressConstKHR) -> Self {
self.inner.src = src;
self
}
pub fn dst(mut self, dst: vk::AccelerationStructureKHR) -> Self {
self.inner.dst = Some(dst);
self
}
pub fn mode(mut self, mode: vk::CopyAccelerationStructureModeKHR) -> Self {
self.inner.mode = mode;
self
}
}
impl<'a> Deref for CopyMemoryToAccelerationStructureInfoKHRBuilder<'a> {
type Target = vk::CopyMemoryToAccelerationStructureInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RayTracingPipelineInterfaceCreateInfoKHR {
type Type = RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
inner: vk::RayTracingPipelineInterfaceCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn max_payload_size(mut self, max_payload_size: u32) -> Self {
self.inner.max_payload_size = max_payload_size;
self
}
pub fn max_attribute_size(mut self, max_attribute_size: u32) -> Self {
self.inner.max_attribute_size = max_attribute_size;
self
}
pub fn max_callable_size(mut self, max_callable_size: u32) -> Self {
self.inner.max_callable_size = max_callable_size;
self
}
}
impl<'a> Deref for RayTracingPipelineInterfaceCreateInfoKHRBuilder<'a> {
type Target = vk::RayTracingPipelineInterfaceCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeferredOperationInfoKHR {
type Type = DeferredOperationInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeferredOperationInfoKHRBuilder<'a> {
inner: vk::DeferredOperationInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeferredOperationInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn operation_handle(mut self, operation_handle: vk::DeferredOperationKHR) -> Self {
self.inner.operation_handle = Some(operation_handle);
self
}
}
impl<'a> Deref for DeferredOperationInfoKHRBuilder<'a> {
type Target = vk::DeferredOperationInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PipelineLibraryCreateInfoKHR {
type Type = PipelineLibraryCreateInfoKHRBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PipelineLibraryCreateInfoKHRBuilder<'a> {
inner: vk::PipelineLibraryCreateInfoKHR,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PipelineLibraryCreateInfoKHRBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn p_libraries(mut self, p_libraries: &'a [vk::Pipeline]) -> Self {
self.inner.library_count = p_libraries.len() as u32;
self.inner.p_libraries = p_libraries.as_ptr();
self
}
}
impl<'a> Deref for PipelineLibraryCreateInfoKHRBuilder<'a> {
type Target = vk::PipelineLibraryCreateInfoKHR;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::RenderPassTransformBeginInfoQCOM {
type Type = RenderPassTransformBeginInfoQCOMBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct RenderPassTransformBeginInfoQCOMBuilder<'a> {
inner: vk::RenderPassTransformBeginInfoQCOM,
phantom: PhantomData<&'a c_void>,
}
impl<'a> RenderPassTransformBeginInfoQCOMBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn transform(mut self, transform: vk::SurfaceTransformFlagsKHR) -> Self {
self.inner.transform = transform;
self
}
}
impl<'a> Deref for RenderPassTransformBeginInfoQCOMBuilder<'a> {
type Target = vk::RenderPassTransformBeginInfoQCOM;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::CommandBufferInheritanceRenderPassTransformInfoQCOM {
type Type = CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
inner: vk::CommandBufferInheritanceRenderPassTransformInfoQCOM,
phantom: PhantomData<&'a c_void>,
}
impl<'a> CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn transform(mut self, transform: vk::SurfaceTransformFlagsKHR) -> Self {
self.inner.transform = transform;
self
}
pub fn render_area(mut self, render_area: vk::Rect2D) -> Self {
self.inner.render_area = render_area;
self
}
}
impl<'a> Deref for CommandBufferInheritanceRenderPassTransformInfoQCOMBuilder<'a> {
type Target = vk::CommandBufferInheritanceRenderPassTransformInfoQCOM;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::PhysicalDeviceDiagnosticsConfigFeaturesNV {
type Type = PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
inner: vk::PhysicalDeviceDiagnosticsConfigFeaturesNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *mut c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn diagnostics_config(mut self, diagnostics_config: bool) -> Self {
self.inner.diagnostics_config = if diagnostics_config { vk::TRUE } else { vk::FALSE };
self
}
}
impl<'a> Deref for PhysicalDeviceDiagnosticsConfigFeaturesNVBuilder<'a> {
type Target = vk::PhysicalDeviceDiagnosticsConfigFeaturesNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl<'a> Builder<'a> for vk::DeviceDiagnosticsConfigCreateInfoNV {
type Type = DeviceDiagnosticsConfigCreateInfoNVBuilder<'a>;
fn builder() -> Self::Type {
Default::default()
}
}
#[derive(Default)]
pub struct DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
inner: vk::DeviceDiagnosticsConfigCreateInfoNV,
phantom: PhantomData<&'a c_void>,
}
impl<'a> DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
pub fn s_type(mut self, s_type: vk::StructureType) -> Self {
self.inner.s_type = s_type;
self
}
pub fn p_next(mut self, p_next: *const c_void) -> Self {
self.inner.p_next = p_next;
self
}
pub fn flags(mut self, flags: vk::DeviceDiagnosticsConfigFlagsNV) -> Self {
self.inner.flags = flags;
self
}
}
impl<'a> Deref for DeviceDiagnosticsConfigCreateInfoNVBuilder<'a> {
type Target = vk::DeviceDiagnosticsConfigCreateInfoNV;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
|
pub trait BuilderExtManualGetObjectExpect {
fn get_object_expect<T: glib::object::IsA<glib::object::Object>>(
&self,
name: &str,
) -> T;
}
impl<U: gtk::prelude::BuilderExtManual> BuilderExtManualGetObjectExpect for U
where
U: gtk::prelude::BuilderExtManual,
{
fn get_object_expect<T: glib::object::IsA<glib::object::Object>>(
&self,
name: &str,
) -> T {
self.get_object(name).expect(&format!(
"Expected to get \"{}\" from the builder, but failed.",
name
))
}
}
pub fn create() -> gtk::Builder {
let glade_src = include_str!("../../glade/ui.glade");
gtk::Builder::new_from_string(glade_src)
}
|
pub fn run(){
// For non primitive vars use & to borrow it
// &str read only borrow, ownership is not changed
// &mut str mutable borrow, ownership is not changed
let my_vec = vec![1,2,3];
let my_vec2 = &my_vec;
println!("{:?}",&my_vec );
} |
use std::convert::TryInto;
use luminance::texture::Dim2;
use luminance::texture::Flat;
use luminance::framebuffer::Framebuffer;
use gl;
use luminance::context::GraphicsContext;
use luminance::state::GraphicsState;
pub use luminance::state::StateQueryError;
// pub use luminance_windowing::{CursorMode, Surface, WindowDim, WindowOpt};
use std::cell::RefCell;
use std::fmt;
use std::os::raw::c_void;
use std::rc::Rc;
use std::ffi::CString;
use std::ops::DerefMut;
// #[macro_use] extern crate log;
//Error that can be risen while creating a surface
#[derive(Debug)]
pub enum SurfaceError {
GraphicsStateError(StateQueryError)
}
impl fmt::Display for SurfaceError {
fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
match self {
SurfaceError::GraphicsStateError(sqe) => write!(f, "Failed to get graphics state: {}", sqe)
}
}
}
#[repr(C)]
pub struct Surface {
pub window_size: (u32, u32),
pub gfx_state: Rc<RefCell<GraphicsState>>,
}
unsafe impl GraphicsContext for Surface {
fn state(&self) -> &Rc<RefCell<GraphicsState>> {
&self.gfx_state
}
}
//TODO: Implement better error checking using error enum above (e.g. notify user that sdl2.dll is missing)
//TODO: Perhaps implement wrappers for a bunch of window-related functions?
impl Surface {
pub fn new(window_size: (u32, u32)) -> Result<Self, SurfaceError> {
// gl::load_with(|s| video.gl_get_proc_address(s) as *const c_void);
// let swap_interval = if vsync {
// sdl2::video::SwapInterval::VSync
// } else {
// sdl2::video::SwapInterval::Immediate
// };
//
// video.gl_set_swap_interval(swap_interval).expect("Failed to set swap interval!");
let gfx_state = GraphicsState::new().map_err(SurfaceError::GraphicsStateError)?;
let surface = Self {
window_size: window_size,
gfx_state: Rc::new(RefCell::new(gfx_state)),
};
Ok(surface)
}
pub fn size(&self) -> (u32, u32) {
self.window_size
}
pub fn size_array(&self) -> [u32; 2] {
let size = self.size();
[size.0.try_into().expect("Failed to turn size into i32"), size.1.try_into().expect("Failed to turn size into i32")]
}
pub fn width(&self) -> u32 {
self.window_size.0
}
pub fn height(&self) -> u32 {
self.window_size.1
}
pub fn back_buffer(&mut self) -> Result<Framebuffer<Flat, Dim2, (), ()>, SurfaceError> {
Ok(Framebuffer::back_buffer(self, self.size_array()))
}
}
|
use std::os::unix::io::RawFd;
use std::sync::atomic::Ordering;
use std::sync::Arc;
#[cfg(feature = "io_timeout")]
use std::time::Duration;
use std::{io, ptr};
#[cfg(feature = "io_timeout")]
use super::{timeout_handler, TimerList};
use super::{EventData, IoData};
use crate::scheduler::Scheduler;
#[cfg(feature = "io_timeout")]
use crate::timeout_list::{now, ns_to_dur};
use may_queue::mpsc::Queue;
use smallvec::SmallVec;
pub type SysEvent = libc::kevent;
// used for notify wakeup
const NOTIFY_IDENT: usize = 42;
macro_rules! kevent {
($id:expr, $filter:expr, $flags:expr, $data:expr) => {
libc::kevent {
ident: $id as libc::uintptr_t,
filter: $filter,
flags: $flags,
fflags: 0,
data: 0,
udata: $data as *mut _,
}
};
}
struct SingleSelector {
kqfd: RawFd,
#[cfg(feature = "io_timeout")]
timer_list: TimerList,
free_ev: Queue<Arc<EventData>>,
}
impl SingleSelector {
pub fn new() -> io::Result<Self> {
let kqfd = unsafe { libc::kqueue() };
if kqfd < 0 {
return Err(io::Error::last_os_error());
}
let kev = libc::kevent {
ident: NOTIFY_IDENT,
filter: libc::EVFILT_USER,
flags: libc::EV_ADD | libc::EV_CLEAR,
fflags: 0,
data: 0,
udata: ptr::null_mut(),
};
let ret = unsafe { libc::kevent(kqfd, &kev, 1, ptr::null_mut(), 0, ptr::null()) };
if ret < 0 {
unsafe { libc::close(kqfd) };
return Err(io::Error::last_os_error());
}
Ok(SingleSelector {
kqfd,
free_ev: Queue::new(),
#[cfg(feature = "io_timeout")]
timer_list: TimerList::new(),
})
}
}
impl Drop for SingleSelector {
fn drop(&mut self) {
let _ = unsafe { libc::close(self.kqfd) };
}
}
pub struct Selector {
// 128 should be fine for max io threads
vec: SmallVec<[SingleSelector; 128]>,
}
impl Selector {
pub fn new(io_workers: usize) -> io::Result<Self> {
let mut s = Selector {
vec: SmallVec::new(),
};
for _ in 0..io_workers {
let ss = SingleSelector::new()?;
s.vec.push(ss);
}
Ok(s)
}
#[inline]
pub fn select(
&self,
scheduler: &Scheduler,
id: usize,
events: &mut [SysEvent],
_timeout: Option<u64>,
) -> io::Result<Option<u64>> {
#[cfg(feature = "io_timeout")]
let timeout_spec = _timeout.map(|to| {
let dur = ns_to_dur(to);
libc::timespec {
tv_sec: dur.as_secs() as libc::time_t,
tv_nsec: dur.subsec_nanos() as libc::c_long,
}
});
#[cfg(feature = "io_timeout")]
let timeout = timeout_spec
.as_ref()
.map(|s| s as *const _)
.unwrap_or(ptr::null_mut());
#[cfg(not(feature = "io_timeout"))]
let timeout = ptr::null_mut();
// info!("select; timeout={:?}", timeout_ms);
let single_selector = unsafe { self.vec.get_unchecked(id) };
// Wait for kqueue events for at most timeout_ms milliseconds
let kqfd = single_selector.kqfd;
let n = unsafe {
libc::kevent(
kqfd,
ptr::null(),
0,
events.as_mut_ptr(),
events.len() as libc::c_int,
timeout,
)
};
if n < 0 {
return Err(io::Error::last_os_error());
}
let n = n as usize;
for event in unsafe { events.get_unchecked(..n) } {
if event.udata.is_null() {
// this is just a wakeup event, ignore it
// let mut buf = [0u8; 8];
// clear the eventfd, ignore the result
// read(self.vec[id].evfd, &mut buf).ok();
info!("got wakeup event in select, id={}", id);
scheduler.collect_global(id);
continue;
}
let data = unsafe { &mut *(event.udata as *mut EventData) };
// info!("select got event, data={:p}", data);
data.io_flag.store(true, Ordering::Release);
// first check the atomic co, this may be grab by the worker first
let co = match data.co.take() {
None => continue,
Some(co) => co,
};
// it's safe to remove the timer since we are running the timer_list in the same thread
#[cfg(feature = "io_timeout")]
data.timer.borrow_mut().take().map(|h| {
unsafe {
// tell the timer handler not to cancel the io
// it's not always true that you can really remove the timer entry
h.with_mut_data(|value| value.data.event_data = ptr::null_mut());
}
h.remove()
});
#[cfg(feature = "work_steal")]
scheduler.schedule_with_id(co, id);
#[cfg(not(feature = "work_steal"))]
crate::coroutine_impl::run_coroutine(co);
}
// run all the local tasks
scheduler.run_queued_tasks(id);
// free the unused event_data
self.free_unused_event_data(id);
// deal with the timer list
#[cfg(feature = "io_timeout")]
let next_expire = single_selector
.timer_list
.schedule_timer(now(), &timeout_handler);
#[cfg(not(feature = "io_timeout"))]
let next_expire = None;
Ok(next_expire)
}
// this will post an os event so that we can wakeup the event loop
#[inline]
pub fn wakeup(&self, id: usize) {
let kqfd = unsafe { self.vec.get_unchecked(id) }.kqfd;
let kev = libc::kevent {
ident: NOTIFY_IDENT,
filter: libc::EVFILT_USER,
flags: 0,
fflags: libc::NOTE_TRIGGER,
data: 0,
udata: ptr::null_mut(),
};
let ret = unsafe { libc::kevent(kqfd, &kev, 1, ptr::null_mut(), 0, ptr::null()) };
trace!("wakeup id={:?}, ret={:?}", id, ret);
}
// register io event to the selector
#[inline]
pub fn add_fd(&self, io_data: IoData) -> io::Result<IoData> {
let fd = io_data.fd;
let id = fd as usize % self.vec.len();
let kqfd = unsafe { self.vec.get_unchecked(id) }.kqfd;
info!("add fd to kqueue select, fd={:?}", fd);
let flags = libc::EV_ADD | libc::EV_CLEAR;
let udata = io_data.as_ref() as *const _;
let changes = [
kevent!(fd, libc::EVFILT_READ, flags, udata),
kevent!(fd, libc::EVFILT_WRITE, flags, udata),
];
let n = unsafe {
libc::kevent(
kqfd,
changes.as_ptr(),
changes.len() as libc::c_int,
ptr::null_mut(),
0,
ptr::null(),
)
};
if n < 0 {
return Err(io::Error::last_os_error());
}
Ok(io_data)
}
#[inline]
pub fn mod_fd(&self, io_data: &IoData, is_read: bool) -> io::Result<()> {
let fd = io_data.fd;
let id = fd as usize % self.vec.len();
let kqfd = unsafe { self.vec.get_unchecked(id) }.kqfd;
info!("add fd to kqueue select, fd={:?}", fd);
let flags = libc::EV_DELETE;
let udata = io_data.as_ref() as *const _;
let changes = if is_read {
[kevent!(fd, libc::EVFILT_WRITE, flags, udata)]
} else {
[kevent!(fd, libc::EVFILT_READ, flags, udata)]
};
let n = unsafe {
libc::kevent(
kqfd,
changes.as_ptr(),
changes.len() as libc::c_int,
ptr::null_mut(),
0,
ptr::null(),
)
};
if n < 0 {
return Err(io::Error::last_os_error());
}
Ok(())
}
#[inline]
pub fn del_fd(&self, io_data: &IoData) {
#[cfg(feature = "io_timeout")]
io_data.timer.borrow_mut().take().map(|h| {
unsafe {
// mark the timer as removed if any, this only happened
// when cancel an IO. what if the timer expired at the same time?
// because we run this func in the user space, so the timer handler
// will not got the coroutine
h.with_mut_data(|value| value.data.event_data = ptr::null_mut());
}
});
let fd = io_data.fd;
let id = fd as usize % self.vec.len();
let single_selector = unsafe { self.vec.get_unchecked(id) };
let kqfd = single_selector.kqfd;
info!("del fd from kqueue select, fd={:?}", fd);
let filter = libc::EV_DELETE;
let changes = [
kevent!(fd, libc::EVFILT_READ, filter, ptr::null_mut()),
kevent!(fd, libc::EVFILT_WRITE, filter, ptr::null_mut()),
];
// ignore the error
unsafe {
libc::kevent(
kqfd,
changes.as_ptr(),
changes.len() as libc::c_int,
ptr::null_mut(),
0,
ptr::null(),
);
}
// after EpollCtlDel push the unused event data
single_selector.free_ev.push((*io_data).clone());
}
// we can't free the event data directly in the worker thread
// must free them before the next epoll_wait
#[inline]
fn free_unused_event_data(&self, id: usize) {
let free_ev = &unsafe { self.vec.get_unchecked(id) }.free_ev;
while !free_ev.bulk_pop().is_empty() {}
}
// register the io request to the timeout list
#[inline]
#[cfg(feature = "io_timeout")]
pub fn add_io_timer(&self, io: &IoData, timeout: Duration) {
let id = io.fd as usize % self.vec.len();
// info!("io timeout = {:?}", dur);
let (h, b_new) = unsafe { self.vec.get_unchecked(id) }
.timer_list
.add_timer(timeout, io.timer_data());
if b_new {
// wakeup the event loop thread to recall the next wait timeout
self.wakeup(id);
}
io.timer.borrow_mut().replace(h);
}
}
|
#[doc = "Register `PECR` reader"]
pub type R = crate::R<PECR_SPEC>;
#[doc = "Register `PECR` writer"]
pub type W = crate::W<PECR_SPEC>;
#[doc = "Field `PELOCK` reader - FLASH_PECR and data EEPROM lock"]
pub type PELOCK_R = crate::BitReader;
#[doc = "Field `PELOCK` writer - FLASH_PECR and data EEPROM lock"]
pub type PELOCK_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `PRGLOCK` reader - Program memory lock"]
pub type PRGLOCK_R = crate::BitReader;
#[doc = "Field `PRGLOCK` writer - Program memory lock"]
pub type PRGLOCK_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `OPTLOCK` reader - Option bytes block lock"]
pub type OPTLOCK_R = crate::BitReader;
#[doc = "Field `OPTLOCK` writer - Option bytes block lock"]
pub type OPTLOCK_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `PROG` reader - Program memory selection"]
pub type PROG_R = crate::BitReader;
#[doc = "Field `PROG` writer - Program memory selection"]
pub type PROG_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `DATA` reader - Data EEPROM selection"]
pub type DATA_R = crate::BitReader;
#[doc = "Field `DATA` writer - Data EEPROM selection"]
pub type DATA_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `FTDW` reader - Fixed time data write for Byte, Half Word and Word programming"]
pub type FTDW_R = crate::BitReader;
#[doc = "Field `FTDW` writer - Fixed time data write for Byte, Half Word and Word programming"]
pub type FTDW_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `ERASE` reader - Page or Double Word erase mode"]
pub type ERASE_R = crate::BitReader;
#[doc = "Field `ERASE` writer - Page or Double Word erase mode"]
pub type ERASE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `FPRG` reader - Half Page/Double Word programming mode"]
pub type FPRG_R = crate::BitReader;
#[doc = "Field `FPRG` writer - Half Page/Double Word programming mode"]
pub type FPRG_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `PARALLELBANK` reader - Parallel bank mode"]
pub type PARALLELBANK_R = crate::BitReader;
#[doc = "Field `PARALLELBANK` writer - Parallel bank mode"]
pub type PARALLELBANK_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `EOPIE` reader - End of programming interrupt enable"]
pub type EOPIE_R = crate::BitReader;
#[doc = "Field `EOPIE` writer - End of programming interrupt enable"]
pub type EOPIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `ERRIE` reader - Error interrupt enable"]
pub type ERRIE_R = crate::BitReader;
#[doc = "Field `ERRIE` writer - Error interrupt enable"]
pub type ERRIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `OBL_LAUNCH` reader - Launch the option byte loading"]
pub type OBL_LAUNCH_R = crate::BitReader;
#[doc = "Field `OBL_LAUNCH` writer - Launch the option byte loading"]
pub type OBL_LAUNCH_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bit 0 - FLASH_PECR and data EEPROM lock"]
#[inline(always)]
pub fn pelock(&self) -> PELOCK_R {
PELOCK_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - Program memory lock"]
#[inline(always)]
pub fn prglock(&self) -> PRGLOCK_R {
PRGLOCK_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - Option bytes block lock"]
#[inline(always)]
pub fn optlock(&self) -> OPTLOCK_R {
OPTLOCK_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - Program memory selection"]
#[inline(always)]
pub fn prog(&self) -> PROG_R {
PROG_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - Data EEPROM selection"]
#[inline(always)]
pub fn data(&self) -> DATA_R {
DATA_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 8 - Fixed time data write for Byte, Half Word and Word programming"]
#[inline(always)]
pub fn ftdw(&self) -> FTDW_R {
FTDW_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - Page or Double Word erase mode"]
#[inline(always)]
pub fn erase(&self) -> ERASE_R {
ERASE_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - Half Page/Double Word programming mode"]
#[inline(always)]
pub fn fprg(&self) -> FPRG_R {
FPRG_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 15 - Parallel bank mode"]
#[inline(always)]
pub fn parallelbank(&self) -> PARALLELBANK_R {
PARALLELBANK_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - End of programming interrupt enable"]
#[inline(always)]
pub fn eopie(&self) -> EOPIE_R {
EOPIE_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - Error interrupt enable"]
#[inline(always)]
pub fn errie(&self) -> ERRIE_R {
ERRIE_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - Launch the option byte loading"]
#[inline(always)]
pub fn obl_launch(&self) -> OBL_LAUNCH_R {
OBL_LAUNCH_R::new(((self.bits >> 18) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - FLASH_PECR and data EEPROM lock"]
#[inline(always)]
#[must_use]
pub fn pelock(&mut self) -> PELOCK_W<PECR_SPEC, 0> {
PELOCK_W::new(self)
}
#[doc = "Bit 1 - Program memory lock"]
#[inline(always)]
#[must_use]
pub fn prglock(&mut self) -> PRGLOCK_W<PECR_SPEC, 1> {
PRGLOCK_W::new(self)
}
#[doc = "Bit 2 - Option bytes block lock"]
#[inline(always)]
#[must_use]
pub fn optlock(&mut self) -> OPTLOCK_W<PECR_SPEC, 2> {
OPTLOCK_W::new(self)
}
#[doc = "Bit 3 - Program memory selection"]
#[inline(always)]
#[must_use]
pub fn prog(&mut self) -> PROG_W<PECR_SPEC, 3> {
PROG_W::new(self)
}
#[doc = "Bit 4 - Data EEPROM selection"]
#[inline(always)]
#[must_use]
pub fn data(&mut self) -> DATA_W<PECR_SPEC, 4> {
DATA_W::new(self)
}
#[doc = "Bit 8 - Fixed time data write for Byte, Half Word and Word programming"]
#[inline(always)]
#[must_use]
pub fn ftdw(&mut self) -> FTDW_W<PECR_SPEC, 8> {
FTDW_W::new(self)
}
#[doc = "Bit 9 - Page or Double Word erase mode"]
#[inline(always)]
#[must_use]
pub fn erase(&mut self) -> ERASE_W<PECR_SPEC, 9> {
ERASE_W::new(self)
}
#[doc = "Bit 10 - Half Page/Double Word programming mode"]
#[inline(always)]
#[must_use]
pub fn fprg(&mut self) -> FPRG_W<PECR_SPEC, 10> {
FPRG_W::new(self)
}
#[doc = "Bit 15 - Parallel bank mode"]
#[inline(always)]
#[must_use]
pub fn parallelbank(&mut self) -> PARALLELBANK_W<PECR_SPEC, 15> {
PARALLELBANK_W::new(self)
}
#[doc = "Bit 16 - End of programming interrupt enable"]
#[inline(always)]
#[must_use]
pub fn eopie(&mut self) -> EOPIE_W<PECR_SPEC, 16> {
EOPIE_W::new(self)
}
#[doc = "Bit 17 - Error interrupt enable"]
#[inline(always)]
#[must_use]
pub fn errie(&mut self) -> ERRIE_W<PECR_SPEC, 17> {
ERRIE_W::new(self)
}
#[doc = "Bit 18 - Launch the option byte loading"]
#[inline(always)]
#[must_use]
pub fn obl_launch(&mut self) -> OBL_LAUNCH_W<PECR_SPEC, 18> {
OBL_LAUNCH_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "Program/erase control register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`pecr::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`pecr::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct PECR_SPEC;
impl crate::RegisterSpec for PECR_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`pecr::R`](R) reader structure"]
impl crate::Readable for PECR_SPEC {}
#[doc = "`write(|w| ..)` method takes [`pecr::W`](W) writer structure"]
impl crate::Writable for PECR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets PECR to value 0x07"]
impl crate::Resettable for PECR_SPEC {
const RESET_VALUE: Self::Ux = 0x07;
}
|
use std::ptr;
use assets::AssetBundle;
use capi::common::parse_asset_id;
use libc::c_char;
use error::Error;
ffi_fn! {
fn dmbc_asset_create(
id: *const c_char,
amount: u64,
error: *mut Error,
) -> *mut AssetBundle {
let asset_id = match parse_asset_id(id) {
Ok(id) => id,
Err(err) => {
unsafe {
if !error.is_null() {
*error = err;
}
return ptr::null_mut();
}
}
};
Box::into_raw(
Box::new(
AssetBundle::new(asset_id, amount)
)
)
}
}
ffi_fn! {
fn dmbc_asset_free(asset: *const AssetBundle) {
if !asset.is_null() {
unsafe { Box::from_raw(asset as *mut AssetBundle); }
}
}
}
|
#[macro_use] extern crate log;
extern crate env_logger;
extern crate lapin_futures as lapin;
extern crate futures;
extern crate tokio;
extern crate uuid;
extern crate signin;
use uuid::Uuid;
use futures::future::Future;
use futures::Stream;
use tokio::executor::current_thread::{ self, CurrentThread };
use tokio::net::TcpStream;
use tokio::io::{ AsyncRead, AsyncWrite };
use lapin::client::ConnectionOptions;
use lapin::channel::{ Channel, BasicConsumeOptions, BasicPublishOptions, BasicProperties, QueueDeclareOptions };
use lapin::types::FieldTable;
fn main () {
env_logger::init();
let addr = "127.0.0.3:5672".parse().unwrap();
let mut current_thread = CurrentThread::new();
let task = TcpStream::connect(&addr).and_then(|stream| {
lapin::client::Client::connect(stream, &ConnectionOptions::default())
}).and_then(|(client, heartbeat_future_fn)| {
let heartbeat_client = client.clone();
current_thread::spawn(heartbeat_future_fn(&heartbeat_client).map_err(|_| ()));
client.create_channel()
}).and_then(|channel| Handler::queue_declare(channel)).map_err(|_| ());
current_thread.spawn(task);
current_thread.run().unwrap();
}
struct Handler;
impl Handler {
pub fn queue_declare<T>(channel: Channel<T>)
-> Box<Future<Item = (), Error = std::io::Error>>
where T: AsyncRead + AsyncWrite + Sync + Send + 'static {
let ch = channel.clone();
let name = format!("{}", Uuid::new_v4());
let queue = channel.queue_declare("sif", &QueueDeclareOptions::default(), &FieldTable::new()).and_then(move |_| {
channel.basic_consume("sif", &name, &BasicConsumeOptions::default(), &FieldTable::new())
}).and_then(|stream| {
info!("[.] Waiting for requests...");
stream.for_each(move |message| {
let BasicProperties { correlation_id, reply_to, .. } = message.properties.clone();
if let (Some(reply_to), Some(correlation_id)) = (reply_to, correlation_id) {
info!("[x] Got a request!");
debug!("Message: {:?}", message);
debug!("Message's content: {:?}", std::str::from_utf8(&message.data).unwrap());
let properties = BasicProperties::default()
.with_correlation_id(correlation_id);
ch.basic_publish("", &reply_to, b"hello from server", &BasicPublishOptions::default(), properties);
ch.basic_ack(message.delivery_tag);
}
Ok(())
})
});
Box::new(queue)
}
}
|
use std::{
fmt,
ops::{Index, Range},
};
use super::TokenKind;
#[derive(Clone, Copy, PartialEq)]
pub struct Token {
pub kind: TokenKind,
pub span: Span,
}
impl Token {
/// Get the token's text as a slice of the input string
pub fn text<'input>(&self, input: &'input str) -> &'input str {
&input[self.span]
}
}
#[derive(Clone, Copy, PartialEq)]
pub struct Span {
pub start: usize,
pub end: usize,
}
impl Span {
/// Return the line number (0 based) and column number (0 based)
/// of the token (relative to the input string)
pub fn get_line_and_column(&self, input: &str) -> (usize, usize) {
let start = self.start as usize;
let mut line = 0;
let mut column = 0;
for (index, byte) in input.bytes().enumerate() {
if index == start {
break;
}
if byte == b'\n' {
line += 1;
column = 0;
}
column += 1;
}
(line, column)
}
pub fn _len(&self) -> usize {
self.end - self.start
}
}
impl From<Span> for Range<usize> {
fn from(span: Span) -> Self {
span.start as usize..span.end as usize
}
}
impl From<Range<usize>> for Span {
fn from(range: Range<usize>) -> Self {
Self {
start: range.start,
end: range.end,
}
}
}
impl Index<Span> for str {
type Output = str;
fn index(&self, index: Span) -> &Self::Output {
&self[Range::<usize>::from(index)]
}
}
impl fmt::Display for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.kind)
}
}
impl fmt::Debug for Token {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"{:?} ({}, {})",
self.kind, self.span.start, self.span.end
)
}
}
|
// This file is part of dpdk. It is subject to the license terms in the COPYRIGHT file found in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/dpdk/master/COPYRIGHT. No part of dpdk, including this file, may be copied, modified, propagated, or distributed except according to the terms contained in the COPYRIGHT file.
// Copyright © 2017 The developers of dpdk. See the COPYRIGHT file in the top-level directory of this distribution and at https://raw.githubusercontent.com/lemonrock/dpdk/master/COPYRIGHT.
pub enum CompletionQueueContextChoice
{
Unextended(UnextendedCompletionQueueContext),
Extended(ExtendedCompletionQueueContext),
}
impl CompletionQueueContextChoice
{
/// completionQueuePointerMaybeExtended can also be of type ibv_cq_ex
#[inline(always)]
pub fn destroy(&mut self, completionQueuePointerMaybeExtended: *mut ibv_cq)
{
match *self
{
CompletionQueueContextChoice::Unextended(ref mut context) => context.destroy(completionQueuePointerMaybeExtended),
CompletionQueueContextChoice::Extended(ref mut context) => context.destroy(completionQueuePointerMaybeExtended),
}
}
#[inline(always)]
pub fn pollToExhaustion<UnextendedWorkCompletionUser: Fn(UnextendedWorkCompletion), ExtendedWorkCompletionUser: Fn(ExtendedWorkCompletion)>(&mut self, completionQueuePointerMaybeExtended: *mut ibv_cq, unextendedWorkCompletionUser: UnextendedWorkCompletionUser, extendedWorkCompletionUser: ExtendedWorkCompletionUser)
{
match *self
{
CompletionQueueContextChoice::Unextended(ref mut context) =>
{
context.pollToExhaustion(completionQueuePointerMaybeExtended, unextendedWorkCompletionUser)
},
CompletionQueueContextChoice::Extended(ref mut context) =>
{
context.pollToExhaustion(completionQueuePointerMaybeExtended, extendedWorkCompletionUser)
},
}
}
}
|
//! Implements all outgoing status packets
/*
use super::super::super::deque_buffer::DequeBuffer;
use super::super::super::game_connection::GameConnection; //It's super super super effective!
use super::super::{ ID_STATUS_STC_RESPONSE, ID_STATUS_STC_PONG };
use super::OutgoingPacket;
use rustc_serialize::json;
mod response {
use super::super::super::super::super::super::{get_version, MINECRAFT_PROTOCOL_VERSION};
use super::super::super::super::super::super::universe::{MAX_PLAYERS};
/// A response to be sent by the server list response packet
#[derive(Debug, RustcDecodable, RustcEncodable)]
pub struct Response {
/// The player data contained in this response
pub players: Players,
/// The version data contained in this response
pub version: Version,
/// The description contained in this response
pub description: Description,
/// The optional / Forge-only mod information
pub modinfo: Option<ModInfo>
}
impl Response {
/// Constructs a new Response
pub fn construct() -> Response {
return Response { players: Players::construct(), version: Version::construct(), description: Description::construct(), modinfo: Some(ModInfo::construct())};
}
}
/// A struct containing mod (forge) information
#[derive(Debug, RustcDecodable, RustcEncodable)]
#[allow(non_snake_case)]
pub struct ModInfo {
/// The type of mod loader compatibility being used
pub _type: String,
/// The list of mods currently in use on the server
pub modList: Vec<ModDescriptor>
}
impl ModInfo {
/// Constructs a new ModInfo struct
pub fn construct() -> ModInfo {
ModInfo { _type: "FML".to_string(), modList: ModDescriptor::construct() }
}
}
/// A struct containing mod information
#[derive(Debug, RustcDecodable, RustcEncodable)]
pub struct ModDescriptor {
/// The mod's ID
pub modid: String,
/// The mod's version
pub version: String
}
impl ModDescriptor {
/// Constructs a new list of ModDescriptors
pub fn construct() -> Vec<ModDescriptor> {
//TODO: One day, replace this with names of mods added
vec!(
ModDescriptor { modid: "ExampleMod".to_string(), version: "0.0.1-pre".to_string() }
)
}
}
/// A struct defining the players portion of the StatusResponsePacket
#[derive(Debug, RustcDecodable, RustcEncodable)]
pub struct Players {
/// The maximum number of players allowed on this server
pub max: i32, //Yes, I know. But Java only supports signed integers
/// The current number of online players
pub online: i32
}
impl Players {
/// Constructs a new Players struct
///
/// TODO: Make this use real data for online
pub fn construct() -> Players {
Players { max: MAX_PLAYERS, online: 0 }
}
}
/// The version part of the response packet
#[derive(Debug, RustcDecodable, RustcEncodable)]
pub struct Version {
/// The name of the version (This may or may not be ignored)
pub name: String,
/// The Minecraft protocol number being used
pub protocol: u32
}
impl Version {
/// Constructs a new Version struct
///
/// TODO: Make name use a defined value
pub fn construct() -> Version {
Version { name: "1.8.8".to_string(), protocol: MINECRAFT_PROTOCOL_VERSION }
}
}
/// The description part of the response packet
#[derive(Debug, RustcDecodable, RustcEncodable)]
pub struct Description {
/// The text to display
pub text: String
}
impl Description {
/// Constructs a new Description.
///
/// In the future, this will get the description from a (cached) file
pub fn construct() -> Description {
Description { text: format!("A Netherrack {} server", get_version()) }
}
}
}
/// A packet sent from the server to
pub struct StatusResponsePacket;
impl StatusResponsePacket {
/// Creates a new Packet
pub fn new() -> StatusResponsePacket {
StatusResponsePacket
}
}
impl OutgoingPacket for StatusResponsePacket {
/// Gets this StatusResponsePacket's ID
///
/// One day, this will be replaced with an associated constant
fn get_id(&self) -> u32 {
ID_STATUS_STC_RESPONSE
}
/// Encodes this StatusResponsePacket's data
fn encode_data(&self, buffer: &mut DequeBuffer) {
buffer.write_utf8_string(
json::encode(&response::Response::construct()).unwrap().replace("_type", "type")
);
}
}
/// A packet sent from the server to the client responding to a ping
pub struct ListPongPacket {
pub payload: i64
}
impl ListPongPacket {
/// Creates a new ListPongPacket
pub fn new(payload: i64) -> ListPongPacket {
ListPongPacket { payload: payload }
}
}
impl OutgoingPacket for ListPongPacket {
/// Gets this ListPongPacket's ID
fn get_id(&self) -> u32 {
ID_STATUS_STC_PONG
}
/// Encodes this Packet's data
fn encode_data(&self, buffer: &mut DequeBuffer) {
buffer.write_signed_long(self.payload);
}
/// Called after the OutgoingPacket is sent
fn post_send(&self, connection: &mut GameConnection) {
// All ListPongPackets are at the end of any packet stream, so we can disconnect the client here
connection.disconnect();
}
}*/
|
$NetBSD: patch-src_utils.rs,v 1.1 2023/07/13 20:38:53 pin Exp $
Allow building on NetBSD.
--- src/utils.rs.orig 2023-04-20 21:37:30.000000000 +0000
+++ src/utils.rs
@@ -1,7 +1,7 @@
use log::trace;
use std::env;
-#[cfg(any(target_os = "freebsd", target_os = "linux"))]
+#[cfg(any(target_os = "netbsd", target_os = "freebsd", target_os = "linux"))]
fn get_shell_ffi() -> Option<String> {
use libc::{geteuid, getpwuid_r};
use std::{ffi::CStr, mem, ptr};
|
use std::{ffi::OsStr, fs::File, path::Path};
use anyhow::Result;
use flate2::{Compression, GzBuilder};
use polars::prelude::*;
use crate::Rank;
fn read_graph_by_poloars(path: &Path, rank: &Rank) -> Result<DataFrame> {
let schema = Schema::new(vec![
Field::new("gene_1", DataType::Utf8),
Field::new("gene_2", DataType::Utf8),
Field::new("corr", DataType::Float64),
Field::new("rank", DataType::Float64),
]);
let mut df = CsvReader::from_path(path)?
.has_header(true)
.with_schema(&schema)
.finish()?;
let col_name = match rank {
Rank::HRR => "hrr_rank",
Rank::MR => "mr_rank",
};
df.rename("rank", col_name)?;
Ok(df)
}
fn add_relation(df: &mut DataFrame) -> Result<()> {
let gene1chunk = df.column("gene_1")?.utf8()?;
// Either ownership is required for add op with "-"
let gene2chunk = df.column("gene_2")?.utf8()?;
let genechunk = gene1chunk + "-" + gene2chunk.to_owned();
df.replace_or_add("relation", genechunk.into_series())?;
Ok(())
}
fn filterout_by_rank_and_merge(
df: &DataFrame,
other: &DataFrame,
priority: &Rank,
max_rank: f64,
) -> Result<DataFrame> {
let col_name = match priority {
Rank::HRR => "hrr_rank",
Rank::MR => "mr_rank",
};
let mask = df.column(col_name)?.f64()?.lt_eq(max_rank);
let df = df.filter(&mask)?;
let merged_df = df
.inner_join(other, "relation", "relation")?
.select(vec!["gene_1", "gene_2", "corr", "hrr_rank", "mr_rank"])?;
Ok(merged_df)
}
pub fn parse_args(
hrr_path: &Path,
mr_path: &Path,
out_path: &Path,
priority: &Rank,
max_rank: &f64,
) -> Result<()> {
info!(
"\n hrr graph path: {:?}\n mr graph path: {:?}\n out_path: {:?}\n priority rank: {}, max rank: {}",
hrr_path, mr_path, out_path, priority, max_rank
);
let mut hrr_df = read_graph_by_poloars(hrr_path, &Rank::HRR)?;
let mut mr_df = read_graph_by_poloars(mr_path, &Rank::MR)?;
add_relation(&mut hrr_df)?;
add_relation(&mut mr_df)?;
let merged_df = match priority {
Rank::HRR => filterout_by_rank_and_merge(&hrr_df, &mr_df, priority, *max_rank),
Rank::MR => filterout_by_rank_and_merge(&mr_df, &hrr_df, priority, *max_rank),
}?;
let ext = out_path.extension();
let mut f = File::create(out_path)?;
if ext == Some(OsStr::new("gz")) {
let mut gz = GzBuilder::new().write(f, Compression::default());
CsvWriter::new(&mut gz)
.has_header(true)
.with_delimiter(b',')
.finish(&merged_df)?;
} else {
CsvWriter::new(&mut f)
.has_header(true)
.with_delimiter(b',')
.finish(&merged_df)?;
}
Ok(())
}
|
use crate::common::models::Event;
use crate::frontend::routes::Table;
use yew::{html, Html};
impl Table for Event {
fn title() -> &'static str {
"Events"
}
fn render_header() -> Html {
html! {
<tr>
<th>{ "#" }</th>
<th>{ "Name" }</th>
</tr>
}
}
fn render_row(&self) -> Html {
html! {
<tr>
<td>{ self.id }</td>
<td>{ &self.name.as_deref().unwrap_or("") }</td>
</tr>
}
}
}
|
use bincode;
use std::fs::File;
use std::io::prelude::*;
pub fn read_from_file(file: &str) -> Vec<u8> {
let mut file: File = File::open(file).unwrap();
let mut buf: Vec<u8> = Vec::with_capacity(file.metadata().unwrap().len() as usize);
file.read_to_end(&mut buf).unwrap();
buf
}
pub fn read_from_file_deserialized(file: &str) -> Vec<u32> {
let mut file: File = File::open(file).unwrap();
let mut buf: Vec<u8> = Vec::with_capacity(file.metadata().unwrap().len() as usize);
file.read_to_end(&mut buf).unwrap();
let deserialized: Vec<u32> = bincode::deserialize(&buf).unwrap();
deserialized
}
pub fn write_vec8_to_file(data: &Vec<u8>, file: &str) {
let mut file: File = File::create(file).unwrap();
file.write_all(data).unwrap();
file.sync_all().unwrap();
}
pub fn write_to_file_serialized(data: &Vec<u32>, file: &str) {
let mut file: File = File::create(file).unwrap();
let serialized_data = bincode::serialize(data).unwrap();
file.write_all(&serialized_data).unwrap();
file.sync_all().unwrap();
}
|
mod event;
mod event_manager;
mod event_reader;
mod event_writer;
mod glue;
pub use event::{Axis, Button, Direction, Event, Key, KeyKind};
pub use event_manager::EventManager;
pub use event_writer::EventWriter;
|
/// Args models our command line arguments
pub struct Args {
pub command: Option<String>,
pub private_key: Option<String>,
pub server: Option<String>,
pub subject: Option<String>,
pub message: Option<String>,
pub exec: Option<String>,
}
|
use crate::{AnyBin, BinSegment, Bytes128};
/// Trait used to build a binary efficiently (with just one allocation & no re-allocation or
/// even without allocation).
///
/// ```rust
/// use abin::{NewBin, BinSegment, Bin, AnyBin, BinBuilder};
///
/// let mut builder = NewBin::builder();
/// builder.push(BinSegment::Static("Hello, ".as_bytes()));
/// builder.push(BinSegment::Static("World!".as_bytes()));
/// let bin : Bin = builder.build();
///
/// assert_eq!("Hello, World!".as_bytes(), bin.as_slice());
/// ```
pub trait BinBuilder<'a> {
type T: AnyBin;
fn push(&mut self, segment: impl Into<BinSegment<'a, Self::T>>);
#[inline]
fn push_bin(&mut self, bin: impl Into<Self::T>) {
self.push(BinSegment::Bin(bin.into()));
}
#[inline]
fn push_slice(&mut self, slice: impl Into<&'a [u8]>) {
self.push(BinSegment::Slice(slice.into()));
}
#[inline]
fn push_static(&mut self, slice: impl Into<&'static [u8]>) {
self.push(BinSegment::Static(slice.into()));
}
#[inline]
fn push_given_vec(&mut self, vec: impl Into<Vec<u8>>) {
self.push(BinSegment::GivenVec(vec.into()));
}
#[inline]
fn push_u8(&mut self, byte: u8) {
let bin_segment: Bytes128 = byte.into();
self.push(BinSegment::Bytes128(bin_segment));
}
/// Builds the binary.
///
/// Note: After calling this method, the builder will be empty again and can be re-used. We
/// use `&mut self` here instead of `self` to make sure the builder is not copied (it's large).
/// I'm not sure how well rust would optimize `self` here.
fn build(&mut self) -> Self::T;
}
|
use super::memory::{MemoryError};
use crate::microvm::memory::address::AddressType;
mod traits {
use crate::microvm::mmu::MMU;
use crate::microvm::memory::address::AddressType;
pub trait Regs<Reg> {
type RegIdentifier;
fn get_reg(&self, ident: u32) -> Reg;
fn set_reg(&mut self, ident: u32, value: Reg);
}
pub trait Context<'a, Address: AddressType> {
type Regs;
fn mmu() -> &'a MMU< Address>;
fn mmu_mut() -> &'a mut MMU< Address>;
}
}
#[derive(Debug, Clone)]
pub enum VMError {
Memory(MemoryError),
InvalidArguments,
InvalidInstructionFormat,
InvalidSettings
}
pub trait VM<'a, Address: AddressType, Context: traits::Context<'a, Address>> {
fn cycle() -> Result<(), VMError>;
}
|
use crate::BlockingProvider;
use sputnik::backend::{Backend, Basic, MemoryAccount, MemoryVicinity};
use ethers::{
providers::Middleware,
types::{H160, H256, U256},
};
use std::collections::BTreeMap;
/// Memory backend with ability to fork another chain from an HTTP provider, storing all state
/// values in a `BTreeMap` in memory.
#[derive(Clone, Debug)]
// TODO: Add option to easily 1. impersonate accounts, 2. roll back to pinned block
pub struct ForkMemoryBackend<M> {
/// ethers middleware for querying on-chain data
pub provider: BlockingProvider<M>,
/// the global context of the chain
pub vicinity: MemoryVicinity,
/// state cache
// TODO: This should probably be abstracted away into something that efficiently
// also caches at disk etc.
pub state: BTreeMap<H160, MemoryAccount>,
}
impl<M: Middleware> ForkMemoryBackend<M> {
/// Create a new memory backend given a provider, an optional block to pin state
/// against and a state tree
pub fn new(provider: M, pin_block: Option<u64>, state: BTreeMap<H160, MemoryAccount>) -> Self {
let provider = BlockingProvider::new(provider);
let vicinity = provider
.vicinity(pin_block)
.expect("could not instantiate vicinity corresponding to upstream");
Self { provider, vicinity, state }
}
}
impl<M: Middleware> Backend for ForkMemoryBackend<M> {
fn gas_price(&self) -> U256 {
self.vicinity.gas_price
}
fn origin(&self) -> H160 {
self.vicinity.origin
}
fn block_hash(&self, number: U256) -> H256 {
if number >= self.vicinity.block_number ||
self.vicinity.block_number - number - U256::one() >=
U256::from(self.vicinity.block_hashes.len())
{
H256::default()
} else {
let index = (self.vicinity.block_number - number - U256::one()).as_usize();
self.vicinity.block_hashes[index]
}
}
fn block_number(&self) -> U256 {
self.vicinity.block_number
}
fn block_coinbase(&self) -> H160 {
self.vicinity.block_coinbase
}
fn block_timestamp(&self) -> U256 {
self.vicinity.block_timestamp
}
fn block_difficulty(&self) -> U256 {
self.vicinity.block_difficulty
}
fn block_gas_limit(&self) -> U256 {
self.vicinity.block_gas_limit
}
fn chain_id(&self) -> U256 {
self.vicinity.chain_id
}
fn exists(&self, address: H160) -> bool {
let mut exists = self.state.contains_key(&address);
// check non-zero balance
if !exists {
let balance = self
.provider
.get_balance(address, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default();
exists = balance != U256::zero();
}
// check non-zero nonce
if !exists {
let nonce = self
.provider
.get_transaction_count(address, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default();
exists = nonce != U256::zero();
}
// check non-empty code
if !exists {
let code = self
.provider
.get_code(address, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default();
exists = !code.0.is_empty();
}
exists
}
fn basic(&self, address: H160) -> Basic {
self.state
.get(&address)
.map(|a| Basic { balance: a.balance, nonce: a.nonce })
.unwrap_or_else(|| Basic {
balance: self
.provider
.get_balance(address, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default(),
nonce: self
.provider
.get_transaction_count(
address,
Some(self.vicinity.block_number.as_u64().into()),
)
.unwrap_or_default(),
})
}
fn code(&self, address: H160) -> Vec<u8> {
self.state.get(&address).map(|v| v.code.clone()).unwrap_or_else(|| {
self.provider
.get_code(address, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default()
.to_vec()
})
}
fn storage(&self, address: H160, index: H256) -> H256 {
if let Some(acct) = self.state.get(&address) {
if let Some(store_data) = acct.storage.get(&index) {
*store_data
} else {
self.provider
.get_storage_at(
address,
index,
Some(self.vicinity.block_number.as_u64().into()),
)
.unwrap_or_default()
}
} else {
self.provider
.get_storage_at(address, index, Some(self.vicinity.block_number.as_u64().into()))
.unwrap_or_default()
}
}
fn original_storage(&self, address: H160, index: H256) -> Option<H256> {
Some(self.storage(address, index))
}
}
#[cfg(test)]
mod tests {
use crate::{sputnik::Executor, test_helpers::COMPILED, Evm};
use ethers::{
providers::{Http, Provider},
types::Address,
};
use sputnik::Config;
use std::convert::TryFrom;
use super::*;
#[test]
fn forked_backend() {
let cfg = Config::istanbul();
let compiled = COMPILED.get("Greeter").expect("could not find contract");
let addr = "0x1000000000000000000000000000000000000000".parse().unwrap();
let provider = Provider::<Http>::try_from(
"https://mainnet.infura.io/v3/c60b0bb42f8a4c6481ecd229eddaca27",
)
.unwrap();
let backend = ForkMemoryBackend::new(provider, Some(13292465), Default::default());
let mut evm = Executor::new(12_000_000, &cfg, &backend);
evm.initialize_contracts(vec![(addr, compiled.runtime_bytecode.clone())]);
// call the setup function to deploy the contracts inside the test
let (res, _, _) = evm
.call::<U256, _>(
Address::zero(),
addr,
&dapp_utils::get_func("function time() public view returns (uint256)").unwrap(),
(),
0.into(),
)
.unwrap();
// https://etherscan.io/block/13292465
assert_eq!(res.as_u64(), 1632539668);
}
}
|
//! Types for working with errors.
use std::{error, fmt};
use std::ops::Deref;
/// A specialized `Result` typedef.
pub type Result<T = (), E = Error> = ::std::result::Result<T, E>;
/// The error structure used by the Parenchyma crate.
#[derive(Debug)]
pub struct Error {
kind: ErrorKind,
/// A boxed sendable, syncable `Error`.
inner: Option<Box<::std::error::Error + Send + Sync>>,
}
/// A set of general categories.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ErrorKind {
/// A framework-specific error.
///
/// Consider creating an framework-specific error by calling the `Error::from_framework`
/// function, rather than constructing an `Error` using this variant.
Framework(&'static str),
/// An error returned when attempting to access uninitialized memory.
UninitializedMemory,
/// Unable to drop the provided device because a memory allocation was not found for it.
AllocatedMemoryNotFoundForDevice,
/// An error occurred while attempting to synchronize memory.
MemorySynchronizationFailed,
/// A memory synchronization route was requested, but no available synchronization route was found.
NoAvailableSynchronizationRouteFound,
/// An error occurred while attempting to allocate memory.
MemoryAllocationFailed,
/// An error occurred while downcasting
MemoryDowncasting,
// MARK: - A set of tensor error categories
/// Maximum number of backing memories has been reached (`BitMap` - type alias for `u64`).
CapacityExceeded,
/// The tensor shape is incompatible with the shape of some data.
IncompatibleShape,
/// Invalid reshaped tensor size.
InvalidReshapedTensorSize,
/// Any error not part of this list.
Other,
/// A marker variant that tells the compiler that users of this enum cannot match
/// it exhaustively ([related RFC](https://github.com/rust-lang/rust/issues/32770)).
#[doc(hidden)]
_NonExhaustive,
}
impl ErrorKind {
fn as_str(&self) -> &'static str {
use self::ErrorKind::*;
match *self {
Framework(name) => name,
CapacityExceeded => "the maximum number of backing memories has been reached",
IncompatibleShape => "the tensor shape is incompatible with the shape of the data",
InvalidReshapedTensorSize => "size of the provided shape is not equal to the size of the current shape",
UninitializedMemory => "uninitialized memory",
AllocatedMemoryNotFoundForDevice => "memory allocation was not found for the provided device",
MemorySynchronizationFailed => "memory synchronization failed",
NoAvailableSynchronizationRouteFound => "no available memory synchronization route",
MemoryAllocationFailed => "memory allocation failed",
MemoryDowncasting => "something went wrong while downcasting",
Other => "other error",
_ => unreachable!(),
}
}
}
impl Error {
/// Creates a new error from a known kind of error as well as an arbitrary error error.
pub fn new<K, E>(kind: K, error: E) -> Error
where K: Into<ErrorKind>,
E: Into<Box<error::Error + Send + Sync>> {
Self::_new(kind.into(), Some(error.into()))
}
/// Returns a reference to the inner error wrapped by this error (if any).
pub fn get_ref(&self) -> Option<&(error::Error + Send + Sync + 'static)> {
match self.inner {
Some(ref error) => Some(error.deref()),
_ => None
}
}
/// Returns the corresponding `ErrorKind` for this error.
pub fn kind(&self) -> ErrorKind {
self.kind
}
}
impl Error {
// "De-generization" technique..
fn _new(kind: ErrorKind, error: Option<Box<error::Error + Send + Sync>>) -> Error {
Error { kind, inner: error }
}
}
impl fmt::Display for Error {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
write!(fmt, "{}", self.kind.as_str())
}
}
impl error::Error for Error {
fn description(&self) -> &str {
if let Some(ref error) = self.inner {
error.description()
} else {
self.kind.as_str()
}
}
fn cause(&self) -> Option<&error::Error> {
match self.inner {
Some(ref error) => error.cause(),
_ => None,
}
}
}
impl From<ErrorKind> for Error {
/// Creates a new error from a known kind of error
fn from(kind: ErrorKind) -> Error {
Error::_new(kind, None)
}
}
#[cfg(test)]
mod test {
use super::{Error, ErrorKind};
use std::{error, fmt};
#[test]
fn test_downcasting() {
#[derive(Debug)]
struct TestError;
impl fmt::Display for TestError { fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
Ok(())
}}
impl error::Error for TestError { fn description(&self) -> &str { "abc" } }
let err = Error::new(ErrorKind::Other, TestError);
assert!(err.get_ref().unwrap().is::<TestError>());
assert_eq!("abc", err.get_ref().unwrap().description());
}
} |
use crate::tests::util::{
create_multi_outputs_transaction, create_transaction, create_transaction_with_out_point,
gen_block, start_chain,
};
use ckb_chain_spec::consensus::Consensus;
use ckb_core::block::Block;
use ckb_core::block::BlockBuilder;
use ckb_core::cell::{BlockInfo, CellMetaBuilder, CellProvider, CellStatus, UnresolvableError};
use ckb_core::header::HeaderBuilder;
use ckb_core::script::Script;
use ckb_core::transaction::{CellInput, CellOutPoint, CellOutput, OutPoint, TransactionBuilder};
use ckb_core::{capacity_bytes, Bytes, Capacity};
use ckb_shared::error::SharedError;
use ckb_traits::ChainProvider;
use numext_fixed_uint::U256;
use std::sync::Arc;
#[test]
fn test_genesis_transaction_spend() {
let tx = TransactionBuilder::default()
.input(CellInput::new(OutPoint::null(), 0))
.outputs(vec![
CellOutput::new(
capacity_bytes!(100_000_000),
Bytes::default(),
Script::default(),
None
);
100
])
.build();
let mut root_hash = tx.hash().to_owned();
let genesis_tx_hash = root_hash.clone();
let genesis_block = BlockBuilder::default()
.transaction(tx)
.header_builder(HeaderBuilder::default().difficulty(U256::from(1000u64)))
.build();
let consensus = Consensus::default().set_genesis_block(genesis_block);
let (chain_controller, shared) = start_chain(Some(consensus));
let end = 21;
let mut blocks1: Vec<Block> = vec![];
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for i in 1..end {
let difficulty = parent.difficulty().to_owned();
let tx = create_transaction(&root_hash, i as u8);
root_hash = tx.hash().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(1u64),
vec![tx],
vec![],
vec![],
);
blocks1.push(new_block.clone());
parent = new_block.header().to_owned();
}
for block in &blocks1[0..10] {
assert!(chain_controller
.process_block(Arc::new(block.clone()), false)
.is_ok());
}
assert_eq!(
shared
.lock_chain_state()
.cell(&OutPoint::new_cell(genesis_tx_hash, 0)),
CellStatus::Dead
);
}
#[test]
fn test_transaction_spend_in_same_block() {
let (chain_controller, shared) = start_chain(None);
let mut chain: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
let last_cell_base = &chain.last().unwrap().transactions()[0];
let last_cell_base_hash = last_cell_base.hash().to_owned();
let tx1 = create_multi_outputs_transaction(&last_cell_base, vec![0], 2, vec![1]);
let tx1_hash = tx1.hash().to_owned();
let tx2 = create_multi_outputs_transaction(&tx1, vec![0], 2, vec![2]);
let tx2_hash = tx2.hash().to_owned();
let tx2_output = tx2.outputs()[0].clone();
let txs = vec![tx1, tx2];
for hash in &[&last_cell_base_hash, &tx1_hash, &tx2_hash] {
assert_eq!(
shared
.lock_chain_state()
.cell(&OutPoint::new_cell(hash.to_owned().to_owned(), 0)),
CellStatus::Unknown
);
}
// proposal txs
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
txs.clone(),
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// empty N+1 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit txs in N+2 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
txs.clone(),
vec![],
vec![],
);
chain.push(new_block);
}
for block in &chain {
chain_controller
.process_block(Arc::new(block.clone()), true)
.expect("process block ok");
}
// assert last_cell_base_hash is full dead
assert_eq!(
shared
.lock_chain_state()
.cell(&OutPoint::new_cell(last_cell_base_hash.to_owned(), 0)),
CellStatus::Unknown
);
assert_eq!(
shared
.lock_chain_state()
.cell(&OutPoint::new_cell(tx1_hash.to_owned(), 0)),
CellStatus::Dead
);
assert_eq!(
shared
.lock_chain_state()
.cell(&OutPoint::new_cell(tx2_hash.to_owned(), 0)),
CellStatus::live_cell(
CellMetaBuilder::default()
.out_point(CellOutPoint {
tx_hash: tx2_hash.to_owned(),
index: 0
})
.data_hash(tx2_output.data_hash())
.capacity(tx2_output.capacity)
.block_info(BlockInfo::new(4, 0))
.build()
)
);
}
#[test]
fn test_transaction_conflict_in_same_block() {
let (chain_controller, shared) = start_chain(None);
let mut chain: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
let last_cell_base = &chain.last().unwrap().transactions()[0];
let tx1 = create_transaction(last_cell_base.hash(), 1);
let tx1_hash = tx1.hash().to_owned();
let tx2 = create_transaction(&tx1_hash, 2);
let tx3 = create_transaction(&tx1_hash, 3);
let txs = vec![tx1, tx2, tx3];
// proposal txs
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
txs.clone(),
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// empty N+1 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit txs in N+2 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
txs.clone(),
vec![],
vec![],
);
chain.push(new_block);
}
for block in chain.iter().take(3) {
chain_controller
.process_block(Arc::new(block.clone()), true)
.expect("process block ok");
}
assert_eq!(
SharedError::UnresolvableTransaction(UnresolvableError::Dead(OutPoint::new_cell(
tx1_hash.to_owned(),
0
))),
chain_controller
.process_block(Arc::new(chain[3].clone()), true)
.unwrap_err()
.downcast()
.unwrap()
);
}
#[test]
fn test_transaction_conflict_in_different_blocks() {
let (chain_controller, shared) = start_chain(None);
let mut chain: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
let last_cell_base = &chain.last().unwrap().transactions()[0];
let tx1 = create_multi_outputs_transaction(&last_cell_base, vec![0], 2, vec![1]);
let tx1_hash = tx1.hash();
let tx2 = create_multi_outputs_transaction(&tx1, vec![0], 2, vec![1]);
let tx3 = create_multi_outputs_transaction(&tx1, vec![0], 2, vec![2]);
// proposal txs
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![tx1.clone(), tx2.clone(), tx3.clone()],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// empty N+1 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit tx1 and tx2 in N+2 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![tx1.clone(), tx2.clone()],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit tx3 in N+3 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![tx3.clone()],
vec![],
vec![],
);
chain.push(new_block);
}
for block in chain.iter().take(4) {
chain_controller
.process_block(Arc::new(block.clone()), true)
.expect("process block ok");
}
assert_eq!(
SharedError::UnresolvableTransaction(UnresolvableError::Dead(OutPoint::new_cell(
tx1_hash.to_owned(),
0
))),
chain_controller
.process_block(Arc::new(chain[4].clone()), true)
.unwrap_err()
.downcast()
.unwrap()
);
}
#[test]
fn test_invalid_out_point_index_in_same_block() {
let (chain_controller, shared) = start_chain(None);
let mut chain: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
let last_cell_base = &chain.last().unwrap().transactions()[0];
let tx1 = create_transaction(last_cell_base.hash(), 1);
let tx1_hash = tx1.hash().to_owned();
let tx2 = create_transaction(&tx1_hash, 2);
// create an invalid OutPoint index
let tx3 = create_transaction_with_out_point(OutPoint::new_cell(tx1_hash.clone(), 1), 3);
let txs = vec![tx1, tx2, tx3];
// proposal txs
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
txs.clone(),
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// empty N+1 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit txs in N+2 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
txs.clone(),
vec![],
vec![],
);
chain.push(new_block);
}
for block in chain.iter().take(3) {
chain_controller
.process_block(Arc::new(block.clone()), true)
.expect("process block ok");
}
assert_eq!(
SharedError::UnresolvableTransaction(UnresolvableError::Unknown(vec![OutPoint::new_cell(
tx1_hash.to_owned(),
1,
)])),
chain_controller
.process_block(Arc::new(chain[3].clone()), true)
.unwrap_err()
.downcast()
.unwrap()
);
}
#[test]
fn test_invalid_out_point_index_in_different_blocks() {
let (chain_controller, shared) = start_chain(None);
let mut chain: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
let last_cell_base = &chain.last().unwrap().transactions()[0];
let tx1 = create_transaction(last_cell_base.hash(), 1);
let tx1_hash = tx1.hash();
let tx2 = create_transaction(tx1_hash, 2);
// create an invalid OutPoint index
let tx3 = create_transaction_with_out_point(OutPoint::new_cell(tx1_hash.clone(), 1), 3);
// proposal txs
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![tx1.clone(), tx2.clone(), tx3.clone()],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// empty N+1 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit tx1 and tx2 in N+2 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![tx1.clone(), tx2.clone()],
vec![],
vec![],
);
parent = new_block.header().to_owned();
chain.push(new_block);
}
// commit tx3 in N+3 block
{
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![tx3.clone()],
vec![],
vec![],
);
chain.push(new_block);
}
for block in chain.iter().take(4) {
chain_controller
.process_block(Arc::new(block.clone()), true)
.expect("process block ok");
}
assert_eq!(
SharedError::UnresolvableTransaction(UnresolvableError::Unknown(vec![OutPoint::new_cell(
tx1_hash.to_owned(),
1,
)])),
chain_controller
.process_block(Arc::new(chain[4].clone()), true)
.unwrap_err()
.downcast()
.unwrap()
);
}
#[test]
fn test_genesis_transaction_fetch() {
let tx = TransactionBuilder::default()
.input(CellInput::new(OutPoint::null(), 0))
.outputs(vec![
CellOutput::new(
capacity_bytes!(100_000_000),
Bytes::default(),
Script::default(),
None
);
100
])
.build();
let root_hash = tx.hash().to_owned();
let genesis_block = BlockBuilder::default()
.transaction(tx)
.header_builder(HeaderBuilder::default().difficulty(U256::from(1000u64)))
.build();
let consensus = Consensus::default().set_genesis_block(genesis_block);
let (_chain_controller, shared) = start_chain(Some(consensus));
let out_point = OutPoint::new_cell(root_hash, 0);
let state = shared.lock_chain_state().cell(&out_point);
assert!(state.is_live());
}
#[test]
fn test_chain_fork_by_total_difficulty() {
let (chain_controller, shared) = start_chain(None);
let final_number = 20;
let mut chain1: Vec<Block> = Vec::new();
let mut chain2: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for _ in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
chain1.push(new_block.clone());
parent = new_block.header().to_owned();
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for i in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let j = if i > 10 { 110 } else { 99 };
let new_block = gen_block(
&parent,
difficulty + U256::from(j as u32),
vec![],
vec![],
vec![],
);
chain2.push(new_block.clone());
parent = new_block.header().to_owned();
}
for block in &chain1 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
for block in &chain2 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
assert_eq!(
shared.block_hash(8),
chain2.get(7).map(|b| b.header().hash().to_owned())
);
}
#[test]
fn test_chain_fork_by_hash() {
let (chain_controller, shared) = start_chain(None);
let final_number = 20;
let mut chain1: Vec<Block> = Vec::new();
let mut chain2: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for _ in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
chain1.push(new_block.clone());
parent = new_block.header().to_owned();
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for _ in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
chain2.push(new_block.clone());
parent = new_block.header().to_owned();
}
for block in &chain1 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
for block in &chain2 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
//if total_difficulty equal, we chose block which have smaller hash as best
assert!(chain1
.iter()
.zip(chain2.iter())
.all(|(a, b)| a.header().difficulty() == b.header().difficulty()));
let best = if chain1[(final_number - 2) as usize].header().hash()
< chain2[(final_number - 2) as usize].header().hash()
{
chain1
} else {
chain2
};
assert_eq!(
shared.block_hash(8),
best.get(7).map(|b| b.header().hash().to_owned())
);
assert_eq!(
shared.block_hash(19),
best.get(18).map(|b| b.header().hash().to_owned())
);
}
#[test]
fn test_chain_get_ancestor() {
let (chain_controller, shared) = start_chain(None);
let final_number = 20;
let mut chain1: Vec<Block> = Vec::new();
let mut chain2: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for _ in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
chain1.push(new_block.clone());
parent = new_block.header().to_owned();
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for _ in 1..final_number {
let difficulty = parent.difficulty().to_owned();
let new_block = gen_block(
&parent,
difficulty + U256::from(100u64),
vec![],
vec![],
vec![],
);
chain2.push(new_block.clone());
parent = new_block.header().to_owned();
}
for block in &chain1 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
for block in &chain2 {
chain_controller
.process_block(Arc::new(block.clone()), false)
.expect("process block ok");
}
assert_eq!(
*chain1[9].header(),
shared
.get_ancestor(&chain1.last().unwrap().header().hash(), 10)
.unwrap()
);
assert_eq!(
*chain2[9].header(),
shared
.get_ancestor(&chain2.last().unwrap().header().hash(), 10)
.unwrap()
);
}
#[test]
fn test_next_epoch_ext() {
let genesis_block = BlockBuilder::default()
.header_builder(HeaderBuilder::default().difficulty(U256::from(1000u64)))
.build();
let mut consensus = Consensus::default().set_genesis_block(genesis_block);
consensus.genesis_epoch_ext.set_length(400);
let epoch = consensus.genesis_epoch_ext.clone();
let (chain_controller, shared) = start_chain(Some(consensus.clone()));
let final_number = shared.consensus().genesis_epoch_ext().length();
let mut chain1: Vec<Block> = Vec::new();
let mut chain2: Vec<Block> = Vec::new();
let mut parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
let mut last_epoch = epoch.clone();
for _ in 1..final_number - 1 {
let epoch = shared
.next_epoch_ext(&last_epoch, &parent)
.unwrap_or(last_epoch);
let new_block = gen_block(&parent, epoch.difficulty().clone(), vec![], vec![], vec![]);
chain_controller
.process_block(Arc::new(new_block.clone()), false)
.expect("process block ok");
chain1.push(new_block.clone());
parent = new_block.header().clone();
last_epoch = epoch;
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
let mut last_epoch = epoch.clone();
for i in 1..final_number {
let epoch = shared
.next_epoch_ext(&last_epoch, &parent)
.unwrap_or(last_epoch);
let mut uncles = vec![];
if i < 26 {
uncles.push(chain1[i as usize].clone().into());
}
let new_block = gen_block(&parent, epoch.difficulty().clone(), vec![], vec![], uncles);
chain_controller
.process_block(Arc::new(new_block.clone()), false)
.expect("process block ok");
chain2.push(new_block.clone());
parent = new_block.header().clone();
last_epoch = epoch;
}
{
let chain_state = shared.lock_chain_state();
let tip = chain_state.tip_header().clone();
let total_uncles_count = shared.block_ext(&tip.hash()).unwrap().total_uncles_count;
assert_eq!(total_uncles_count, 25);
let epoch = shared
.next_epoch_ext(chain_state.current_epoch_ext(), &tip)
.unwrap();
// last_uncles_count 25
// last_epoch_length 400
// epoch_duration_target 14400000
// target_recip 20
// last_duration 7980000
// (Diff_last * o_last) / o
// (25 * 1000 * 20) / 400
assert_eq!(epoch.difficulty(), &U256::from(1250u64));
// ((Cu_last + Cm_last) * L * Cm_last) / ((u + 1) * Cu_last * L_last)
// ((25 + 400) * 14400000 * 400) / (( 20 + 1)* 25 * 7980000)
assert_eq!(epoch.length(), 584);
let consensus = shared.consensus();
let epoch_reward = consensus.epoch_reward();
let block_reward = Capacity::shannons(epoch_reward.as_u64() / epoch.length());
let block_reward1 = block_reward.safe_add(Capacity::one()).unwrap();
let bound = 400 + epoch.remainder_reward().as_u64();
// block_reward 428082191780
// remainder_reward 960
assert_eq!(
epoch.block_reward(400).unwrap(),
block_reward1, // Capacity::shannons(428082191781)
"block_reward {:?}, remainder_reward{:?}",
block_reward,
epoch.remainder_reward()
);
assert_eq!(
epoch.block_reward(bound - 1).unwrap(),
block_reward1 // Capacity::shannons(428082191781)
);
assert_eq!(
epoch.block_reward(bound).unwrap(),
block_reward // Capacity::shannons(428082191780)
);
}
let (chain_controller, shared) = start_chain(Some(consensus.clone()));
let mut chain2: Vec<Block> = Vec::new();
for i in 1..final_number - 1 {
chain_controller
.process_block(Arc::new(chain1[(i - 1) as usize].clone()), false)
.expect("process block ok");
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
for i in 1..final_number {
let epoch = shared
.next_epoch_ext(&last_epoch, &parent)
.unwrap_or(last_epoch);
let mut uncles = vec![];
if i < 11 {
uncles.push(chain1[i as usize].clone().into());
}
let new_block = gen_block(&parent, epoch.difficulty().clone(), vec![], vec![], uncles);
chain_controller
.process_block(Arc::new(new_block.clone()), false)
.expect("process block ok");
chain2.push(new_block.clone());
parent = new_block.header().clone();
last_epoch = epoch;
}
{
let chain_state = shared.lock_chain_state();
let tip = chain_state.tip_header().clone();
let total_uncles_count = shared.block_ext(&tip.hash()).unwrap().total_uncles_count;
assert_eq!(total_uncles_count, 10);
let epoch = shared
.next_epoch_ext(chain_state.current_epoch_ext(), &tip)
.unwrap();
assert_eq!(epoch.difficulty(), &U256::from(1000u64));
}
let (chain_controller, shared) = start_chain(Some(consensus.clone()));
let mut chain2: Vec<Block> = Vec::new();
for i in 1..final_number - 1 {
chain_controller
.process_block(Arc::new(chain1[(i - 1) as usize].clone()), false)
.expect("process block ok");
}
parent = shared.block_header(&shared.block_hash(0).unwrap()).unwrap();
let mut last_epoch = epoch.clone();
for i in 1..final_number {
let epoch = shared
.next_epoch_ext(&last_epoch, &parent)
.unwrap_or(last_epoch);
let mut uncles = vec![];
if i < 151 {
uncles.push(chain1[i as usize].clone().into());
}
let new_block = gen_block(&parent, epoch.difficulty().clone(), vec![], vec![], uncles);
chain_controller
.process_block(Arc::new(new_block.clone()), false)
.expect("process block ok");
chain2.push(new_block.clone());
parent = new_block.header().clone();
last_epoch = epoch;
}
{
let chain_state = shared.lock_chain_state();
let tip = chain_state.tip_header().clone();
let total_uncles_count = shared.block_ext(&tip.hash()).unwrap().total_uncles_count;
assert_eq!(total_uncles_count, 150);
let epoch = shared
.next_epoch_ext(chain_state.current_epoch_ext(), &tip)
.unwrap();
// max[150 * 10 * 1000 / 200, 2 * 1000]
assert_eq!(epoch.difficulty(), &U256::from(2000u64));
}
}
|
fn main() {
let input = std::fs::read_to_string("../input.txt").unwrap();
let count = input
.split("\n")
.filter(|s| {
if s.is_empty() {
return false;
}
let mut parts: Vec<&str> = s.split(": ").collect();
if parts.len() != 2 {
return false;
}
let policy = parts.remove(0);
let password = parts.remove(0);
let mut parts: Vec<&str> = policy.split(' ').collect();
if parts.len() != 2 {
return false;
}
let mut range: Vec<&str> = parts.remove(0).split('-').collect();
let c: char = parts.remove(0).chars().next().unwrap();
let low = range.remove(0);
let high = range.remove(0);
let low: usize = low.parse().unwrap();
let high: usize = high.parse().unwrap();
let count = password.chars().filter(|&ch| ch == c).count();
count >= low && count <= high
})
.count();
println!("{}", count);
}
|
#[doc = "Reader of register SW_CMP_P_SEL"]
pub type R = crate::R<u32, super::SW_CMP_P_SEL>;
#[doc = "Writer for register SW_CMP_P_SEL"]
pub type W = crate::W<u32, super::SW_CMP_P_SEL>;
#[doc = "Register SW_CMP_P_SEL `reset()`'s with value 0"]
impl crate::ResetValue for super::SW_CMP_P_SEL {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0
}
}
#[doc = "Reader of field `SW_SFPM`"]
pub type SW_SFPM_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `SW_SFPM`"]
pub struct SW_SFPM_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFPM_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x07) | ((value as u32) & 0x07);
self.w
}
}
#[doc = "Reader of field `SW_SFPT`"]
pub type SW_SFPT_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `SW_SFPT`"]
pub struct SW_SFPT_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFPT_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07 << 4)) | (((value as u32) & 0x07) << 4);
self.w
}
}
#[doc = "Reader of field `SW_SFPS`"]
pub type SW_SFPS_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `SW_SFPS`"]
pub struct SW_SFPS_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFPS_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x07 << 8)) | (((value as u32) & 0x07) << 8);
self.w
}
}
#[doc = "Reader of field `SW_SFMA`"]
pub type SW_SFMA_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SW_SFMA`"]
pub struct SW_SFMA_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFMA_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
self.w
}
}
#[doc = "Reader of field `SW_SFMB`"]
pub type SW_SFMB_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SW_SFMB`"]
pub struct SW_SFMB_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFMB_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "Reader of field `SW_SFCA`"]
pub type SW_SFCA_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SW_SFCA`"]
pub struct SW_SFCA_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFCA_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
self.w
}
}
#[doc = "Reader of field `SW_SFCB`"]
pub type SW_SFCB_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `SW_SFCB`"]
pub struct SW_SFCB_W<'a> {
w: &'a mut W,
}
impl<'a> SW_SFCB_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
self.w
}
}
impl R {
#[doc = "Bits 0:2 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfpm(&self) -> SW_SFPM_R {
SW_SFPM_R::new((self.bits & 0x07) as u8)
}
#[doc = "Bits 4:6 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfpt(&self) -> SW_SFPT_R {
SW_SFPT_R::new(((self.bits >> 4) & 0x07) as u8)
}
#[doc = "Bits 8:10 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfps(&self) -> SW_SFPS_R {
SW_SFPS_R::new(((self.bits >> 8) & 0x07) as u8)
}
#[doc = "Bit 12 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfma(&self) -> SW_SFMA_R {
SW_SFMA_R::new(((self.bits >> 12) & 0x01) != 0)
}
#[doc = "Bit 16 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfmb(&self) -> SW_SFMB_R {
SW_SFMB_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bit 20 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfca(&self) -> SW_SFCA_R {
SW_SFCA_R::new(((self.bits >> 20) & 0x01) != 0)
}
#[doc = "Bit 24 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfcb(&self) -> SW_SFCB_R {
SW_SFCB_R::new(((self.bits >> 24) & 0x01) != 0)
}
}
impl W {
#[doc = "Bits 0:2 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfpm(&mut self) -> SW_SFPM_W {
SW_SFPM_W { w: self }
}
#[doc = "Bits 4:6 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfpt(&mut self) -> SW_SFPT_W {
SW_SFPT_W { w: self }
}
#[doc = "Bits 8:10 - Select waveform for corresponding switch"]
#[inline(always)]
pub fn sw_sfps(&mut self) -> SW_SFPS_W {
SW_SFPS_W { w: self }
}
#[doc = "Bit 12 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfma(&mut self) -> SW_SFMA_W {
SW_SFMA_W { w: self }
}
#[doc = "Bit 16 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfmb(&mut self) -> SW_SFMB_W {
SW_SFMB_W { w: self }
}
#[doc = "Bit 20 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfca(&mut self) -> SW_SFCA_W {
SW_SFCA_W { w: self }
}
#[doc = "Bit 24 - Set corresponding switch"]
#[inline(always)]
pub fn sw_sfcb(&mut self) -> SW_SFCB_W {
SW_SFCB_W { w: self }
}
}
|
fn increment_power(power: i32) -> i32 {
println!("My power is going to increase:");
power + 1
}
fn main() {
let power = increment_power(1);
println!("My power level is now: {}", power);
}
|
#[macro_export]
macro_rules! assert_ts_eq {
($lhs:expr, $rhs:expr) => {{
let lhs: TokenStream = $lhs;
let rhs: TokenStream = $rhs;
if lhs.to_string() != rhs.to_string() {
panic!(
r#"assertion failed: `(left == right)`
left:
```
{}
```
right: ```
{}
```
"#,
synstructure::unpretty_print(&lhs),
synstructure::unpretty_print(&rhs),
);
}
}};
($lhs:expr, $rhs:expr,) => {
assert_ts_eq!($lhs, $rhs)
};
}
|
// Copyright 2018-2019 Mozilla
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use
// this file except in compliance with the License. You may obtain a copy of the
// License at http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.
use super::ErrorImpl;
use crate::backend::traits::BackendIter;
pub struct IterImpl<'i, C> {
// LMDB semantics dictate that a cursor must be valid for the entire lifetime
// of an iterator. In other words, cursors must not be dropped while an
// iterator built from it is alive. Unfortunately, the LMDB crate API does
// not express this through the type system, so we must enforce it somehow.
#[allow(dead_code)]
cursor: C,
iter: lmdb::Iter<'i>,
}
impl<'i, C> IterImpl<'i, C> {
pub(crate) fn new(
mut cursor: C,
to_iter: impl FnOnce(&mut C) -> lmdb::Iter<'i>,
) -> IterImpl<'i, C> {
let iter = to_iter(&mut cursor);
IterImpl { cursor, iter }
}
}
impl<'i, C> BackendIter<'i> for IterImpl<'i, C> {
type Error = ErrorImpl;
#[allow(clippy::type_complexity)]
fn next(&mut self) -> Option<Result<(&'i [u8], &'i [u8]), Self::Error>> {
self.iter.next().map(|e| e.map_err(ErrorImpl::LmdbError))
}
}
|
use num_enum::TryFromPrimitive;
use strum_macros::Display;
use super::chunk::Chunk;
#[derive(Debug, Eq, PartialEq, TryFromPrimitive, Display)]
#[repr(u8)]
pub enum OpCode {
Constant,
Nil,
True,
False,
Pop,
GetLocal,
SetLocal,
GetGlobal,
DefineGlobal,
SetGlobal,
Equal,
Greater,
Less,
Add,
Subtract,
Multiply,
Divide,
Not,
Negate,
Print,
Jump,
JumpIfFalse,
Loop,
Return,
}
impl OpCode {
pub fn simple_instruction(&self, offset: usize) -> usize {
println!("{}", self);
offset + 1
}
pub fn constant_instruction(&self, chunk: &Chunk, offset: usize) -> usize {
let constant = chunk.code[offset + 1] as usize;
println!(
"{:16} {:4} '{:?}'",
format!("{}", self),
constant,
chunk.constant(constant)
);
offset + 2
}
pub fn byte_instruction(&self, chunk: &Chunk, offset: usize) -> usize {
let slot = chunk.code[offset + 1];
println!("{:16} {:4}", format!("{}", self), slot);
offset + 2
}
pub fn jump_instruction(&self, sign: i32, chunk: &Chunk, offset: usize) -> usize {
let mut jump = (chunk.code[offset + 1] as u16) << 8;
jump |= chunk.code[offset + 2] as u16;
println!(
"{:16} {:4} -> {}",
format!("{}", self),
offset,
(offset as i32) + 3 + sign * (jump as i32)
);
offset + 3
}
}
|
type FsmIndex = usize;
const FSM_COLUMN_SIZE: usize = 130;
const FSM_LINEEND: FsmIndex = 129;
#[derive(Default, Clone, Copy)]
struct FsmAction {
next: FsmIndex,
offset: i32,
}
#[derive(Clone)]
struct FsmColumn {
ts: [FsmAction; FSM_COLUMN_SIZE],
}
impl FsmColumn {
fn new() -> Self {
Self {
ts: [Default::default(); FSM_COLUMN_SIZE]
}
}
}
struct Regex {
cs: Vec<FsmColumn>
}
#[derive(Debug, Copy, Clone)]
enum Atom {
Any,
EndLine,
Char(char),
}
#[derive(Debug)]
enum Token {
Atom(Atom),
Star(Atom),
}
fn lexer(src: &str) -> Vec<Token> {
let bytes = src.as_bytes();
let mut result = Vec::new();
let mut i = 0;
while i < bytes.len() {
let atom = match bytes[i] as char {
'.' => Atom::Any,
'$' => Atom::EndLine,
'*' | '+' => panic!("Invalid target for quantifier"),
x => Atom::Char(x),
};
i += 1;
match bytes.get(i).map(|x| *x as char) {
Some('*') => {
i += 1;
result.push(Token::Star(atom));
}
Some('+') => {
i += 1;
result.push(Token::Atom(atom));
result.push(Token::Star(atom));
}
_ => {
result.push(Token::Atom(atom));
}
};
}
result
}
fn compile_atom(atom: &Atom, success: FsmIndex) -> FsmColumn {
use Atom::*;
let mut column = FsmColumn::new();
match atom {
Any => {
for i in 32..127 {
column.ts[i] = FsmAction {
next: success,
offset: 1,
};
}
},
EndLine => {
column.ts[FSM_LINEEND] = FsmAction {
next: success,
offset: 1,
};
}
Char(x) => {
column.ts[*x as usize] = FsmAction {
next: success,
offset: 1,
};
}
}
column
}
impl Regex {
fn compile(src: &str) -> Self {
let tokens = lexer(src);
let mut fsm = Self { cs: Vec::new() };
fsm.cs.push(FsmColumn::new()); // default failed state
for token in tokens.iter() {
let current_state = fsm.cs.len();
let next_state = fsm.cs.len() + 1;
match token {
Token::Atom(atom) => {
let column = compile_atom(atom, next_state);
fsm.cs.push(column);
},
Token::Star(atom) => {
let mut column = compile_atom(atom, current_state);
for action in column.ts.iter_mut() {
if action.next == 0 {
action.next = next_state;
} else {
assert!(action.next == current_state);
}
}
fsm.cs.push(column);
}
}
}
fsm
}
fn match_str(&self, input: &str) -> bool {
let mut state = 1;
let mut head = 0;
let chars = input.chars().collect::<Vec<_>>();
let n = chars.len();
while 0 < state && state < self.cs.len() && head < n {
let action = self.cs[state].ts[chars[head] as usize];
state = action.next;
head = (head as i32 + action.offset) as usize;
}
if state == 0 {
return false;
}
if state < self.cs.len() {
let action = self.cs[state].ts[FSM_LINEEND];
state = action.next;
}
return state >= self.cs.len();
}
#[allow(dead_code)]
fn dump(&self) {
for symbol in 0..FSM_COLUMN_SIZE {
print!("{:03} => ", symbol);
for column in self.cs.iter() {
print!("({}, {}) ",
column.ts[symbol].next,
column.ts[symbol].offset);
}
println!();
}
}
}
fn test_regex(regex_src: &str, test_cases: &[(&str, bool)]) {
let regex = Regex::compile(regex_src);
println!("Testing {:?}", regex_src);
for (input, expected_outcome) in test_cases {
println!(" input: {:?}", input);
println!(" match: {:?}", *expected_outcome);
assert_eq!(regex.match_str(input), *expected_outcome);
println!();
}
}
fn main() {
let tests = vec!{
("a+bc$", vec![
("Hello, World", false),
("bc", false),
("abc", true),
("aabc", true),
("aaabc", true),
("bbc", false),
("cbc", false),
("cbd", false),
("cbt", false),
("abcd", false),
], false),
(".*bc", vec![
("bc", true),
("abc", true),
("aabc", true),
], true),
};
for (regex_src, test_cases, ignored) in tests.iter() {
if !ignored {
test_regex(regex_src, &test_cases);
}
}
} |
use crate::colors::{BLACK, BRIGHT_GRAY, GRAY, GREEN};
use crate::{LinePart, ARROW_SEPARATOR};
use ansi_term::{ANSIStrings, Style};
pub fn active_tab(text: String) -> LinePart {
let left_separator = Style::new().fg(GRAY).on(GREEN).paint(ARROW_SEPARATOR);
let tab_text_len = text.chars().count() + 4; // 2 for left and right separators, 2 for the text padding
let tab_styled_text = Style::new()
.fg(BLACK)
.on(GREEN)
.bold()
.paint(format!(" {} ", text));
let right_separator = Style::new().fg(GREEN).on(GRAY).paint(ARROW_SEPARATOR);
let tab_styled_text = format!(
"{}",
ANSIStrings(&[left_separator, tab_styled_text, right_separator,])
);
LinePart {
part: tab_styled_text,
len: tab_text_len,
}
}
pub fn non_active_tab(text: String) -> LinePart {
let left_separator = Style::new().fg(GRAY).on(BRIGHT_GRAY).paint(ARROW_SEPARATOR);
let tab_text_len = text.chars().count() + 4; // 2 for left and right separators, 2 for the padding
let tab_styled_text = Style::new()
.fg(BLACK)
.on(BRIGHT_GRAY)
.bold()
.paint(format!(" {} ", text));
let right_separator = Style::new().fg(BRIGHT_GRAY).on(GRAY).paint(ARROW_SEPARATOR);
let tab_styled_text = format!(
"{}",
ANSIStrings(&[left_separator, tab_styled_text, right_separator,])
);
LinePart {
part: tab_styled_text,
len: tab_text_len,
}
}
pub fn tab_style(text: String, is_active_tab: bool, position: usize) -> LinePart {
let tab_text = if text.is_empty() {
format!("Tab #{}", position + 1)
} else {
text
};
if is_active_tab {
active_tab(tab_text)
} else {
non_active_tab(tab_text)
}
}
|
extern crate tokio;
use tokio::io;
use tokio::executor::thread_pool::ThreadPool;
use tokio::prelude::*;
struct Server {
lst_socks: Vec<tokio::net::TcpListener>,
clients: Vec<tokio::net::TcpStream>,
}
fn main() {
// Create a thread pool with default configuration values
let thread_pool = ThreadPool::new();
let listen_addr = "0.0.0.0:2435".parse().unwrap();
let mut serv = Server{
lst_socks: Vec::new(),
clients: Vec::new(),
};
serv.lst_socks.push(tokio::net::TcpListener::bind(&listen_addr).unwrap());
for lst_sock in serv.lst_socks {
thread_pool.spawn(lst_sock.incoming().for_each(|socket| {
println!("New connection: {:?}", socket.peer_addr().unwrap());
let message = "Ok\n";
let peer_write = io::write_all(socket, message)
.then(|res| {
// println!("Wrote {:?} bytes", message.len());
println!("Wrote {:?}", res.is_ok());
Ok(())
});
tokio::spawn(peer_write);
Ok(())
}).map_err(|err| {
println!("accept() error => {:?}", err);
}));
}
// Gracefully shutdown the threadpool
thread_pool.shutdown().wait().unwrap();
}
|
extern crate clap;
extern crate ldap3;
use clap::{App, Arg, SubCommand};
use ldap3::{LdapConn};
use std::collections::HashSet;
use std::iter::FromIterator;
fn main() {
let matches = App::new("navkafka-cli")
.version("0.1")
.author("Kevin Sillerud <kevin.sillerud@nav.no>")
.about("Application for doing operations against NAVs kafka environment")
.subcommand(SubCommand::with_name("ldap")
.about("Subcommand for doing ldap operations against the docker-compose kafka environment")
.arg(Arg::with_name("ldap-url")
.short("h")
.long("ldap-url")
.help("The url for the ldap server")
.default_value("ldap://localhost:10389")
)
.arg(Arg::with_name("bind-dn")
.short("u")
.long("bind-dn")
.help("dn string to use for bind")
.default_value("cn=igroup,ou=ServiceAccounts,dc=test,dc=local")
)
.arg(Arg::with_name("bind-password")
.short("p")
.long("bind-password")
.help("Password to use for binding against ldap")
.default_value("itest")
)
.subcommand(SubCommand::with_name("useradd")
.about("Add a user")
.arg(Arg::with_name("user-type")
.possible_values(&["SERVICE_USER", "PERSONAL_USER"])
.short("t")
.long("user-type")
.help("Define the type of user to add")
.default_value("SERVICE_USER")
)
.arg(Arg::with_name("username")
.required(true)
.index(1)
)
.arg(Arg::with_name("password")
.required(true)
.index(2)
)
)
)
.get_matches();
if let Some(ldap_command) = matches.subcommand_matches("ldap") {
let ldap_url = ldap_command.value_of("ldap-url").unwrap();
let bind_dn = ldap_command.value_of("bind-dn").unwrap();
let bind_password = ldap_command.value_of("bind-password").unwrap();
let ldap = LdapConn::new(ldap_url).expect("Failed to connect to LDAP server");
ldap.simple_bind(bind_dn, bind_password).unwrap();
if let Some(add_command) = ldap_command.subcommand_matches("useradd") {
let username = add_command.value_of("username").unwrap();
let password = add_command.value_of("password").unwrap();
let dn = if add_command.value_of("user-type").unwrap() == "SERVICE_USER" {
format!("cn={},ou=ApplAccounts,ou=ServiceAccounts,dc=test,dc=local", username)
} else {
format!("cn={},ou=Users,ou=NAV,ou=BusinessUnits,dc=test,dc=local", username)
};
println!("{}", dn);
ldap.add(dn.as_ref(), vec![
("objectClass", HashSet::from_iter(vec!["inetOrgPerson", "person", "organizationalPerson"])),
("cn", HashSet::from_iter(vec![username.as_ref()])),
("uid", HashSet::from_iter(vec![username.as_ref()])),
("sn", HashSet::from_iter(vec![username.as_ref()])),
("userPassword", HashSet::from_iter(vec![password]))
]).unwrap();
}
}
}
|
use regex::Regex;
pub trait IrcExt {
fn is_channel_name(&self) -> bool;
fn is_ctcp(&self) -> bool;
fn remove_colorization(&self) -> String;
}
impl<'a> IrcExt for &'a str {
fn is_channel_name(&self) -> bool {
return self.starts_with('#')
|| self.starts_with('&')
|| self.starts_with('+')
|| self.starts_with('!');
}
fn is_ctcp(&self) -> bool {
return self.starts_with('\u{1}');
}
fn remove_colorization(&self) -> String {
// https://stackoverflow.com/a/3504063
let re = Regex::new(r"\x1f|\x02|\x12|\x0f|\x16|\x03(?:\d{1,2}(?:,\d{1,2})?)?").unwrap();
let result = re.replace_all(self, "").to_string();
return result;
}
}
impl IrcExt for String {
fn is_channel_name(&self) -> bool {
return (&self[..]).is_channel_name();
}
fn is_ctcp(&self) -> bool {
return (&self[..]).is_ctcp();
}
fn remove_colorization(&self) -> String {
return (&self[..]).remove_colorization();
}
} |
fn get_int_from_file() -> Result<i32,String> {
let path = "input.txt";
let num_str = std::fs::read_to_string(path).map_err(|err| err.to_string())?;
num_str.trim().parse::<i32>().map(|t| t * 2).map_err(|err| err.to_string())
}
fn main() {
match get_int_from_file() {
Ok(x) => println!("{}",x),
Err(e) => println!("{}",e),
}
}
|
use crate::arch::sys::raw_syscall;
use crate::obj::{objid_split, ObjID};
const SYS_ATTACH: i64 = 4;
const SYS_BECOME: i64 = 6;
const SYS_THREAD_SYNC: i64 = 7;
const SYS_KCONF: i64 = 14;
const SYS_THRD_CTL: i64 = 10;
const SYS_INVL_KSO: i64 = 3;
const SYS_OCREATE: i64 = 21;
const SYS_KACTION: i64 = 11;
const SYS_KEC_READ: i64 = 22;
const SYS_KEC_WRITE: i64 = 23;
pub(crate) const THRD_CTL_EXIT: i32 = 0x100;
pub fn thrd_ctl(op: i32, arg: u64) -> i64 {
unsafe { raw_syscall(SYS_THRD_CTL, op as u64, arg, 0, 0, 0, 0) }
}
pub fn attach(pid: ObjID, cid: ObjID, flags: i32, ty: i32) -> i64 {
let (pid_hi, pid_lo) = objid_split(pid);
let (cid_hi, cid_lo) = objid_split(cid);
let sf = (ty & 0xffff) as u64 | (flags as u64) << 32;
unsafe { raw_syscall(SYS_ATTACH, pid_lo, pid_hi, cid_lo, cid_hi, sf, 0) }
}
pub const KCONF_RDRESET: u64 = 1;
pub const KCONF_ARCH_TSC_PSPERIOD: u64 = 1001;
pub fn kconf(cmd: u64, arg: u64) -> i64 {
unsafe { raw_syscall(SYS_KCONF, cmd, arg, 0, 0, 0, 0) }
}
crate::bitflags! {
pub struct KECReadFlags : u32 {
const KEC_READ_NONBLOCK = 1;
}
}
pub fn kec_read(buffer: &mut [u8], flags: KECReadFlags) -> Result<&mut [u8], u64> {
let result = unsafe {
raw_syscall(
SYS_KEC_READ,
buffer.as_ptr() as u64,
buffer.len() as u64,
flags.bits() as u64,
0,
0,
0,
)
};
if result < 0 {
Err(-result as u64)
} else {
Ok(&mut buffer[0..result as usize])
}
}
crate::bitflags! {
pub struct KECWriteFlags : u32 {
const KEC_WRITE_DISCARD_ON_FULL = 1;
}
}
pub fn kec_write(buffer: &[u8], flags: KECWriteFlags) -> Result<(), u64> {
let result = unsafe {
raw_syscall(
SYS_KEC_WRITE,
buffer.as_ptr() as u64,
buffer.len() as u64,
flags.bits() as u64,
0,
0,
0,
)
};
if result < 0 {
Err(-result as u64)
} else {
Ok(())
}
}
#[allow(dead_code)]
pub struct ThreadSyncArgs {
addr: *const std::sync::atomic::AtomicU64,
arg: u64,
res: u64,
__resv: u64,
op: u32,
flags: u32,
}
impl ThreadSyncArgs {
pub fn new_sleep(addr: &std::sync::atomic::AtomicU64, val: u64) -> ThreadSyncArgs {
ThreadSyncArgs {
addr: addr as *const std::sync::atomic::AtomicU64,
arg: val,
op: 0,
flags: 0,
__resv: 0,
res: 0,
}
}
pub fn new_wake(addr: &std::sync::atomic::AtomicU64, count: u64) -> ThreadSyncArgs {
ThreadSyncArgs {
addr: addr as *const std::sync::atomic::AtomicU64,
arg: count,
op: 1,
flags: 0,
__resv: 0,
res: 0,
}
}
}
#[repr(C, align(16))]
pub(crate) struct InvalidateOp {
id: ObjID,
offset: u64,
length: u32,
flags: u16,
result: u16,
}
pub(crate) enum InvalidateCurrent {
View = 0,
}
const KSOI_VALID: u16 = 1;
const KSOI_CURRENT: u16 = 2;
impl InvalidateOp {
pub(crate) fn new_current(which: InvalidateCurrent, offset: u64, length: u32) -> InvalidateOp {
InvalidateOp {
id: which as u128,
offset: offset,
length: length,
flags: KSOI_VALID | KSOI_CURRENT,
result: 0,
}
}
}
pub(crate) fn invalidate(specs: &mut [InvalidateOp]) -> i64 {
unsafe { raw_syscall(SYS_INVL_KSO, specs.as_ptr() as u64, specs.len() as u64, 0, 0, 0, 0) }
}
#[repr(C, align(16))]
pub(crate) struct KactionOp {
id: ObjID,
result: i64,
cmd: i64,
arg: i64,
flags: i64,
}
const KACTION_VALID: i64 = 1;
impl KactionOp {
pub(crate) fn new(id: ObjID, cmd: i64, arg: i64) -> KactionOp {
KactionOp {
id,
result: 0,
cmd,
arg,
flags: KACTION_VALID,
}
}
pub(crate) fn result(&self) -> i64 {
self.result
}
}
pub(crate) fn kaction(ops: &mut [KactionOp]) -> i64 {
unsafe { raw_syscall(SYS_KACTION, ops.len() as u64, ops.as_ptr() as u64, 0, 0, 0, 0) }
}
#[repr(C)]
pub struct KernelTimeSpec {
pub sec: u64,
pub nsec: u64,
}
impl From<std::time::Duration> for KernelTimeSpec {
fn from(dur: std::time::Duration) -> KernelTimeSpec {
KernelTimeSpec {
sec: dur.as_secs(),
nsec: dur.subsec_nanos() as u64,
}
}
}
pub fn thread_sync(specs: &mut [ThreadSyncArgs], timeout: Option<std::time::Duration>) -> i64 {
let timespec: Option<KernelTimeSpec> = timeout.map(|t| t.into());
let to = if let Some(timespec) = timespec {
(×pec) as *const KernelTimeSpec
} else {
std::ptr::null()
};
unsafe { raw_syscall(SYS_THREAD_SYNC, specs.len() as u64, specs.as_ptr() as u64, to as u64, 0, 0, 0) }
}
#[derive(Default)]
#[repr(C)]
pub struct BecomeArgs {
pub target_view: u128,
pub target_rip: u64,
pub rax: i64,
pub rbx: i64,
pub rcx: i64,
pub rdx: i64,
pub rdi: i64,
pub rsi: i64,
pub rsp: i64,
pub rbp: i64,
pub r8: i64,
pub r9: i64,
pub r10: i64,
pub r11: i64,
pub r12: i64,
pub r13: i64,
pub r14: i64,
pub r15: i64,
pub sctx_hint: u128,
}
/* TODO: move this to arch-specific */
pub unsafe fn r#become(args: *const BecomeArgs, arg0: i64, arg1: i64) -> Result<BecomeArgs, i64> {
let mut num: i64 = SYS_BECOME;
let mut rdi = std::mem::transmute::<*const BecomeArgs, i64>(args);
let mut rsi = arg0;
let mut rdx = arg1;
let mut r8: i64;
let mut r9: i64;
let mut r10: i64;
asm!("syscall",
inout("rax") num,
inout("rdi") rdi,
inout("rsi") rsi,
inout("rdx") rdx,
out("r10") r10,
out("r8") r8,
out("r9") r9,
out("r11") _,
out("rcx") _);
if num < 0 {
return Err(num);
}
Ok(BecomeArgs {
rdi: rdi,
rsi: rsi,
rdx: rdx,
r10: r10,
r8: r8,
r9: r9,
..Default::default()
})
}
#[repr(C, align(16))]
pub(crate) struct KernelCreateSpec {
result: ObjID,
ku: ObjID,
srcs: *const KernelCreateSrc,
srcs_len: u64,
ties: *const ObjID,
ties_len: u64,
flags: u32,
backing_type: u16,
lifetime: u16,
}
#[repr(C, align(16))]
struct KernelCreateSrc {
id: ObjID,
start: u64,
length: u64,
}
use crate::obj::{CreateSpec, KuSpec, TieSpec};
pub(crate) fn create(spec: &CreateSpec) -> Result<ObjID, u64> {
let kuid = if let KuSpec::Obj(id) = spec.ku { id } else { 0 };
let srcs: Vec<KernelCreateSrc> = spec
.srcs
.iter()
.map(|src| KernelCreateSrc {
id: src.srcid,
start: src.start,
length: src.length,
})
.collect();
let ties: Vec<ObjID> = spec
.ties
.iter()
.map(|tie| {
if let TieSpec::Obj(id) = tie {
*id
} else {
crate::kso::view::View::current().id()
}
})
.collect();
let mut ks = KernelCreateSpec {
result: 0,
ku: kuid,
srcs: (&srcs).as_ptr(),
srcs_len: srcs.len() as u64,
ties: (&ties).as_ptr(),
ties_len: ties.len() as u64,
flags: spec.flags.bits() as u32,
backing_type: spec.bt as u16,
lifetime: spec.lt as u16,
};
let res = unsafe { raw_syscall(SYS_OCREATE, (&mut ks as *mut KernelCreateSpec) as u64, 0, 0, 0, 0, 0) };
if res < 0 {
Err(-res as u64)
} else {
Ok(ks.result)
}
}
|
#![doc = "generated by AutoRust 0.1.0"]
#[cfg(feature = "package-2020-09")]
mod package_2020_09;
#[cfg(feature = "package-2020-09")]
pub use package_2020_09::{models, operations, API_VERSION};
#[cfg(feature = "package-2020-06-preview")]
mod package_2020_06_preview;
#[cfg(feature = "package-2020-06-preview")]
pub use package_2020_06_preview::{models, operations, API_VERSION};
#[cfg(feature = "package-2020-04")]
mod package_2020_04;
#[cfg(feature = "package-2020-04")]
pub use package_2020_04::{models, operations, API_VERSION};
#[cfg(feature = "package-2020-03")]
mod package_2020_03;
#[cfg(feature = "package-2020-03")]
pub use package_2020_03::{models, operations, API_VERSION};
#[cfg(feature = "package-2019-12")]
mod package_2019_12;
#[cfg(feature = "package-2019-12")]
pub use package_2019_12::{models, operations, API_VERSION};
#[cfg(feature = "package-2019-08")]
mod package_2019_08;
#[cfg(feature = "package-2019-08")]
pub use package_2019_08::{models, operations, API_VERSION};
#[cfg(feature = "package-2019-08-preview")]
mod package_2019_08_preview;
#[cfg(feature = "package-2019-08-preview")]
pub use package_2019_08_preview::{models, operations, API_VERSION};
#[cfg(feature = "package-2015-04")]
mod package_2015_04;
#[cfg(feature = "package-2015-04")]
pub use package_2015_04::{models, operations, API_VERSION};
#[cfg(feature = "package-2014-04")]
mod package_2014_04;
#[cfg(feature = "package-2014-04")]
pub use package_2014_04::{models, operations, API_VERSION};
#[cfg(feature = "package-2015-11")]
mod package_2015_11;
#[cfg(feature = "package-2015-11")]
pub use package_2015_11::{models, operations, API_VERSION};
#[cfg(feature = "package-2016-03-19")]
mod package_2016_03_19;
#[cfg(feature = "package-2016-03-19")]
pub use package_2016_03_19::{models, operations, API_VERSION};
#[cfg(feature = "package-2016-03-31")]
mod package_2016_03_31;
#[cfg(feature = "package-2016-03-31")]
pub use package_2016_03_31::{models, operations, API_VERSION};
pub struct OperationConfig {
pub api_version: String,
pub client: reqwest::Client,
pub base_path: String,
pub token_credential: Option<Box<dyn azure_core::TokenCredential>>,
pub token_credential_resource: String,
}
impl OperationConfig {
pub fn new(token_credential: Box<dyn azure_core::TokenCredential>) -> Self {
Self {
token_credential: Some(token_credential),
..Default::default()
}
}
}
impl Default for OperationConfig {
fn default() -> Self {
Self {
api_version: API_VERSION.to_owned(),
client: reqwest::Client::new(),
base_path: "https://management.azure.com".to_owned(),
token_credential: None,
token_credential_resource: "https://management.azure.com/".to_owned(),
}
}
}
|
//! Contains definitions for the elementary operations.
mod addition;
pub use addition::Addition;
mod multiplication;
pub use multiplication::Multiplication;
|
fn main() {
println!("Hello world!");
println!("How are you?")
}
|
use diesel::r2d2::ConnectionManager;
use diesel::mysql::MysqlConnection;
pub type Conn = r2d2::PooledConnection<ConnectionManager<MysqlConnection>>;
pub type Pool = r2d2::Pool<ConnectionManager<MysqlConnection>>;
pub fn init_database_pool(database_url: &str) -> Pool {
let manager = ConnectionManager::<MysqlConnection>::new(database_url);
Pool::builder().build(manager).expect("db pool build error occurred")
}
|
extern crate confy;
#[macro_use]
extern crate serde_derive;
pub mod config;
|
/*
2
3 1
4
20 18 2 18
*/
fn main() {
let n = read();
let mut vec = read_line();
vec.sort_by(|a, b| b.cmp(a));
let mut alice = 0;
let mut bob = 0;
for i in 0..n as usize {
if i % 2 == 0 {
alice += vec[i];
} else {
bob += vec[i];
}
}
println!("{}", alice - bob);
}
fn read() -> i32 {
let mut s = String::new();
std::io::stdin().read_line(&mut s).ok();
s.trim().parse().ok().unwrap()
}
fn read_line() -> Vec<i32> {
let mut s = String::new();
std::io::stdin().read_line(&mut s).ok();
let v = s.trim()
.split_whitespace()
.map(|e| e.parse().ok().unwrap())
.collect();
return v
} |
use docset::{DocSet, SkipResult};
use query::Scorer;
use DocId;
use Score;
/// Creates a `DocSet` that iterator through the intersection of two `DocSet`s.
pub struct Intersection<TDocSet: DocSet> {
docsets: Vec<TDocSet>,
finished: bool,
doc: DocId,
}
impl<TDocSet: DocSet> From<Vec<TDocSet>> for Intersection<TDocSet> {
fn from(mut docsets: Vec<TDocSet>) -> Intersection<TDocSet> {
assert!(docsets.len() >= 2);
docsets.sort_by_key(|docset| docset.size_hint());
Intersection {
docsets,
finished: false,
doc: 0u32,
}
}
}
impl<TDocSet: DocSet> Intersection<TDocSet> {
/// Returns an array to the underlying `DocSet`s of the intersection.
/// These `DocSet` are in the same position as the `IntersectionDocSet`,
/// so that user can access their `docfreq` and `positions`.
pub fn docsets(&self) -> &[TDocSet] {
&self.docsets[..]
}
}
impl<TDocSet: DocSet> DocSet for Intersection<TDocSet> {
#[allow(never_loop)]
fn advance(&mut self) -> bool {
if self.finished {
return false;
}
let mut candidate_doc = self.doc;
let mut candidate_ord = self.docsets.len();
'outer: loop {
for (ord, docset) in self.docsets.iter_mut().enumerate() {
if ord != candidate_ord {
// `candidate_ord` is already at the
// right position.
//
// Calling `skip_next` would advance this docset
// and miss it.
match docset.skip_next(candidate_doc) {
SkipResult::Reached => {}
SkipResult::OverStep => {
// this is not in the intersection,
// let's update our candidate.
candidate_doc = docset.doc();
candidate_ord = ord;
continue 'outer;
}
SkipResult::End => {
self.finished = true;
return false;
}
}
}
}
self.doc = candidate_doc;
return true;
}
}
fn skip_next(&mut self, target: DocId) -> SkipResult {
// We optimize skipping by skipping every single member
// of the intersection to target.
let mut current_target: DocId = target;
let mut current_ord = self.docsets.len();
'outer: loop {
for (ord, docset) in self.docsets.iter_mut().enumerate() {
if ord == current_ord {
continue;
}
match docset.skip_next(current_target) {
SkipResult::End => {
return SkipResult::End;
}
SkipResult::OverStep => {
// update the target
// for the remaining members of the intersection.
current_target = docset.doc();
current_ord = ord;
continue 'outer;
}
SkipResult::Reached => {}
}
}
self.doc = current_target;
if target == current_target {
return SkipResult::Reached;
} else {
assert!(current_target > target);
return SkipResult::OverStep;
}
}
}
fn doc(&self) -> DocId {
self.doc
}
fn size_hint(&self) -> u32 {
self.docsets
.iter()
.map(|docset| docset.size_hint())
.min()
.unwrap_or(0u32)
}
}
impl<TScorer> Scorer for Intersection<TScorer>
where
TScorer: Scorer,
{
fn score(&mut self) -> Score {
self.docsets.iter_mut().map(Scorer::score).sum()
}
}
#[cfg(test)]
mod tests {
use docset::{DocSet, SkipResult};
use super::Intersection;
use query::VecDocSet;
use postings::tests::test_skip_against_unoptimized;
#[test]
fn test_intersection() {
{
let left = VecDocSet::from(vec![1, 3, 9]);
let right = VecDocSet::from(vec![3, 4, 9, 18]);
let mut intersection = Intersection::from(vec![left, right]);
assert!(intersection.advance());
assert_eq!(intersection.doc(), 3);
assert!(intersection.advance());
assert_eq!(intersection.doc(), 9);
assert!(!intersection.advance());
}
{
let a = VecDocSet::from(vec![1, 3, 9]);
let b = VecDocSet::from(vec![3, 4, 9, 18]);
let c = VecDocSet::from(vec![1, 5, 9, 111]);
let mut intersection = Intersection::from(vec![a, b, c]);
assert!(intersection.advance());
assert_eq!(intersection.doc(), 9);
assert!(!intersection.advance());
}
}
#[test]
fn test_intersection_zero() {
let left = VecDocSet::from(vec![0]);
let right = VecDocSet::from(vec![0]);
let mut intersection = Intersection::from(vec![left, right]);
assert!(intersection.advance());
assert_eq!(intersection.doc(), 0);
}
#[test]
fn test_intersection_skip() {
let left = VecDocSet::from(vec![0, 1, 2, 4]);
let right = VecDocSet::from(vec![2, 5]);
let mut intersection = Intersection::from(vec![left, right]);
assert_eq!(intersection.skip_next(2), SkipResult::Reached);
assert_eq!(intersection.doc(), 2);
}
#[test]
fn test_intersection_skip_against_unoptimized() {
test_skip_against_unoptimized(
|| {
let left = VecDocSet::from(vec![4]);
let right = VecDocSet::from(vec![2, 5]);
box Intersection::from(vec![left, right])
},
vec![0, 2, 4, 5, 6],
);
test_skip_against_unoptimized(
|| {
let mut left = VecDocSet::from(vec![1, 4, 5, 6]);
let mut right = VecDocSet::from(vec![2, 5, 10]);
left.advance();
right.advance();
box Intersection::from(vec![left, right])
},
vec![0, 1, 2, 3, 4, 5, 6, 7, 10, 11],
);
test_skip_against_unoptimized(
|| {
box Intersection::from(vec![
VecDocSet::from(vec![1, 4, 5, 6]),
VecDocSet::from(vec![1, 2, 5, 6]),
VecDocSet::from(vec![1, 4, 5, 6]),
VecDocSet::from(vec![1, 5, 6]),
VecDocSet::from(vec![2, 4, 5, 7, 8]),
])
},
vec![0, 1, 2, 3, 4, 5, 6, 7, 10, 11],
);
}
#[test]
fn test_intersection_empty() {
let a = VecDocSet::from(vec![1, 3]);
let b = VecDocSet::from(vec![1, 4]);
let c = VecDocSet::from(vec![3, 9]);
let mut intersection = Intersection::from(vec![a, b, c]);
assert!(!intersection.advance());
}
}
|
extern crate nalgebra as na;
use na::Vector2;
use nphysics2d::object::{DefaultBodySet, DefaultColliderSet};
use nphysics2d::force_generator::DefaultForceGeneratorSet;
use nphysics2d::joint::DefaultJointConstraintSet;
use nphysics2d::world::{DefaultMechanicalWorld, DefaultGeometricalWorld};
pub struct PhysicsWorld {
mechanical_world: DefaultMechanicalWorld<f32>,
geometrical_world: DefaultGeometricalWorld<f32>,
bodies: DefaultBodySet<f32>,
colliders: DefaultColliderSet<f32>,
joint_constraints: DefaultJointConstraintSet<f32>,
force_generators: DefaultForceGeneratorSet<f32>,
}
impl PhysicsWorld {
pub fn new() -> Self {
let mechanical_world = DefaultMechanicalWorld::new(Vector2::new(0.0, -9.81));
let geometrical_world = DefaultGeometricalWorld::<f32>::new();
let bodies = DefaultBodySet::<f32>::new();
let colliders = DefaultColliderSet::<f32>::new();
let joint_constraints = DefaultJointConstraintSet::<f32>::new();
let force_generators = DefaultForceGeneratorSet::<f32>::new();
Self {
mechanical_world,
geometrical_world,
bodies,
colliders,
joint_constraints,
force_generators
}
}
pub fn step(&mut self) {
self.mechanical_world.step(
&mut self.geometrical_world,
&mut self.bodies,
&mut self.colliders,
&mut self.joint_constraints,
&mut self.force_generators
);
}
} |
use std::cmp::min;
use std::sync::Arc;
use cgmath::prelude::*;
use crate::prelude::*;
use crate::interaction::SurfaceInteraction;
use super::{ Bxdf, BxdfType };
use crate::interaction::Sample;
use crate::sampler::ONE_MINUS_EPSILON;
#[derive(Clone, Debug)]
pub struct Bsdf {
pub eta: Float,
n_s: Normal,
n_g: Normal,
ss: Vector3f,
ts: Vector3f,
bxdfs: Vec<Arc<dyn Bxdf>>,
}
impl Bsdf {
pub fn new(si: &SurfaceInteraction<'_>, eta: Option<Float>) -> Self {
let eta = eta.unwrap_or_else(|| float(1.0));
Self {
eta,
n_s: si.shading.n,
n_g: si.n.unwrap(),
ss: si.shading.dpdu.normalize(),
ts: (*si.shading.n).cross(si.shading.dpdu.normalize()),
bxdfs: vec![],
}
}
pub fn add(&mut self, bxdf: Arc<dyn Bxdf>) {
self.bxdfs.push(bxdf);
}
pub fn num_components(&self, flags: BxdfType) -> usize {
let mut num = 0;
for bxdf in &self.bxdfs {
if flags.contains(bxdf.ty()) {
num += 1;
}
}
num
}
pub fn world_to_local(&self, v: Vector3f) -> Vector3f {
Vector3f::new(
v.dot(self.ss),
v.dot(self.ts),
v.dot(*self.n_s)
)
}
pub fn local_to_world(&self, v: Vector3f) -> Vector3f {
Vector3f {
x: self.ss.x * v.x + self.ts.x * v.y + self.n_s.x * v.z,
y: self.ss.y * v.x + self.ts.y * v.y + self.n_s.y * v.z,
z: self.ss.z * v.x + self.ts.z * v.y + self.n_s.z * v.z,
}
}
pub fn f(&self, wo_w: Vector3f, wi_w: Vector3f, flags: BxdfType) -> Spectrum {
let wi = self.world_to_local(wi_w);
let wo = self.world_to_local(wo_w);
if wo.z == 0.0 {
return Spectrum::new(0.0);
}
let reflect = wi_w.dot(*self.n_g) * wo_w.dot(*self.n_g) > 0.0;
let mut f = Spectrum::new(0.0);
for bxdf in &self.bxdfs {
if flags.contains(bxdf.ty()) &&
((reflect && bxdf.ty().contains(BxdfType::Reflection)) ||
(!reflect && bxdf.ty().contains(BxdfType::Transmission))) {
f += bxdf.f(wo, wi);
}
}
f
}
pub fn sample_f(&self, wo_world: Vector3f, u: Point2f, ty: BxdfType) -> Option<Sample> {
let matching = self.num_components(ty);
if matching == 0 {
return None;
}
let comp = min(
(u[0] * float(matching)).floor().raw() as usize,
matching - 1,
);
let bxdfs = self.bxdfs.iter()
.filter(|b| ty.contains(b.ty()))
.enumerate()
.collect::<Vec<_>>();
let (chosen_idx, bxdf) = bxdfs[comp];
// u[0] is no longer uniformly distributed
// but we can a uniformly distributed one back
let u_remapped = Point2f::new(
min(u[0] * float(matching) - float(comp), float(ONE_MINUS_EPSILON)),
u[1],
);
let wo_local = self.world_to_local(wo_world);
if wo_local.z == 0.0 {
return None;
}
let mut sample = match bxdf.sample_f(wo_local, u_remapped) {
Some(sample) => sample,
None => return None,
};
if sample.pdf == 0.0 {
return None;
}
let wi_world = self.local_to_world(sample.wi);
if !bxdf.ty().contains(BxdfType::Specular) && matching > 1 {
for (idx, bxdf) in &bxdfs {
if *idx == chosen_idx {
continue;
}
sample.pdf += bxdf.pdf(wo_local, sample.wi);
assert!(sample.pdf > 0.0);
}
}
if matching > 1 {
sample.pdf /= float(matching);
}
assert!(sample.pdf > 0.0);
if !bxdf.ty().contains(BxdfType::Specular) {
let reflect = wi_world.dot(*self.n_g) * wo_world.dot(*self.n_g) > 0.0;
let mut f = Spectrum::new(0.0);
for (_, bxdf) in &bxdfs {
if ty.contains(bxdf.ty()) &&
((reflect && bxdf.ty().contains(BxdfType::Reflection)) ||
(!reflect && bxdf.ty().contains(BxdfType::Transmission))) {
f += bxdf.f(wo_local, sample.wi);
}
}
sample.li = f;
}
Some(sample)
}
pub fn pdf(&self, wo_w: Vector3f, wi_w: Vector3f, flags: BxdfType) -> Float {
if self.bxdfs.is_empty() {
return float(0.0);
}
let wi = self.world_to_local(wi_w);
let wo = self.world_to_local(wo_w);
if wo.z == 0.0 {
return float(0.0);
}
let mut pdf = float(0.0);
let mut matching = 0;
for bxdf in &self.bxdfs {
if flags.contains(bxdf.ty()) {
matching += 1;
pdf += bxdf.pdf(wo, wi);
}
}
if matching > 0 {
pdf / float(matching)
} else {
float(0.0)
}
}
pub fn rho(&self, wo: Option<Vector3f>, n_samples: i32, samples: &[Point2f], flags: BxdfType) -> Spectrum {
let mut f = Spectrum::new(0.0);
for bxdf in &self.bxdfs {
if flags.contains(bxdf.ty()) {
f += bxdf.rho(wo, n_samples, samples);
}
}
f
}
}
|
/// LeetCode Monthly Challenge problem for March 23rd, 2021.
pub struct Solution {}
impl Solution {
/// Given an integer array arr, and an integer target, returns the number
/// of tuples i, j, k such that i < j < k and arr[i] + arr[j] + arr[k] ==
/// target.
///
/// As the answer can be very large, return it modulo 109 + 7.
///
/// # Examples
/// ```
/// # use crate::threesum_with_multiplicity::Solution;
/// let ex_one = Solution::three_sum_multi(vec![1,1,2,2,3,3,4,4,5,5], 8);
/// let ex_two = Solution::three_sum_multi(vec![1,1,2,2,2,2], 5);
///
/// assert_eq!(ex_one, 20);
/// assert_eq!(ex_two, 12);
/// ```
///
/// # Arguments
/// * 3 <= arr.len() <= 3000
/// * 0 <= arr[i] <= 100
/// * 0 <= target <= 300
///
pub fn three_sum_multi(arr: Vec<i32>, target: i32) -> i32 {
let mut counts: Vec<usize> = vec![0;101];
let mut res = 0;
for n in arr { counts[n as usize] += 1; }
for i in 0..counts.len() {
let (mut j, mut k) = (i, counts.len() - 1);
while j <= k && k < counts.len() && j < counts.len() {
let sum = (i + j + k) as i32;
if sum < target {
j += 1;
} else if sum > target {
k -= 1;
} else {
if i == j && j == k && counts[i] > 2 {
res += counts[i] * (counts[i] - 1) * (counts[i] - 2) / 6;
} else if i == j && j != k && counts[j] > 1 {
res += counts[j] * (counts[j] - 1) * counts[k] / 2;
} else if i != k && j == k && counts[j] > 1 {
res += counts[i] * counts[j] * (counts[j] - 1) / 2;
} else if i != j && j != k{
res += counts[i] * counts[j] * counts[k];
}
j += 1;
k -= 1;
}
}
}
(res % (10_usize.pow(9) + 7)) as i32
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_three_sum_multi() {
assert_eq!(
Solution::three_sum_multi(vec![1,1,2,2,3,3,4,4,5,5], 8),
20
);
assert_eq!(
Solution::three_sum_multi(vec![1,1,2,2,2,2], 5),
12
);
assert_eq!(
Solution::three_sum_multi(vec![2,2,3,2], 7),
3
);
assert_eq!(
Solution::three_sum_multi(vec![2,1,3], 6),
1
);
assert_eq!(
Solution::three_sum_multi(vec![3,3,0,0,3,2,2,3], 6),
12
);
}
}
|
/*
* Copyright (c) 2013, David Renshaw (dwrenshaw@gmail.com)
*
* See the LICENSE file in the capnproto-rust root directory.
*/
pub mod PrimitiveList {
use layout::*;
pub struct Reader<'self, T> {
reader : ListReader<'self>
}
impl <'self, T : PrimitiveElement> Reader<'self, T> {
pub fn new<'a>(reader : ListReader<'a>) -> Reader<'a, T> {
Reader::<'a, T> { reader : reader }
}
pub fn size(&self) -> uint { self.reader.size() }
pub fn get(&self, index : uint) -> T {
PrimitiveElement::get(&self.reader, index)
}
}
pub struct Builder<T> {
builder : ListBuilder
}
impl <T : PrimitiveElement> Builder<T> {
pub fn new(builder : ListBuilder) -> Builder<T> {
Builder { builder : builder }
}
pub fn size(&self) -> uint { self.builder.size() }
pub fn get(&self, index : uint) -> T {
PrimitiveElement::getFromBuilder(&self.builder, index)
}
pub fn set(&self, index : uint, value : T) {
PrimitiveElement::set(&self.builder, index, value);
}
}
}
pub trait HasMaxEnumerant {
fn maxEnumerant(_unused_self : Option<Self>) -> u16;
fn cast(unused_self : Option<Self>, value : u16) -> Option<Self> {
use std;
if (value > HasMaxEnumerant::maxEnumerant(unused_self)) { None }
else {Some (unsafe {std::cast::transmute(value as uint)})}
}
// Do I really have to define a method for this?
fn asU16(self) -> u16;
}
pub mod EnumList {
use layout::*;
use list::*;
pub struct Reader<'self, T> {
reader : ListReader<'self>
}
impl <'self, T : HasMaxEnumerant> Reader<'self, T> {
pub fn new<'a>(reader : ListReader<'a>) -> Reader<'a, T> {
Reader::<'a, T> { reader : reader }
}
pub fn size(&self) -> uint { self.reader.size() }
pub fn get(&self, index : uint) -> Option<T> {
let result : u16 = PrimitiveElement::get(&self.reader, index);
let unused_self : Option<T> = None;
HasMaxEnumerant::cast(unused_self, result)
}
}
pub struct Builder<T> {
builder : ListBuilder
}
impl <T : HasMaxEnumerant> Builder<T> {
pub fn new(builder : ListBuilder) -> Builder<T> {
Builder { builder : builder }
}
pub fn size(&self) -> uint { self.builder.size() }
pub fn get(&self, index : uint) -> Option<T> {
let result : u16 = PrimitiveElement::getFromBuilder(&self.builder, index);
let unused_self : Option<T> = None;
HasMaxEnumerant::cast(unused_self, result)
}
pub fn set(&self, index : uint, value : T) {
PrimitiveElement::set(&self.builder, index, value.asU16());
}
}
}
// The struct list reader needs to be able to instantiate element readers
// of the appropriate type. It is implemented as a macro.
|
mod data_lake_client;
pub use data_lake_client::DataLakeClient;
mod file_system_client;
pub use file_system_client::FileSystemClient;
|
use crate::eval::prelude::*;
impl Eval<&ast::ExprWhile> for ConstCompiler<'_> {
fn eval(
&mut self,
expr_while: &ast::ExprWhile,
used: Used,
) -> Result<Option<ConstValue>, crate::CompileError> {
let span = expr_while.span();
while expr_while.condition.as_bool(self, used)? {
// NB: use up one budget on each loop, in case the condition is
// constant folded.
self.budget.take(span)?;
self.eval(&*expr_while.body, used)?
.ok_or_else(|| CompileError::not_const(&*expr_while.body))?;
}
Ok(Some(ConstValue::Unit))
}
}
|
use socketcan_isotp::{self, IsoTpSocket, StandardId};
use std::time::Duration;
fn main() -> Result<(), socketcan_isotp::Error> {
let tp_socket = IsoTpSocket::open(
"vcan0",
StandardId::new(0x321).expect("Invalid rx id"),
StandardId::new(0x123).expect("Invalid tx id"),
)?;
loop {
tp_socket.write(&[0xAA, 0x11, 0x22, 0x33, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF])?;
println!("Sent frame");
std::thread::sleep(Duration::from_millis(1000));
}
}
|
pub struct Xorshift32 {
state: u32,
}
impl Xorshift32 {
pub fn new(seed: u32) -> Xorshift32 {
Xorshift32 { state: seed }
}
fn xorshift32(&mut self) -> u32 {
self.state ^= self.state << 13;
self.state ^= self.state >> 17;
self.state ^= self.state << 5;
self.state
}
pub fn float(&mut self) -> f32 {
self.xorshift32() as f32 / 4_294_967_295u32 as f32
}
}
|
pub use gdk::prelude::*;
pub use gio::prelude::*;
pub use glib::prelude::*;
pub use gtk::prelude::*;
pub use std::convert::TryFrom;
pub use super::builder::BuilderExtManualGetObjectExpect;
|
#[doc = "Reader of register TRIM_LDO_0"]
pub type R = crate::R<u32, super::TRIM_LDO_0>;
#[doc = "Writer for register TRIM_LDO_0"]
pub type W = crate::W<u32, super::TRIM_LDO_0>;
#[doc = "Register TRIM_LDO_0 `reset()`'s with value 0x58"]
impl crate::ResetValue for super::TRIM_LDO_0 {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x58
}
}
#[doc = "Reader of field `ACT_LDO_VREG`"]
pub type ACT_LDO_VREG_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `ACT_LDO_VREG`"]
pub struct ACT_LDO_VREG_W<'a> {
w: &'a mut W,
}
impl<'a> ACT_LDO_VREG_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !0x0f) | ((value as u32) & 0x0f);
self.w
}
}
#[doc = "Reader of field `ACT_LDO_ITAIL`"]
pub type ACT_LDO_ITAIL_R = crate::R<u8, u8>;
#[doc = "Write proxy for field `ACT_LDO_ITAIL`"]
pub struct ACT_LDO_ITAIL_W<'a> {
w: &'a mut W,
}
impl<'a> ACT_LDO_ITAIL_W<'a> {
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x0f << 4)) | (((value as u32) & 0x0f) << 4);
self.w
}
}
impl R {
#[doc = "Bits 0:3 - To trim the regulated voltage in steps of 25mV typically"]
#[inline(always)]
pub fn act_ldo_vreg(&self) -> ACT_LDO_VREG_R {
ACT_LDO_VREG_R::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - To trim the bias currents for all the active mode blocks"]
#[inline(always)]
pub fn act_ldo_itail(&self) -> ACT_LDO_ITAIL_R {
ACT_LDO_ITAIL_R::new(((self.bits >> 4) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - To trim the regulated voltage in steps of 25mV typically"]
#[inline(always)]
pub fn act_ldo_vreg(&mut self) -> ACT_LDO_VREG_W {
ACT_LDO_VREG_W { w: self }
}
#[doc = "Bits 4:7 - To trim the bias currents for all the active mode blocks"]
#[inline(always)]
pub fn act_ldo_itail(&mut self) -> ACT_LDO_ITAIL_W {
ACT_LDO_ITAIL_W { w: self }
}
}
|
// Need pub keyword to be able to use in main functions
// Using super rather than an abolsute path starting with crate
// is that using super may make it easier to update your code to have
// a different module hierarchy
// For example if we wrapped the in another module, the super would still work
// #[derive(Debug)]
mod sound {
pub mod instrument {
pub fn clarinet() {
println!("hello from clarinet");
super::breathe_in();
}
}
fn breathe_in() {
println!("hello from breathe_in");
}
}
mod plant {
pub struct Vegetable {
// public name field but private id field
pub name: String,
id: i32
}
impl Vegetable {
pub fn new(name: &str) -> Vegetable {
Vegetable {
name: String::from(name),
id: 1
}
}
}
}
mod menu {
pub enum Appetizer {
Soup,
Salad
}
}
fn main() {
// absolute path
crate::sound::instrument::clarinet();
// relative path
sound::instrument::clarinet();
let mut v = plant::Vegetable::new("squash");
v.name = String::from("butternut squash");
println!("{} are delicious", v.name);
// The next line won't compile if we uncomment it:
// We can't access id in this scope because id is private
// println!("The ID is {}", v.id);
let order1 = menu::Appetizer::Soup;
let order2 = menu::Appetizer::Salad;
}
|
pub trait IsModel {
fn name(&self) -> String;
fn next(&mut self);
}
pub struct BasicModel {
pub name: String,
}
pub struct Model {
basic: BasicModel,
}
impl Model {
pub fn new(name: &str) -> Self {
Self {
basic: BasicModel {
name: name.to_string(),
},
}
}
}
impl IsModel for Model {
fn name(&self) -> String {
return self.basic.name.clone();
}
fn next(&mut self) {}
}
|
use crate::{Points, SplineOpts};
use wasm_bindgen::prelude::*;
#[allow(clippy::too_many_arguments, non_snake_case)]
#[wasm_bindgen]
pub fn getCurvePoints(
pts: Vec<f64>,
num_of_segments: Option<u32>,
tension: Option<f64>,
custom_tensions: Option<Vec<f64>>,
invert_x_with_width: Option<f64>,
invert_y_with_height: Option<f64>,
hidden_point_at_start: Option<Vec<f64>>,
hidden_point_at_end: Option<Vec<f64>>,
) -> Vec<f64> {
let mut b = SplineOpts::new();
if let Some(t) = tension {
b = b.tension(t);
}
if let Some(n) = num_of_segments {
b = b.num_of_segments(n);
}
if let Some(s) = hidden_point_at_start {
if s.len() >= 2 {
b = b.hidden_point_at_start((s[0], s[1]));
}
}
if let Some(s) = hidden_point_at_end {
if s.len() >= 2 {
b = b.hidden_point_at_end((s[0], s[1]));
}
}
let mut pts = Points::try_from_flatten(&pts).unwrap();
if let Some(w) = invert_x_with_width {
pts.invert_horizontally(w);
}
if let Some(h) = invert_y_with_height {
pts.invert_vertically(h);
}
if let Some(ct) = custom_tensions {
ct.iter().enumerate().for_each(|(i, t)| {
if *t > -100.0 {
pts.get_mut().get_mut(i).iter_mut().for_each(|p| {
p.tension = Some(*t);
});
}
});
}
pts.calc_spline(&b).unwrap().into()
}
|
#[aoc_generator(day9, part1)]
pub fn parse_program(input: &str) -> Vec<i64> {
input
.split(',')
.map(|i| i.parse::<i64>().unwrap())
.collect()
}
#[aoc(day9, part1)]
fn solve_p1(tape: &[i64]) -> i64 {
let mut tape = tape.to_owned();
intcode_computer(&mut tape, &mut 0, &mut 0, || 1)
}
#[aoc_generator(day9, part2)]
fn p2_generator(input: &str) -> Vec<i64> {
parse_program(input)
}
#[aoc(day9, part2)]
fn solve_p2(tape: &[i64]) -> i64 {
let mut tape = tape.to_owned();
intcode_computer(&mut tape, &mut 0, &mut 0, || 2)
}
pub fn intcode_computer<F>(
tape: &mut Vec<i64>,
i: &mut usize,
relative_base: &mut i64,
mut get_input: F,
) -> i64
where
F: FnMut() -> i64,
{
use crate::day4::get_digits;
use std::convert::TryInto;
//let mut tape = tape.clone();
loop {
let instr: u64 = tape[*i]
.try_into()
.expect("Negative Instruction is Invalid");
let mut digits = get_digits(instr);
while digits.len() < 5 {
digits.insert(0, 0);
}
let opcode = [digits[digits.len() - 2], digits[digits.len() - 1]];
let read_param = |idx| {
let parameter_mode = digits.get(digits.len() - 2 - idx).unwrap();
match parameter_mode {
0 => *tape
.get(*tape.get(*i + idx).unwrap_or(&0) as usize)
.unwrap_or(&0),
1 => *tape.get(*i + idx).unwrap_or(&0),
2 => *tape
.get((*relative_base + *tape.get(*i + idx).unwrap_or(&0)) as usize)
.unwrap_or(&0),
e => panic!("Unrecognized parameter_mode: {:?}", e),
}
};
let write_param = |tape: &mut Vec<i64>, idx: usize, data| {
let parameter_mode = digits.get(digits.len() - 2 - idx).unwrap();
match parameter_mode {
0 => {
let output = *tape.get(*i + idx).unwrap_or(&0) as usize;
if output >= tape.len() {
tape.resize(output + 1, 0);
}
tape[output] = data;
}
1 => panic!("Cannot write to immediate mode param"),
2 => {
let output = (*relative_base + *tape.get(*i + idx).unwrap_or(&0)) as usize;
if output >= tape.len() {
tape.resize(output + 1, 0);
}
tape[output] = data;
}
e => panic!("Unrecognized parameter_mode: {:?}", e),
}
};
match opcode {
[0, 1] => {
let p1 = read_param(1);
let p2 = read_param(2);
write_param(tape, 3, p1 + p2);
*i += 4;
}
[0, 2] => {
let p1 = read_param(1);
let p2 = read_param(2);
write_param(tape, 3, p1 * p2);
*i += 4;
}
[0, 3] => {
write_param(tape, 1, get_input());
*i += 2;
}
[0, 4] => {
let out = read_param(1);
*i += 2;
break out;
}
[0, 5] => {
let p1 = read_param(1);
let p2 = read_param(2);
if p1 != 0 {
*i = p2 as usize;
} else {
*i += 3;
}
}
[0, 6] => {
let p1 = read_param(1);
let p2 = read_param(2);
if p1 == 0 {
*i = p2 as usize;
} else {
*i += 3;
}
}
[0, 7] => {
let p1 = read_param(1);
let p2 = read_param(2);
if p1 < p2 {
write_param(tape, 3, 1);
} else {
write_param(tape, 3, 0)
}
*i += 4;
}
[0, 8] => {
let p1 = read_param(1);
let p2 = read_param(2);
if p1 == p2 {
write_param(tape, 3, 1);
} else {
write_param(tape, 3, 0);
}
*i += 4;
}
[0, 9] => {
let p1 = read_param(1);
*relative_base += p1;
*i += 2
}
[9, 9] => break -1,
_ => panic!("Unrecognized opcode: {:?}", opcode),
};
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn copy_input() {
let mut tape = vec![
109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99,
];
//tape.append(&mut vec![0; 10_000]);
let mut i = 0;
let mut relative_base = 0;
loop {
let output = intcode_computer(&mut tape, &mut i, &mut relative_base, || 0);
if output == -1 {
return;
} else {
println!("{:?}", output);
}
}
}
#[test]
fn large_output() {
let mut tape = vec![1102, 34915192, 34915192, 7, 4, 7, 99, 0];
//tape.append(&mut vec![0; 10_000]);
let mut i = 0;
let mut relative_base = 0;
let output = intcode_computer(&mut tape, &mut i, &mut relative_base, || 0);
println!("{:?}", output);
}
#[test]
fn large_output_2() {
let mut tape = vec![104, 1125899906842624, 99];
//tape.append(&mut vec![0; 10_000]);
let mut i = 0;
let mut relative_base = 0;
let output = intcode_computer(&mut tape, &mut i, &mut relative_base, || 0);
println!("{:?}", output);
assert_eq!(output, tape[1]);
}
}
|
extern crate image;
extern crate num_cpus;
extern crate rand;
mod geometry;
mod material;
mod math;
use geometry::*;
use material::*;
use math::*;
use rand::random;
use std::path::Path;
use std::sync::{mpsc, Arc, Mutex};
use std::thread;
const DEFAULT_SAMPLES: usize = 16;
const DEFAULT_W_PIXELS: usize = 1024;
const DEFAULT_H_PIXELS: usize = 1024;
fn main() {
let w = DEFAULT_W_PIXELS;
let h = DEFAULT_H_PIXELS;
let mut s = DEFAULT_SAMPLES;
s /= 4;
let w_f = w as f64;
let h_f = h as f64;
let s_f = s as f64;
let n = num_cpus::get();
let chunk_h = h / n;
let cam = Ray::new(
Point::new(0.0, 0.0, 50.0),
Vector::new(0.0, 0.0, -1.0).norm(),
);
let cx = Vector::new(w as f64 * 0.5135 / h as f64, 0.0, 0.0);
let cy = cx.cross(cam.dir).norm() * 0.5135;
let (tx, rx) = mpsc::channel();
let data = Arc::new(Mutex::new(vec![0u8; 3 * w * h]));
let materials = [
Material::new(
Color::zero(),
Color::new(0.75, 0.25, 0.25),
MaterialType::DIFFUSE,
),
Material::new(
Color::zero(),
Color::new(0.25, 0.25, 0.75),
MaterialType::DIFFUSE,
),
Material::new(Color::zero(), Color::all(0.75), MaterialType::DIFFUSE),
Material::new(Color::zero(), Color::zero(), MaterialType::DIFFUSE),
Material::new(Color::zero(), Color::all(0.999), MaterialType::DIFFUSE),
Material::new(Color::zero(), Color::all(0.999), MaterialType::GLASS),
Material::new(Color::all(12.0), Color::zero(), MaterialType::DIFFUSE),
];
let spheres = [Sphere::new(10.0, Point::new(0.0, 0.0, 0.0), materials[4])];
println!("Calculating using: {} CPUs...", n);
for t in 0..n {
let (data, tx) = (data.clone(), tx.clone());
thread::spawn(move || {
let bot = chunk_h * t;
let top = chunk_h * (t + 1);
for y in bot..top {
let y_f = y as f64;
for x in 0..w {
let x_f = x as f64;
let mut accum = Color::zero();
for sy in 0..2 {
for sx in 0..2 {
let sx = sx as f64;
let sy = sy as f64;
for _ in 0..s {
let r1 = 2.0 * random::<f64>();
let r2 = 2.0 * random::<f64>();
let dx = if r1 < 1.0 {
r1.sqrt() - 1.0
} else {
1.0 - (2.0 - r1).sqrt()
};
let dy = if r2 < 1.0 {
r2.sqrt() - 1.0
} else {
1.0 - (2.0 - r2).sqrt()
};
let d = cx * (((sx + 0.5 + dx) / 2.0 + x_f) / w_f - 0.5)
+ cy * (((sy + 0.5 + dy) / 2.0 + y_f) / h_f - 0.5)
+ cam.dir;
let ray = Ray::new(cam.ori + d, d.norm());
accum = accum + radiance(ray, &spheres);
}
}
}
let mut data = data.lock().unwrap();
let pix_loc = (h - y - 1) * w * 3 + x * 3;
accum = accum * (0.25 / s_f);
data[pix_loc + 0] = to_int(accum.r);
data[pix_loc + 1] = to_int(accum.g);
data[pix_loc + 2] = to_int(accum.b);
}
}
let _ = tx.send(());
});
}
for _ in 0..n {
let _ = rx.recv().unwrap();
}
let (w, h, data) = (w as u32, h as u32, data.lock().unwrap());
let _ = image::save_buffer(
&Path::new("smallpt.png"),
&data,
w,
h,
image::ColorType::Rgb8,
);
}
|
impl super::Cpu {
pub fn absolute(&mut self) -> usize {
self.clock += 4;
<usize>::from(
((self.read(self.pc + 2) as usize) << 8) + // high byte, little endian
(self.read(self.pc + 1)) as usize // low byte
)
}
pub fn absolute_x(&mut self) -> usize {
let current_opcode = self.read(self.pc);
let old_address = self.absolute();
let new_address = old_address + self.x as usize;
match current_opcode {
0x1C | 0x1D | 0x3C | 0x3D | 0x5C | 0x5D | 0x7C | 0x7D | 0xBC | 0xBD | 0xDC | 0xDD | 0xFC | 0xFD
=> self.address_page_cross(old_address, new_address),
0x1E | 0x1F | 0x3E | 0x3F | 0x5E | 0x5F | 0x7E | 0x7F | 0x9D | 0xC3 | 0xC7 | 0xCF | 0xD3 | 0xD7 | 0xDB | 0xDE | 0xDF | 0xFE | 0xFF
=> self.clock += 1,
_ => panic!("illegal opcode using abs x: {:02x}", current_opcode),
}
new_address
}
pub fn absolute_y(&mut self) -> usize {
let current_opcode = self.pc;
let old_address = self.absolute() as u16; // coerce to u16 for wrapping addition
let new_address = old_address.wrapping_add(self.y as u16);
let old_address = old_address as usize; // coerce back
let new_address = new_address as usize;
if current_opcode == 0x99 {
self.clock += 1;
} else {
self.address_page_cross(old_address, new_address);
}
new_address
}
pub fn accumulator(&mut self) -> usize {
self.clock += 2;
0
}
pub fn immediate(&mut self) -> usize {
self.clock += 2;
self.pc + 1
}
pub fn implied(&mut self) -> usize {
self.clock += 2;
0
}
pub fn indexed_indirect(&mut self) -> usize {
self.clock += 6;
let operand = self.read(self.pc + 1);
let zp_low_addr = operand.wrapping_add(self.x);
let zp_high_addr = zp_low_addr.wrapping_add(1); // take account of zero page wraparound
let zp_low_byte = self.read(zp_low_addr as usize);
let zp_high_byte = self.read(zp_high_addr as usize);
((zp_high_byte as usize) << 8) + zp_low_byte as usize
}
pub fn indirect(&mut self) -> usize {
let operand_address = ((self.read(self.pc + 2) as usize) << 8)
+ (self.read(self.pc + 1) as usize);
let low_byte = self.read(operand_address) as usize;
// BUG TIME! from https://wiki.nesdev.com/w/index.php/Errata
// "JMP ($xxyy), or JMP indirect, does not advance pages if the lower eight bits
// of the specified address is $FF; the upper eight bits are fetched from $xx00,
// 255 bytes earlier, instead of the expected following byte."
let high_byte = if operand_address & 0xFF == 0xFF {
(self.read(operand_address as usize - 0xFF) as usize) << 8
} else {
(self.read(operand_address as usize + 1) as usize) << 8
};
let real_address = high_byte + low_byte;
self.clock += 5;
real_address
}
pub fn indirect_indexed(&mut self) -> usize {
let operand = self.read(self.pc + 1);
let zp_low_addr = operand;
let zp_high_addr = operand.wrapping_add(1);
let zp_low_byte = self.read(zp_low_addr as usize);
let zp_high_byte = self.read(zp_high_addr as usize);
let old_address = ((zp_high_byte as u16) << 8) + zp_low_byte as u16;
let new_address = old_address.wrapping_add(self.y as u16);
if self.pc == 0xF1 {
self.clock += 1;
} else {
self.address_page_cross(old_address as usize, new_address as usize);
}
self.clock += 5;
new_address as usize
}
pub fn relative(&mut self) -> usize {
self.clock += 2;
self.pc + 1
}
pub fn zero_page(&mut self) -> usize {
let operand = self.read(self.pc + 1);
self.clock += 3;
operand as usize
}
pub fn zero_page_x(&mut self) -> usize {
let operand = self.read(self.pc + 1);
self.clock += 4;
operand.wrapping_add(self.x) as usize
}
pub fn zero_page_y(&mut self) -> usize {
let operand = self.read(self.pc + 1);
self.clock += 4;
operand.wrapping_add(self.y) as usize
}
}
|
use crate::task::ShowParams;
use crate::task::TimeWindow;
use structopt::StructOpt;
use structopt_flags::ForceFlag;
#[derive(Debug, StructOpt)]
pub enum Cmd {
/// Show all
#[structopt(name = "show")]
Show(ShowOpt),
/// Work on the task database
#[structopt(name = "database")]
Db(DbOpt),
/// Work on tasks/todos
#[structopt(name = "task")]
Task(TaskOpt),
/// Work on tasks steps
#[structopt(name = "step")]
Step(StepOpt),
/// Generate autocompletion for zsh
#[structopt(name = "completion")]
Completion,
}
#[derive(Debug, StructOpt)]
pub struct DbOpt {
#[structopt(subcommand)]
pub cmd: DbCmd,
}
#[derive(Debug, StructOpt)]
pub enum DbCmd {
/// Database initialization
#[structopt(name = "init")]
Init {
#[structopt(flatten)]
force_flag: ForceFlag,
},
}
#[derive(Debug, StructOpt)]
pub struct ShowOpt {
#[structopt(flatten)]
pub show_opts: ShowCommonOpt,
#[structopt(subcommand)]
pub cmd: Option<ShowCmd>,
/// The task id
#[structopt(short = "t", long = "task")]
pub task: Option<u32>,
}
#[derive(Debug, StructOpt)]
pub enum ShowCmd {
/// Show tasks, except the completed ones
#[structopt(name = "all")]
All {
#[structopt(flatten)]
show_opts: ShowCommonOpt,
},
/// Show few tasks: high priority and/or in progress
#[structopt(name = "short")]
Short {
#[structopt(flatten)]
show_opts: ShowCommonOpt,
},
/// Show the backlog, all the tasks in todo
#[structopt(name = "backlog")]
Backlog {
#[structopt(flatten)]
show_opts: ShowCommonOpt,
},
/// Show the tasks that are "in_progress"
#[structopt(name = "work")]
Work {
#[structopt(flatten)]
show_opts: ShowCommonOpt,
},
/// Show the tasks that are "in_progress"
#[structopt(name = "done")]
Done {
#[structopt(flatten)]
show_opts: ShowCommonOpt,
/// The time window desired
/// Possible values are: today, yesterday, week, month
#[structopt(short = "T", long = "time")]
time_window: Option<TimeWindow>,
},
}
#[derive(Debug, StructOpt, Default)]
pub struct ShowCommonOpt {
/// Show fields normally hidden, like story points
#[structopt(short = "H", long = "hidden")]
pub hidden: bool,
/// Select one or more label as filter
#[structopt(short = "l", long = "label", raw(number_of_values = "1"))]
pub labels: Vec<String>,
/// Show references as well
#[structopt(short = "r", long = "reference")]
pub reference: bool,
/// Show steps as well
#[structopt(short = "s", long = "steps")]
pub steps: bool,
}
impl ShowCommonOpt {
pub fn as_show_params<'a>(&'a self, status: &'a str) -> ShowParams<'a> {
ShowParams {
label: &self.labels,
status,
reference: self.reference,
storypoints: self.hidden,
steps: self.steps,
}
}
pub fn merge(&mut self, to_merge: &ShowCommonOpt) {
self.hidden |= to_merge.hidden;
self.reference |= to_merge.reference;
to_merge
.labels
.iter()
.for_each(|x| self.labels.push(x.to_string()));
}
}
#[derive(Debug, StructOpt)]
pub struct TaskOpt {
#[structopt(subcommand)]
pub cmd: TaskCmd,
}
#[derive(Debug, StructOpt)]
pub enum TaskCmd {
/// Create a new task
#[structopt(name = "new")]
New {
/// attach one or more label to the task
#[structopt(short = "l", long = "label", raw(number_of_values = "1"))]
labels: Vec<String>,
/// set a reference to the task
#[structopt(short = "r", long = "reference")]
reference: Option<String>,
/// set a priority
#[structopt(short = "p", long = "priority")]
priority: Option<String>,
/// the story points
#[structopt(short = "S", long = "story-points")]
storypoint: Option<u32>,
/// The task description
#[structopt(raw(required = "true"))]
descr: Vec<String>,
},
/// Add a label to an existing task
#[structopt(name = "add-label")]
AddLabel {
/// attach one or more label to the task
#[structopt(short = "l", long = "label", raw(number_of_values = "1"))]
labels: Vec<String>,
/// The task id
#[structopt(short = "t", long = "task")]
task: u32,
},
/// Set a new description for the task
#[structopt(name = "edit")]
Edit {
/// The task id
#[structopt(short = "t", long = "task")]
task: u32,
/// the priority level
#[structopt(short = "p", long = "priority")]
priority: Option<String>,
/// the task' status
#[structopt(short = "s", long = "status")]
status: Option<String>,
/// the story points
#[structopt(short = "S", long = "story-points")]
storypoint: Option<u32>,
/// set a reference to the task
#[structopt(short = "r", long = "reference")]
reference: Option<String>,
/// The task description
#[structopt()]
descr: Vec<String>,
},
/// Close a task
#[structopt(name = "done")]
Done(OptTaskOnly),
/// Start to work on a task
#[structopt(name = "start")]
Start(OptTaskOnly),
/// Mark the task as blocked
#[structopt(name = "block")]
Block(OptTaskOnly),
/// Delete a task
#[structopt(name = "delete")]
Delete(OptTaskOnly),
/// Increase the priority of a task
#[structopt(name = "prio")]
Prio(OptTaskOnly),
}
#[derive(Debug, StructOpt)]
pub struct OptTaskOnly {
/// The task id
#[structopt(short = "t", long = "task")]
pub task_id: u32,
}
#[derive(Debug, StructOpt)]
pub struct StepOpt {
#[structopt(subcommand)]
pub cmd: StepCmd,
}
#[derive(Debug, StructOpt)]
pub enum StepCmd {
/// Add a new step to a task
#[structopt(name = "add")]
Add {
/// The working task
#[structopt(short = "t", long = "task")]
task_id: u32,
/// The task description
#[structopt(raw(required = "true"))]
descr: Vec<String>,
},
/// Mark a step as completed
#[structopt(name = "done")]
Done {
/// The working task
#[structopt(short = "t", long = "task")]
task_id: u32,
/// The step id
#[structopt(short = "s", long = "step")]
step_id: u32,
},
/// Delete a step
#[structopt(name = "delete")]
Delete {
/// The working task
#[structopt(short = "t", long = "task")]
task_id: u32,
/// The step id
#[structopt(short = "s", long = "step")]
step_id: u32,
},
}
#[cfg(test)]
mod cli_opt_tests {
use super::*;
#[test]
fn test_showcommonopt_default() {
let mut uut = ShowCommonOpt::default();
uut.merge(&ShowCommonOpt::default());
assert!(!uut.hidden);
assert!(!uut.reference);
assert!(uut.labels.is_empty());
}
#[test]
fn test_showcommonopt_true_values() {
let mut uut = ShowCommonOpt::default();
uut.hidden = true;
uut.merge(&ShowCommonOpt {
reference: true,
..ShowCommonOpt::default()
});
assert!(uut.hidden);
assert!(uut.reference);
assert!(uut.labels.is_empty());
}
#[test]
fn test_showcommonopt_labels() {
let mut label_uut = Vec::new();
label_uut.push("label1".to_string());
let mut uut = ShowCommonOpt {
labels: label_uut,
..ShowCommonOpt::default()
};
uut.merge(&ShowCommonOpt::default());
assert!(!uut.hidden);
assert!(!uut.reference);
assert_eq!(uut.labels.len(), 1);
assert_eq!(uut.labels.pop().unwrap(), "label1".to_string());
}
// currently a feature too hard to implement at this level
// #[test]
// fn test_showcommonopt_labels_repeated() {
// let mut label_uut = Vec::new();
// label_uut.push("label1".to_string());
// let mut uut = ShowCommonOpt {
// labels: label_uut,
// ..ShowCommonOpt::default()
// };
// let mut label_uut = Vec::new();
// label_uut.push("label1".to_string());
// uut.merge(ShowCommonOpt {
// labels: label_uut,
// ..ShowCommonOpt::default()
// });
// assert!(!uut.hidden);
// assert!(!uut.reference);
// assert_eq!(uut.labels.len(), 1);
// assert_eq!(uut.labels.pop().unwrap(), "label1".to_string());
// }
}
|
use std::collections::{BTreeMap, BTreeSet};
type Grade = u32;
type Students = BTreeSet<String>;
type Database = BTreeMap<Grade, Students>;
#[derive(Default)]
pub struct School {
database: Database,
}
impl School {
pub fn new() -> School {
Default::default()
}
pub fn add(&mut self, grade: Grade, student: &str) {
self.database
.entry(grade)
.or_insert_with(Students::new)
.insert(student.to_string());
}
pub fn grades(&self) -> Vec<u32> {
self.database
.keys()
.cloned()
.collect()
}
pub fn grade(&self, grade: Grade) -> Option<Vec<String>> {
self.database
.get(&grade)
.map(|students| students.iter().cloned().collect())
}
}
|
use std::fmt;
#[derive(PartialEq, Clone, Copy)]
pub enum Pixel {
Transparent,
Black,
White,
}
impl From<char> for Pixel {
fn from(c: char) -> Pixel {
match c {
'0' => Pixel::Black,
'1' => Pixel::White,
'2' => Pixel::Transparent,
_ => unreachable!(),
}
}
}
impl fmt::Display for Pixel {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Pixel::White => write!(f, "▒"),
_ => write!(f, " "),
}
}
}
impl Pixel {
fn paint(self, layer: Pixel) -> Pixel {
match self {
Pixel::Transparent => layer,
n => n,
}
}
}
fn solve_01(input: &[Pixel], width: usize, height: usize) -> usize {
let m = input
.chunks_exact(width * height)
.min_by_key(|c| c.iter().filter(|&&d| d == Pixel::Black).count())
.unwrap();
m.iter().filter(|d| **d == Pixel::White).count()
* m.iter().filter(|d| **d == Pixel::Black).count()
}
fn solve_02(input: &[Pixel], width: usize, height: usize) -> Vec<Pixel> {
input
.chunks_exact(width * height)
.fold(vec![Pixel::Transparent; width * height], |acc, layer| {
acc
.iter()
.zip(layer)
.map(|(&curr, &layer)| curr.paint(layer))
.collect()
})
}
fn input_gen(input: &str) -> Vec<Pixel> {
input.chars().map(|c| c.into()).collect()
}
pub fn solve(input: &str) {
let r = input_gen(input);
dbg!(solve_01(&r, 25, 6));
let img = solve_02(&r, 25, 6);
img.chunks(25).for_each(|row| {
for &pixel in row {
print!("{}", pixel);
}
println!();
})
}
|
use std::ops::Range;
use lazycell::LazyCell;
use nalgebra::Vector3;
use crate::geometry::Geometry;
use crate::material::Material;
use crate::ray::Ray;
#[derive(Default)]
struct Cache {
point: LazyCell<Vector3<f64>>,
normal_front: LazyCell<(Vector3<f64>, bool)>,
}
pub struct Intersection<'g> {
t: f64,
ray: Ray<f64>,
object: &'g dyn Object,
cache: Cache,
}
impl Intersection<'_> {
pub fn t(&self) -> f64 {
self.t
}
pub fn ray(&self) -> &Ray<f64> {
&self.ray
}
pub fn point(&self) -> &Vector3<f64> {
self.cache.point.borrow_with(|| self.ray.at(self.t))
}
fn normal_front(&self) -> &(Vector3<f64>, bool) {
self.cache.normal_front.borrow_with(|| {
let n = self.object.normal(self.point());
let front = self.ray.direction().dot(&n) < 0.0;
(if front { n } else { -n }, front)
})
}
pub fn normal(&self) -> &Vector3<f64> {
&self.normal_front().0
}
pub fn front(&self) -> bool {
self.normal_front().1
}
pub fn scatter(&self) -> (Ray<f64>, Vector3<f64>) {
self.object.scatter(self)
}
}
pub trait Object {
fn intersect(&self, ray: &Ray<f64>, range: Range<f64>) -> Option<Intersection>;
fn normal(&self, point: &Vector3<f64>) -> Vector3<f64>;
fn scatter(&self, int: &Intersection) -> (Ray<f64>, Vector3<f64>);
}
impl<G: Geometry, M: Material> Object for (G, M) {
fn intersect(&self, ray: &Ray<f64>, range: Range<f64>) -> Option<Intersection> {
self.0.intersect(ray, range).map(|t| Intersection {
t,
ray: ray.clone(),
object: self,
cache: Default::default(),
})
}
fn normal(&self, point: &Vector3<f64>) -> Vector3<f64> {
self.0.normal(point)
}
fn scatter(&self, int: &Intersection) -> (Ray<f64>, Vector3<f64>) {
self.1.scatter(int)
}
}
|
use rayon::iter::plumbing::{
bridge_producer_consumer, Folder, Producer, ProducerCallback, Reducer, UnindexedConsumer,
};
use rayon::prelude::*;
use std::time::{Duration, Instant};
use tracing::{span, Level};
pub struct Deadline<I> {
pub(super) base: I,
pub(super) deadline: Duration,
}
struct DeadlineCallback<C> {
consumer: C,
len: usize,
deadline: Duration,
}
impl<T, C> ProducerCallback<T> for DeadlineCallback<C>
where
C: UnindexedConsumer<T>,
{
type Output = C::Result;
fn callback<P: Producer<Item = T>>(self, mut producer: P) -> Self::Output {
let mut remaining_len = self.len;
let mut consumer = self.consumer;
// TODO: is it really the way to get to identity ?
let (left_consumer, right_consumer, _) = consumer.split_at(0);
let mut res = left_consumer.into_folder().complete();
consumer = right_consumer;
let mut current_block_size = remaining_len / 1000 + 1;
let mut processed_size = 0;
let starting_time = Instant::now();
let mut previous_block_duration = Duration::new(0, 0);
let min_duration = Duration::from_millis(5);
while remaining_len > 0 && !consumer.full() {
current_block_size = if previous_block_duration > min_duration {
current_block_size
} else {
current_block_size * 2
};
let block_start = Instant::now();
let real_size = remaining_len.min(current_block_size);
remaining_len -= real_size;
let (left, right) = producer.split_at(real_size);
producer = right;
// TODO: should we care about this reducer ?
// TODO: why on earth do we care about left and right consumers ?
let (left_consumer, right_consumer, _) = consumer.split_at(real_size);
consumer = right_consumer;
let parallel = if processed_size == 0 {
true
} else {
let current_duration = (block_start - starting_time).as_micros();
let expected_duration =
current_duration * self.len as u128 / processed_size as u128;
expected_duration > self.deadline.as_micros()
};
let block_result = if parallel {
bridge_producer_consumer(real_size, left, left_consumer)
} else {
let s = span!(Level::TRACE, "block");
{
let _enter = s.enter();
left.fold_with(left_consumer.into_folder()).complete()
}
};
res = consumer.to_reducer().reduce(res, block_result);
previous_block_duration = block_start.elapsed();
processed_size += real_size;
}
res
}
}
impl<I> ParallelIterator for Deadline<I>
where
I: IndexedParallelIterator,
{
type Item = I::Item;
fn drive_unindexed<C>(self, consumer: C) -> C::Result
where
C: UnindexedConsumer<Self::Item>,
{
let len = self.base.len();
let callback = DeadlineCallback {
consumer,
len,
deadline: self.deadline,
};
self.base.with_producer(callback)
}
}
|
use rand;
use rand::distributions::{IndependentSample, Range};
pub fn roll(count: i32, sides: i32) -> i32 {
let mut rand = rand::thread_rng();
let sides_range = Range::new(1, sides + 1);
let mut result = 0;
for _ in 0..count {
result += sides_range.ind_sample(&mut rand);
}
result
}
|
// Re-export the public interface defined in sub-modules
pub use ui::sdl2::display::Display;
pub use ui::sdl2::controller::Controller;
pub use ui::sdl2::audio::Audio;
mod display;
mod controller;
mod audio;
|
#[doc = "Register `BMTRG` reader"]
pub type R = crate::R<BMTRG_SPEC>;
#[doc = "Register `BMTRG` writer"]
pub type W = crate::W<BMTRG_SPEC>;
#[doc = "Field `SW` reader - SW"]
pub type SW_R = crate::BitReader;
#[doc = "Field `SW` writer - SW"]
pub type SW_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTRST` reader - MSTRST"]
pub type MSTRST_R = crate::BitReader;
#[doc = "Field `MSTRST` writer - MSTRST"]
pub type MSTRST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTREP` reader - MSTREP"]
pub type MSTREP_R = crate::BitReader;
#[doc = "Field `MSTREP` writer - MSTREP"]
pub type MSTREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTCMP1` reader - MSTCMP1"]
pub type MSTCMP1_R = crate::BitReader;
#[doc = "Field `MSTCMP1` writer - MSTCMP1"]
pub type MSTCMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTCMP2` reader - MSTCMP2"]
pub type MSTCMP2_R = crate::BitReader;
#[doc = "Field `MSTCMP2` writer - MSTCMP2"]
pub type MSTCMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTCMP3` reader - MSTCMP3"]
pub type MSTCMP3_R = crate::BitReader;
#[doc = "Field `MSTCMP3` writer - MSTCMP3"]
pub type MSTCMP3_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `MSTCMP4` reader - MSTCMP4"]
pub type MSTCMP4_R = crate::BitReader;
#[doc = "Field `MSTCMP4` writer - MSTCMP4"]
pub type MSTCMP4_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TARST` reader - TARST"]
pub type TARST_R = crate::BitReader;
#[doc = "Field `TARST` writer - TARST"]
pub type TARST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TAREP` reader - TAREP"]
pub type TAREP_R = crate::BitReader;
#[doc = "Field `TAREP` writer - TAREP"]
pub type TAREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TACMP1` reader - TACMP1"]
pub type TACMP1_R = crate::BitReader;
#[doc = "Field `TACMP1` writer - TACMP1"]
pub type TACMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TACMP2` reader - TACMP2"]
pub type TACMP2_R = crate::BitReader;
#[doc = "Field `TACMP2` writer - TACMP2"]
pub type TACMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TBRST` reader - TBRST"]
pub type TBRST_R = crate::BitReader;
#[doc = "Field `TBRST` writer - TBRST"]
pub type TBRST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TBREP` reader - TBREP"]
pub type TBREP_R = crate::BitReader;
#[doc = "Field `TBREP` writer - TBREP"]
pub type TBREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TBCMP1` reader - TBCMP1"]
pub type TBCMP1_R = crate::BitReader;
#[doc = "Field `TBCMP1` writer - TBCMP1"]
pub type TBCMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TBCMP2` reader - TBCMP2"]
pub type TBCMP2_R = crate::BitReader;
#[doc = "Field `TBCMP2` writer - TBCMP2"]
pub type TBCMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TCRST` reader - TCRST"]
pub type TCRST_R = crate::BitReader;
#[doc = "Field `TCRST` writer - TCRST"]
pub type TCRST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TCREP` reader - TCREP"]
pub type TCREP_R = crate::BitReader;
#[doc = "Field `TCREP` writer - TCREP"]
pub type TCREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TCCMP1` reader - TCCMP1"]
pub type TCCMP1_R = crate::BitReader;
#[doc = "Field `TCCMP1` writer - TCCMP1"]
pub type TCCMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TCCMP2` reader - TCCMP2"]
pub type TCCMP2_R = crate::BitReader;
#[doc = "Field `TCCMP2` writer - TCCMP2"]
pub type TCCMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TDRST` reader - TDRST"]
pub type TDRST_R = crate::BitReader;
#[doc = "Field `TDRST` writer - TDRST"]
pub type TDRST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TDREP` reader - TDREP"]
pub type TDREP_R = crate::BitReader;
#[doc = "Field `TDREP` writer - TDREP"]
pub type TDREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TDCMP1` reader - TDCMP1"]
pub type TDCMP1_R = crate::BitReader;
#[doc = "Field `TDCMP1` writer - TDCMP1"]
pub type TDCMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TDCMP2` reader - TDCMP2"]
pub type TDCMP2_R = crate::BitReader;
#[doc = "Field `TDCMP2` writer - TDCMP2"]
pub type TDCMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TERST` reader - TERST"]
pub type TERST_R = crate::BitReader;
#[doc = "Field `TERST` writer - TERST"]
pub type TERST_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TEREP` reader - TEREP"]
pub type TEREP_R = crate::BitReader;
#[doc = "Field `TEREP` writer - TEREP"]
pub type TEREP_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TECMP1` reader - TECMP1"]
pub type TECMP1_R = crate::BitReader;
#[doc = "Field `TECMP1` writer - TECMP1"]
pub type TECMP1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `TECMP2` reader - TECMP2"]
pub type TECMP2_R = crate::BitReader;
#[doc = "Field `TECMP2` writer - TECMP2"]
pub type TECMP2_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `OCHPEV` reader - OCHPEV"]
pub type OCHPEV_R = crate::BitReader;
#[doc = "Field `OCHPEV` writer - OCHPEV"]
pub type OCHPEV_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl R {
#[doc = "Bit 0 - SW"]
#[inline(always)]
pub fn sw(&self) -> SW_R {
SW_R::new((self.bits & 1) != 0)
}
#[doc = "Bit 1 - MSTRST"]
#[inline(always)]
pub fn mstrst(&self) -> MSTRST_R {
MSTRST_R::new(((self.bits >> 1) & 1) != 0)
}
#[doc = "Bit 2 - MSTREP"]
#[inline(always)]
pub fn mstrep(&self) -> MSTREP_R {
MSTREP_R::new(((self.bits >> 2) & 1) != 0)
}
#[doc = "Bit 3 - MSTCMP1"]
#[inline(always)]
pub fn mstcmp1(&self) -> MSTCMP1_R {
MSTCMP1_R::new(((self.bits >> 3) & 1) != 0)
}
#[doc = "Bit 4 - MSTCMP2"]
#[inline(always)]
pub fn mstcmp2(&self) -> MSTCMP2_R {
MSTCMP2_R::new(((self.bits >> 4) & 1) != 0)
}
#[doc = "Bit 5 - MSTCMP3"]
#[inline(always)]
pub fn mstcmp3(&self) -> MSTCMP3_R {
MSTCMP3_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - MSTCMP4"]
#[inline(always)]
pub fn mstcmp4(&self) -> MSTCMP4_R {
MSTCMP4_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bit 7 - TARST"]
#[inline(always)]
pub fn tarst(&self) -> TARST_R {
TARST_R::new(((self.bits >> 7) & 1) != 0)
}
#[doc = "Bit 8 - TAREP"]
#[inline(always)]
pub fn tarep(&self) -> TAREP_R {
TAREP_R::new(((self.bits >> 8) & 1) != 0)
}
#[doc = "Bit 9 - TACMP1"]
#[inline(always)]
pub fn tacmp1(&self) -> TACMP1_R {
TACMP1_R::new(((self.bits >> 9) & 1) != 0)
}
#[doc = "Bit 10 - TACMP2"]
#[inline(always)]
pub fn tacmp2(&self) -> TACMP2_R {
TACMP2_R::new(((self.bits >> 10) & 1) != 0)
}
#[doc = "Bit 11 - TBRST"]
#[inline(always)]
pub fn tbrst(&self) -> TBRST_R {
TBRST_R::new(((self.bits >> 11) & 1) != 0)
}
#[doc = "Bit 12 - TBREP"]
#[inline(always)]
pub fn tbrep(&self) -> TBREP_R {
TBREP_R::new(((self.bits >> 12) & 1) != 0)
}
#[doc = "Bit 13 - TBCMP1"]
#[inline(always)]
pub fn tbcmp1(&self) -> TBCMP1_R {
TBCMP1_R::new(((self.bits >> 13) & 1) != 0)
}
#[doc = "Bit 14 - TBCMP2"]
#[inline(always)]
pub fn tbcmp2(&self) -> TBCMP2_R {
TBCMP2_R::new(((self.bits >> 14) & 1) != 0)
}
#[doc = "Bit 15 - TCRST"]
#[inline(always)]
pub fn tcrst(&self) -> TCRST_R {
TCRST_R::new(((self.bits >> 15) & 1) != 0)
}
#[doc = "Bit 16 - TCREP"]
#[inline(always)]
pub fn tcrep(&self) -> TCREP_R {
TCREP_R::new(((self.bits >> 16) & 1) != 0)
}
#[doc = "Bit 17 - TCCMP1"]
#[inline(always)]
pub fn tccmp1(&self) -> TCCMP1_R {
TCCMP1_R::new(((self.bits >> 17) & 1) != 0)
}
#[doc = "Bit 18 - TCCMP2"]
#[inline(always)]
pub fn tccmp2(&self) -> TCCMP2_R {
TCCMP2_R::new(((self.bits >> 18) & 1) != 0)
}
#[doc = "Bit 19 - TDRST"]
#[inline(always)]
pub fn tdrst(&self) -> TDRST_R {
TDRST_R::new(((self.bits >> 19) & 1) != 0)
}
#[doc = "Bit 20 - TDREP"]
#[inline(always)]
pub fn tdrep(&self) -> TDREP_R {
TDREP_R::new(((self.bits >> 20) & 1) != 0)
}
#[doc = "Bit 21 - TDCMP1"]
#[inline(always)]
pub fn tdcmp1(&self) -> TDCMP1_R {
TDCMP1_R::new(((self.bits >> 21) & 1) != 0)
}
#[doc = "Bit 22 - TDCMP2"]
#[inline(always)]
pub fn tdcmp2(&self) -> TDCMP2_R {
TDCMP2_R::new(((self.bits >> 22) & 1) != 0)
}
#[doc = "Bit 23 - TERST"]
#[inline(always)]
pub fn terst(&self) -> TERST_R {
TERST_R::new(((self.bits >> 23) & 1) != 0)
}
#[doc = "Bit 24 - TEREP"]
#[inline(always)]
pub fn terep(&self) -> TEREP_R {
TEREP_R::new(((self.bits >> 24) & 1) != 0)
}
#[doc = "Bit 25 - TECMP1"]
#[inline(always)]
pub fn tecmp1(&self) -> TECMP1_R {
TECMP1_R::new(((self.bits >> 25) & 1) != 0)
}
#[doc = "Bit 26 - TECMP2"]
#[inline(always)]
pub fn tecmp2(&self) -> TECMP2_R {
TECMP2_R::new(((self.bits >> 26) & 1) != 0)
}
#[doc = "Bit 31 - OCHPEV"]
#[inline(always)]
pub fn ochpev(&self) -> OCHPEV_R {
OCHPEV_R::new(((self.bits >> 31) & 1) != 0)
}
}
impl W {
#[doc = "Bit 0 - SW"]
#[inline(always)]
#[must_use]
pub fn sw(&mut self) -> SW_W<BMTRG_SPEC, 0> {
SW_W::new(self)
}
#[doc = "Bit 1 - MSTRST"]
#[inline(always)]
#[must_use]
pub fn mstrst(&mut self) -> MSTRST_W<BMTRG_SPEC, 1> {
MSTRST_W::new(self)
}
#[doc = "Bit 2 - MSTREP"]
#[inline(always)]
#[must_use]
pub fn mstrep(&mut self) -> MSTREP_W<BMTRG_SPEC, 2> {
MSTREP_W::new(self)
}
#[doc = "Bit 3 - MSTCMP1"]
#[inline(always)]
#[must_use]
pub fn mstcmp1(&mut self) -> MSTCMP1_W<BMTRG_SPEC, 3> {
MSTCMP1_W::new(self)
}
#[doc = "Bit 4 - MSTCMP2"]
#[inline(always)]
#[must_use]
pub fn mstcmp2(&mut self) -> MSTCMP2_W<BMTRG_SPEC, 4> {
MSTCMP2_W::new(self)
}
#[doc = "Bit 5 - MSTCMP3"]
#[inline(always)]
#[must_use]
pub fn mstcmp3(&mut self) -> MSTCMP3_W<BMTRG_SPEC, 5> {
MSTCMP3_W::new(self)
}
#[doc = "Bit 6 - MSTCMP4"]
#[inline(always)]
#[must_use]
pub fn mstcmp4(&mut self) -> MSTCMP4_W<BMTRG_SPEC, 6> {
MSTCMP4_W::new(self)
}
#[doc = "Bit 7 - TARST"]
#[inline(always)]
#[must_use]
pub fn tarst(&mut self) -> TARST_W<BMTRG_SPEC, 7> {
TARST_W::new(self)
}
#[doc = "Bit 8 - TAREP"]
#[inline(always)]
#[must_use]
pub fn tarep(&mut self) -> TAREP_W<BMTRG_SPEC, 8> {
TAREP_W::new(self)
}
#[doc = "Bit 9 - TACMP1"]
#[inline(always)]
#[must_use]
pub fn tacmp1(&mut self) -> TACMP1_W<BMTRG_SPEC, 9> {
TACMP1_W::new(self)
}
#[doc = "Bit 10 - TACMP2"]
#[inline(always)]
#[must_use]
pub fn tacmp2(&mut self) -> TACMP2_W<BMTRG_SPEC, 10> {
TACMP2_W::new(self)
}
#[doc = "Bit 11 - TBRST"]
#[inline(always)]
#[must_use]
pub fn tbrst(&mut self) -> TBRST_W<BMTRG_SPEC, 11> {
TBRST_W::new(self)
}
#[doc = "Bit 12 - TBREP"]
#[inline(always)]
#[must_use]
pub fn tbrep(&mut self) -> TBREP_W<BMTRG_SPEC, 12> {
TBREP_W::new(self)
}
#[doc = "Bit 13 - TBCMP1"]
#[inline(always)]
#[must_use]
pub fn tbcmp1(&mut self) -> TBCMP1_W<BMTRG_SPEC, 13> {
TBCMP1_W::new(self)
}
#[doc = "Bit 14 - TBCMP2"]
#[inline(always)]
#[must_use]
pub fn tbcmp2(&mut self) -> TBCMP2_W<BMTRG_SPEC, 14> {
TBCMP2_W::new(self)
}
#[doc = "Bit 15 - TCRST"]
#[inline(always)]
#[must_use]
pub fn tcrst(&mut self) -> TCRST_W<BMTRG_SPEC, 15> {
TCRST_W::new(self)
}
#[doc = "Bit 16 - TCREP"]
#[inline(always)]
#[must_use]
pub fn tcrep(&mut self) -> TCREP_W<BMTRG_SPEC, 16> {
TCREP_W::new(self)
}
#[doc = "Bit 17 - TCCMP1"]
#[inline(always)]
#[must_use]
pub fn tccmp1(&mut self) -> TCCMP1_W<BMTRG_SPEC, 17> {
TCCMP1_W::new(self)
}
#[doc = "Bit 18 - TCCMP2"]
#[inline(always)]
#[must_use]
pub fn tccmp2(&mut self) -> TCCMP2_W<BMTRG_SPEC, 18> {
TCCMP2_W::new(self)
}
#[doc = "Bit 19 - TDRST"]
#[inline(always)]
#[must_use]
pub fn tdrst(&mut self) -> TDRST_W<BMTRG_SPEC, 19> {
TDRST_W::new(self)
}
#[doc = "Bit 20 - TDREP"]
#[inline(always)]
#[must_use]
pub fn tdrep(&mut self) -> TDREP_W<BMTRG_SPEC, 20> {
TDREP_W::new(self)
}
#[doc = "Bit 21 - TDCMP1"]
#[inline(always)]
#[must_use]
pub fn tdcmp1(&mut self) -> TDCMP1_W<BMTRG_SPEC, 21> {
TDCMP1_W::new(self)
}
#[doc = "Bit 22 - TDCMP2"]
#[inline(always)]
#[must_use]
pub fn tdcmp2(&mut self) -> TDCMP2_W<BMTRG_SPEC, 22> {
TDCMP2_W::new(self)
}
#[doc = "Bit 23 - TERST"]
#[inline(always)]
#[must_use]
pub fn terst(&mut self) -> TERST_W<BMTRG_SPEC, 23> {
TERST_W::new(self)
}
#[doc = "Bit 24 - TEREP"]
#[inline(always)]
#[must_use]
pub fn terep(&mut self) -> TEREP_W<BMTRG_SPEC, 24> {
TEREP_W::new(self)
}
#[doc = "Bit 25 - TECMP1"]
#[inline(always)]
#[must_use]
pub fn tecmp1(&mut self) -> TECMP1_W<BMTRG_SPEC, 25> {
TECMP1_W::new(self)
}
#[doc = "Bit 26 - TECMP2"]
#[inline(always)]
#[must_use]
pub fn tecmp2(&mut self) -> TECMP2_W<BMTRG_SPEC, 26> {
TECMP2_W::new(self)
}
#[doc = "Bit 31 - OCHPEV"]
#[inline(always)]
#[must_use]
pub fn ochpev(&mut self) -> OCHPEV_W<BMTRG_SPEC, 31> {
OCHPEV_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "BMTRG\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`bmtrg::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bmtrg::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct BMTRG_SPEC;
impl crate::RegisterSpec for BMTRG_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`bmtrg::R`](R) reader structure"]
impl crate::Readable for BMTRG_SPEC {}
#[doc = "`write(|w| ..)` method takes [`bmtrg::W`](W) writer structure"]
impl crate::Writable for BMTRG_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets BMTRG to value 0"]
impl crate::Resettable for BMTRG_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use crate::app::UpdateResult as UR;
use crate::ui::{UpdateContext, Widget, WidgetInner};
use rider_config::ConfigAccess;
use sdl2::rect::{Point, Rect};
const ICON_DEST_WIDTH: u32 = 16;
const ICON_DEST_HEIGHT: u32 = 16;
const ICON_SRC_WIDTH: u32 = 16;
const ICON_SRC_HEIGHT: u32 = 16;
pub struct SettingsButton {
inner: WidgetInner,
}
impl std::ops::Deref for SettingsButton {
type Target = WidgetInner;
fn deref(&self) -> &Self::Target {
&self.inner
}
}
impl std::ops::DerefMut for SettingsButton {
fn deref_mut(&mut self) -> &mut Self::Target {
&mut self.inner
}
}
impl Widget for SettingsButton {
fn texture_path(&self) -> Option<String> {
let c = self.config.read().unwrap();
let mut themes_dir = c.directories().themes_dir.clone();
let path = c.theme().images().settings_icon();
themes_dir.push(path);
Some(themes_dir.to_str().unwrap().to_owned())
}
fn dest(&self) -> &Rect {
&self.dest
}
fn set_dest(&mut self, rect: &Rect) {
self.dest = rect.clone();
}
fn source(&self) -> &Rect {
&self.source
}
fn set_source(&mut self, rect: &Rect) {
self.source = rect.clone();
}
fn on_left_click(&mut self, _point: &Point, _context: &UpdateContext) -> UR {
UR::OpenSettings
}
fn padding_width(&self) -> u32 {
ICON_DEST_WIDTH
}
fn padding_height(&self) -> u32 {
ICON_DEST_HEIGHT
}
}
impl SettingsButton {
pub fn new(config: ConfigAccess) -> Self {
Self {
inner: WidgetInner::new(
config,
Rect::new(0, 0, ICON_SRC_WIDTH, ICON_SRC_HEIGHT),
Rect::new(0, 0, ICON_DEST_WIDTH, ICON_DEST_HEIGHT),
),
}
}
}
#[cfg(test)]
mod test {
use super::*;
use crate::app::UpdateResult;
use crate::tests::*;
#[test]
fn must_return_open_settings_on_left_click() {
let config = build_config();
let mut widget = SettingsButton::new(config);
assert_eq!(
widget.on_left_click(&Point::new(0, 0), &UpdateContext::Nothing),
UpdateResult::OpenSettings
);
}
#[test]
fn must_use_inner() {
let config = build_config();
let mut widget = SettingsButton::new(config);
assert_eq!(
widget.dest(),
&Rect::new(0, 0, ICON_DEST_WIDTH, ICON_DEST_HEIGHT)
);
widget.set_dest(&Rect::new(1, 2, 3, 4));
assert_eq!(widget.dest(), &Rect::new(1, 2, 3, 4));
assert_eq!(
widget.source(),
&Rect::new(0, 0, ICON_SRC_WIDTH, ICON_SRC_HEIGHT)
);
widget.set_source(&Rect::new(5, 6, 7, 8));
assert_eq!(widget.source(), &Rect::new(5, 6, 7, 8));
}
#[test]
fn must_have_padding() {
let config = build_config();
let widget = SettingsButton::new(config);
assert_eq!(widget.padding_width(), ICON_DEST_WIDTH);
assert_eq!(widget.padding_height(), ICON_DEST_HEIGHT);
}
}
|
#[doc = "Register `CR2` reader"]
pub type R = crate::R<CR2_SPEC>;
#[doc = "Register `CR2` writer"]
pub type W = crate::W<CR2_SPEC>;
#[doc = "Field `ADD` reader - Address of the USART node"]
pub type ADD_R = crate::FieldReader;
#[doc = "Field `ADD` writer - Address of the USART node"]
pub type ADD_W<'a, REG, const O: u8> = crate::FieldWriterSafe<'a, REG, 4, O>;
#[doc = "Field `LBDL` reader - lin break detection length"]
pub type LBDL_R = crate::BitReader<LBDL_A>;
#[doc = "lin break detection length\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LBDL_A {
#[doc = "0: 10-bit break detection"]
Lbdl10 = 0,
#[doc = "1: 11-bit break detection"]
Lbdl11 = 1,
}
impl From<LBDL_A> for bool {
#[inline(always)]
fn from(variant: LBDL_A) -> Self {
variant as u8 != 0
}
}
impl LBDL_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LBDL_A {
match self.bits {
false => LBDL_A::Lbdl10,
true => LBDL_A::Lbdl11,
}
}
#[doc = "10-bit break detection"]
#[inline(always)]
pub fn is_lbdl10(&self) -> bool {
*self == LBDL_A::Lbdl10
}
#[doc = "11-bit break detection"]
#[inline(always)]
pub fn is_lbdl11(&self) -> bool {
*self == LBDL_A::Lbdl11
}
}
#[doc = "Field `LBDL` writer - lin break detection length"]
pub type LBDL_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, LBDL_A>;
impl<'a, REG, const O: u8> LBDL_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "10-bit break detection"]
#[inline(always)]
pub fn lbdl10(self) -> &'a mut crate::W<REG> {
self.variant(LBDL_A::Lbdl10)
}
#[doc = "11-bit break detection"]
#[inline(always)]
pub fn lbdl11(self) -> &'a mut crate::W<REG> {
self.variant(LBDL_A::Lbdl11)
}
}
#[doc = "Field `LBDIE` reader - LIN break detection interrupt enable"]
pub type LBDIE_R = crate::BitReader<LBDIE_A>;
#[doc = "LIN break detection interrupt enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LBDIE_A {
#[doc = "0: LIN break detection interrupt disabled"]
Disabled = 0,
#[doc = "1: LIN break detection interrupt enabled"]
Enabled = 1,
}
impl From<LBDIE_A> for bool {
#[inline(always)]
fn from(variant: LBDIE_A) -> Self {
variant as u8 != 0
}
}
impl LBDIE_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LBDIE_A {
match self.bits {
false => LBDIE_A::Disabled,
true => LBDIE_A::Enabled,
}
}
#[doc = "LIN break detection interrupt disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == LBDIE_A::Disabled
}
#[doc = "LIN break detection interrupt enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == LBDIE_A::Enabled
}
}
#[doc = "Field `LBDIE` writer - LIN break detection interrupt enable"]
pub type LBDIE_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, LBDIE_A>;
impl<'a, REG, const O: u8> LBDIE_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "LIN break detection interrupt disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(LBDIE_A::Disabled)
}
#[doc = "LIN break detection interrupt enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(LBDIE_A::Enabled)
}
}
#[doc = "Field `STOP` reader - STOP bits"]
pub type STOP_R = crate::FieldReader<STOP_A>;
#[doc = "STOP bits\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(u8)]
pub enum STOP_A {
#[doc = "0: 1 stop bit"]
Stop1 = 0,
#[doc = "2: 2 stop bits"]
Stop2 = 2,
}
impl From<STOP_A> for u8 {
#[inline(always)]
fn from(variant: STOP_A) -> Self {
variant as _
}
}
impl crate::FieldSpec for STOP_A {
type Ux = u8;
}
impl STOP_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> Option<STOP_A> {
match self.bits {
0 => Some(STOP_A::Stop1),
2 => Some(STOP_A::Stop2),
_ => None,
}
}
#[doc = "1 stop bit"]
#[inline(always)]
pub fn is_stop1(&self) -> bool {
*self == STOP_A::Stop1
}
#[doc = "2 stop bits"]
#[inline(always)]
pub fn is_stop2(&self) -> bool {
*self == STOP_A::Stop2
}
}
#[doc = "Field `STOP` writer - STOP bits"]
pub type STOP_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 2, O, STOP_A>;
impl<'a, REG, const O: u8> STOP_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
REG::Ux: From<u8>,
{
#[doc = "1 stop bit"]
#[inline(always)]
pub fn stop1(self) -> &'a mut crate::W<REG> {
self.variant(STOP_A::Stop1)
}
#[doc = "2 stop bits"]
#[inline(always)]
pub fn stop2(self) -> &'a mut crate::W<REG> {
self.variant(STOP_A::Stop2)
}
}
#[doc = "Field `LINEN` reader - LIN mode enable"]
pub type LINEN_R = crate::BitReader<LINEN_A>;
#[doc = "LIN mode enable\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LINEN_A {
#[doc = "0: LIN mode disabled"]
Disabled = 0,
#[doc = "1: LIN mode enabled"]
Enabled = 1,
}
impl From<LINEN_A> for bool {
#[inline(always)]
fn from(variant: LINEN_A) -> Self {
variant as u8 != 0
}
}
impl LINEN_R {
#[doc = "Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> LINEN_A {
match self.bits {
false => LINEN_A::Disabled,
true => LINEN_A::Enabled,
}
}
#[doc = "LIN mode disabled"]
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == LINEN_A::Disabled
}
#[doc = "LIN mode enabled"]
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == LINEN_A::Enabled
}
}
#[doc = "Field `LINEN` writer - LIN mode enable"]
pub type LINEN_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O, LINEN_A>;
impl<'a, REG, const O: u8> LINEN_W<'a, REG, O>
where
REG: crate::Writable + crate::RegisterSpec,
{
#[doc = "LIN mode disabled"]
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(LINEN_A::Disabled)
}
#[doc = "LIN mode enabled"]
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(LINEN_A::Enabled)
}
}
impl R {
#[doc = "Bits 0:3 - Address of the USART node"]
#[inline(always)]
pub fn add(&self) -> ADD_R {
ADD_R::new((self.bits & 0x0f) as u8)
}
#[doc = "Bit 5 - lin break detection length"]
#[inline(always)]
pub fn lbdl(&self) -> LBDL_R {
LBDL_R::new(((self.bits >> 5) & 1) != 0)
}
#[doc = "Bit 6 - LIN break detection interrupt enable"]
#[inline(always)]
pub fn lbdie(&self) -> LBDIE_R {
LBDIE_R::new(((self.bits >> 6) & 1) != 0)
}
#[doc = "Bits 12:13 - STOP bits"]
#[inline(always)]
pub fn stop(&self) -> STOP_R {
STOP_R::new(((self.bits >> 12) & 3) as u8)
}
#[doc = "Bit 14 - LIN mode enable"]
#[inline(always)]
pub fn linen(&self) -> LINEN_R {
LINEN_R::new(((self.bits >> 14) & 1) != 0)
}
}
impl W {
#[doc = "Bits 0:3 - Address of the USART node"]
#[inline(always)]
#[must_use]
pub fn add(&mut self) -> ADD_W<CR2_SPEC, 0> {
ADD_W::new(self)
}
#[doc = "Bit 5 - lin break detection length"]
#[inline(always)]
#[must_use]
pub fn lbdl(&mut self) -> LBDL_W<CR2_SPEC, 5> {
LBDL_W::new(self)
}
#[doc = "Bit 6 - LIN break detection interrupt enable"]
#[inline(always)]
#[must_use]
pub fn lbdie(&mut self) -> LBDIE_W<CR2_SPEC, 6> {
LBDIE_W::new(self)
}
#[doc = "Bits 12:13 - STOP bits"]
#[inline(always)]
#[must_use]
pub fn stop(&mut self) -> STOP_W<CR2_SPEC, 12> {
STOP_W::new(self)
}
#[doc = "Bit 14 - LIN mode enable"]
#[inline(always)]
#[must_use]
pub fn linen(&mut self) -> LINEN_W<CR2_SPEC, 14> {
LINEN_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "Control register 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cr2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cr2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct CR2_SPEC;
impl crate::RegisterSpec for CR2_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`cr2::R`](R) reader structure"]
impl crate::Readable for CR2_SPEC {}
#[doc = "`write(|w| ..)` method takes [`cr2::W`](W) writer structure"]
impl crate::Writable for CR2_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets CR2 to value 0"]
impl crate::Resettable for CR2_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use combat_action::Action;
use unit_base::CanAttack;
use rand::{thread_rng, Rng};
pub fn get_player_actions() -> Vec<Action> {
let player_fight = Action {
group_id: 0,
action: Box::new(move |player, enemy| {
let mut rng = thread_rng();
let outgoing_damage = rng.gen_range(2,5);
let damage_dealt = player.attack_target(enemy, outgoing_damage);
return Some(damage_dealt);
}),
description: "You attack {0}, and deal {1} damage!".to_string()
};
let player_actions = vec![player_fight];
return player_actions;
} |
// Copyright (c) The Starcoin Core Contributors
// SPDX-License-Identifier: Apache-2.0
//use anyhow::Result;
use anyhow::Result;
use libra_types::account_address::AccountAddress;
use network_libp2p::PeerId;
use std::{
convert::TryFrom,
str::FromStr,
time::{SystemTime, UNIX_EPOCH},
};
pub fn convert_peer_id_to_account_address(peer_id: &PeerId) -> Result<AccountAddress> {
let peer_id_bytes = &peer_id.as_bytes()[2..];
AccountAddress::try_from(peer_id_bytes)
}
pub fn convert_account_address_to_peer_id(
address: AccountAddress,
) -> std::result::Result<PeerId, Vec<u8>> {
let mut peer_id_vec = address.to_vec();
peer_id_vec.insert(0, 32);
peer_id_vec.insert(0, 22);
PeerId::from_bytes(peer_id_vec)
}
pub fn convert_boot_nodes(boot_nodes: Vec<String>) -> Vec<String> {
boot_nodes
.iter()
.map(|x| {
let dx = x.rfind("/").expect("Failed to parse boot nodes");
let account_address = &x[dx + 1..];
let addr = &x[..dx];
let peer_id = convert_account_address_to_peer_id(
AccountAddress::from_str(account_address).expect("Failed to parse account address"),
)
.expect("Failed to parse account address");
format!("{:}/{:}", addr, peer_id).to_string()
})
.clone()
.collect()
}
pub fn get_unix_ts() -> u128 {
let start = SystemTime::now();
let since_the_epoch = start
.duration_since(UNIX_EPOCH)
.expect("Time went backwards");
since_the_epoch.as_nanos()
}
|
use std::{collections::HashSet, i32};
#[aoc_generator(day1, part2)]
pub fn input_gen(input: &str) -> Vec<i32> {
input.lines().map(|l| l.parse::<i32>().unwrap()).collect()
}
#[aoc(day1, part1)]
pub fn solve_part1(input: &str) -> i32 {
input.lines().map(|l| l.parse::<i32>().unwrap()).sum()
}
#[aoc(day1, part2)]
pub fn solve_part2(input: &[i32]) -> i32 {
let mut set = HashSet::new();
let mut freq = 0;
set.insert(freq);
for change in input.iter().cycle() {
freq += change;
if set.contains(&freq) {
break;
}
set.insert(freq);
}
return freq;
}
#[cfg(test)]
mod tests {
use super::{input_gen, solve_part1, solve_part2};
#[test]
fn should_return_3() {
let input = "0\n-2\n5";
assert_eq!(3, solve_part1(input));
}
#[test]
fn should_return_55() {
let data = vec!["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"];
let input = data.join("\n");
assert_eq!((10 * 11) / 2, solve_part1(&input));
}
// part 2 tests
#[test]
fn should_return_0() {
let data = vec!["1", "-1"];
let data = data.join("\n");
let input = input_gen(&data);
assert_eq!(0, solve_part2(&input));
}
#[test]
fn should_return_10() {
let input = vec![3, 3, 4, -2, -4];
assert_eq!(10, solve_part2(&input));
}
#[test]
fn should_return_14() {
let input = vec![7, 7, -2, -7, -4];
assert_eq!(14, solve_part2(&input));
}
}
|
use crate::game::game::*;
use crate::output::export::*;
pub fn gradient_descent(game: &mut Game) {
let learning_rate: f64 = 0.01;
if game.step_nb < 1000 {
game.step_nb += 1;
let (srs_b_d, srs_m_d): (f64, f64) = calculate_srs_derivative(game);
let b_step_size: f64 = srs_b_d * learning_rate;
let m_step_size: f64 = srs_m_d * learning_rate;
if b_step_size.abs() <= 0.001 && m_step_size.abs() <= 0.001 {
export_to_file(&game);
game.linear_regression_finshed = true;
}
game.b -= b_step_size;
game.m -= m_step_size;
}
}
fn calculate_srs_derivative(game: &mut Game) -> (f64, f64) {
let mut srs_b_d: f64 = 0.0;
let mut srs_m_d: f64 = 0.0;
let mut srs_b: f64 = 0.0;
let mut srs_m: f64 = 0.0;
for data in game.dataset.iter() {
let guess = game.b + game.m * data.x;
let error = data.y - guess;
srs_b += error * error;
srs_m += (data.x * error) * (data.x * error);
srs_b_d += -2.0 * error;
srs_m_d += -2.0 * data.x * error;
}
game.srs_b_list.push(srs_b);
game.srs_m_list.push(srs_m);
return (srs_b_d, srs_m_d);
} |
#[doc = "Register `EXTICR2` reader"]
pub type R = crate::R<EXTICR2_SPEC>;
#[doc = "Register `EXTICR2` writer"]
pub type W = crate::W<EXTICR2_SPEC>;
#[doc = "Field `EXTI4` reader - EXTI x configuration (x = 4 to 7)"]
pub type EXTI4_R = crate::FieldReader;
#[doc = "Field `EXTI4` writer - EXTI x configuration (x = 4 to 7)"]
pub type EXTI4_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 4, O>;
#[doc = "Field `EXTI5` reader - EXTI x configuration (x = 4 to 7)"]
pub type EXTI5_R = crate::FieldReader;
#[doc = "Field `EXTI5` writer - EXTI x configuration (x = 4 to 7)"]
pub type EXTI5_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 4, O>;
#[doc = "Field `EXTI6` reader - EXTI x configuration (x = 4 to 7)"]
pub type EXTI6_R = crate::FieldReader;
#[doc = "Field `EXTI6` writer - EXTI x configuration (x = 4 to 7)"]
pub type EXTI6_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 4, O>;
#[doc = "Field `EXTI7` reader - EXTI x configuration (x = 4 to 7)"]
pub type EXTI7_R = crate::FieldReader;
#[doc = "Field `EXTI7` writer - EXTI x configuration (x = 4 to 7)"]
pub type EXTI7_W<'a, REG, const O: u8> = crate::FieldWriter<'a, REG, 4, O>;
impl R {
#[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
pub fn exti4(&self) -> EXTI4_R {
EXTI4_R::new((self.bits & 0x0f) as u8)
}
#[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
pub fn exti5(&self) -> EXTI5_R {
EXTI5_R::new(((self.bits >> 4) & 0x0f) as u8)
}
#[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
pub fn exti6(&self) -> EXTI6_R {
EXTI6_R::new(((self.bits >> 8) & 0x0f) as u8)
}
#[doc = "Bits 12:15 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
pub fn exti7(&self) -> EXTI7_R {
EXTI7_R::new(((self.bits >> 12) & 0x0f) as u8)
}
}
impl W {
#[doc = "Bits 0:3 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
#[must_use]
pub fn exti4(&mut self) -> EXTI4_W<EXTICR2_SPEC, 0> {
EXTI4_W::new(self)
}
#[doc = "Bits 4:7 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
#[must_use]
pub fn exti5(&mut self) -> EXTI5_W<EXTICR2_SPEC, 4> {
EXTI5_W::new(self)
}
#[doc = "Bits 8:11 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
#[must_use]
pub fn exti6(&mut self) -> EXTI6_W<EXTICR2_SPEC, 8> {
EXTI6_W::new(self)
}
#[doc = "Bits 12:15 - EXTI x configuration (x = 4 to 7)"]
#[inline(always)]
#[must_use]
pub fn exti7(&mut self) -> EXTI7_W<EXTICR2_SPEC, 12> {
EXTI7_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "external interrupt configuration register 2\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`exticr2::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`exticr2::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct EXTICR2_SPEC;
impl crate::RegisterSpec for EXTICR2_SPEC {
type Ux = u32;
}
#[doc = "`read()` method returns [`exticr2::R`](R) reader structure"]
impl crate::Readable for EXTICR2_SPEC {}
#[doc = "`write(|w| ..)` method takes [`exticr2::W`](W) writer structure"]
impl crate::Writable for EXTICR2_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets EXTICR2 to value 0"]
impl crate::Resettable for EXTICR2_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
#[doc = "Reader of register UART_CTRL"]
pub type R = crate::R<u32, super::UART_CTRL>;
#[doc = "Writer for register UART_CTRL"]
pub type W = crate::W<u32, super::UART_CTRL>;
#[doc = "Register UART_CTRL `reset()`'s with value 0x0300_0000"]
impl crate::ResetValue for super::UART_CTRL {
type Type = u32;
#[inline(always)]
fn reset_value() -> Self::Type {
0x0300_0000
}
}
#[doc = "Reader of field `LOOPBACK`"]
pub type LOOPBACK_R = crate::R<bool, bool>;
#[doc = "Write proxy for field `LOOPBACK`"]
pub struct LOOPBACK_W<'a> {
w: &'a mut W,
}
impl<'a> LOOPBACK_W<'a> {
#[doc = r"Sets the field bit"]
#[inline(always)]
pub fn set_bit(self) -> &'a mut W {
self.bit(true)
}
#[doc = r"Clears the field bit"]
#[inline(always)]
pub fn clear_bit(self) -> &'a mut W {
self.bit(false)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub fn bit(self, value: bool) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
self.w
}
}
#[doc = "N/A\n\nValue on reset: 3"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum MODE_A {
#[doc = "0: N/A"]
UART_STD,
#[doc = "1: N/A"]
UART_SMARTCARD,
#[doc = "2: Infrared Data Association (IrDA) submode. Return to Zero modulation scheme. In this mode, the oversampling factor should be 16, that is OVS should be set to 15."]
UART_IRDA,
}
impl From<MODE_A> for u8 {
#[inline(always)]
fn from(variant: MODE_A) -> Self {
match variant {
MODE_A::UART_STD => 0,
MODE_A::UART_SMARTCARD => 1,
MODE_A::UART_IRDA => 2,
}
}
}
#[doc = "Reader of field `MODE`"]
pub type MODE_R = crate::R<u8, MODE_A>;
impl MODE_R {
#[doc = r"Get enumerated values variant"]
#[inline(always)]
pub fn variant(&self) -> crate::Variant<u8, MODE_A> {
use crate::Variant::*;
match self.bits {
0 => Val(MODE_A::UART_STD),
1 => Val(MODE_A::UART_SMARTCARD),
2 => Val(MODE_A::UART_IRDA),
i => Res(i),
}
}
#[doc = "Checks if the value of the field is `UART_STD`"]
#[inline(always)]
pub fn is_uart_std(&self) -> bool {
*self == MODE_A::UART_STD
}
#[doc = "Checks if the value of the field is `UART_SMARTCARD`"]
#[inline(always)]
pub fn is_uart_smartcard(&self) -> bool {
*self == MODE_A::UART_SMARTCARD
}
#[doc = "Checks if the value of the field is `UART_IRDA`"]
#[inline(always)]
pub fn is_uart_irda(&self) -> bool {
*self == MODE_A::UART_IRDA
}
}
#[doc = "Write proxy for field `MODE`"]
pub struct MODE_W<'a> {
w: &'a mut W,
}
impl<'a> MODE_W<'a> {
#[doc = r"Writes `variant` to the field"]
#[inline(always)]
pub fn variant(self, variant: MODE_A) -> &'a mut W {
unsafe { self.bits(variant.into()) }
}
#[doc = "N/A"]
#[inline(always)]
pub fn uart_std(self) -> &'a mut W {
self.variant(MODE_A::UART_STD)
}
#[doc = "N/A"]
#[inline(always)]
pub fn uart_smartcard(self) -> &'a mut W {
self.variant(MODE_A::UART_SMARTCARD)
}
#[doc = "Infrared Data Association (IrDA) submode. Return to Zero modulation scheme. In this mode, the oversampling factor should be 16, that is OVS should be set to 15."]
#[inline(always)]
pub fn uart_irda(self) -> &'a mut W {
self.variant(MODE_A::UART_IRDA)
}
#[doc = r"Writes raw bits to the field"]
#[inline(always)]
pub unsafe fn bits(self, value: u8) -> &'a mut W {
self.w.bits = (self.w.bits & !(0x03 << 24)) | (((value as u32) & 0x03) << 24);
self.w
}
}
impl R {
#[doc = "Bit 16 - Local loopback control (does NOT affect the information on the pins). 0: Loopback is not enabled 1: UART_TX is connected to UART_RX. UART_RTS is connected to UART_CTS. This allows a SCB UART transmitter to communicate with its receiver counterpart."]
#[inline(always)]
pub fn loopback(&self) -> LOOPBACK_R {
LOOPBACK_R::new(((self.bits >> 16) & 0x01) != 0)
}
#[doc = "Bits 24:25 - N/A"]
#[inline(always)]
pub fn mode(&self) -> MODE_R {
MODE_R::new(((self.bits >> 24) & 0x03) as u8)
}
}
impl W {
#[doc = "Bit 16 - Local loopback control (does NOT affect the information on the pins). 0: Loopback is not enabled 1: UART_TX is connected to UART_RX. UART_RTS is connected to UART_CTS. This allows a SCB UART transmitter to communicate with its receiver counterpart."]
#[inline(always)]
pub fn loopback(&mut self) -> LOOPBACK_W {
LOOPBACK_W { w: self }
}
#[doc = "Bits 24:25 - N/A"]
#[inline(always)]
pub fn mode(&mut self) -> MODE_W {
MODE_W { w: self }
}
}
|
use pulldown_cmark::{Options, Parser};
use super::front_matter::FrontMatter;
#[derive(Debug, Clone)]
pub struct Note {
pub front_matter: FrontMatter,
pub content: String
}
impl Default for Note {
fn default() -> Self {
Self {
front_matter: FrontMatter::default(),
content: String::new()
}
}
}
impl Note {
pub fn new<S: Into<String>>(front_matter: FrontMatter, content: S) -> Self {
Self { front_matter, content: content.into() }
}
pub fn from_text<S>(text: S) -> Note where S: AsRef<str> {
let lines = text.as_ref().lines();
let mut front_matter = vec![];
let mut content = vec![];
let mut in_front_matter = false;
lines.enumerate().for_each(|(pos, line)| {
content.push(line);
if pos != 0 && line.trim() == "---" && in_front_matter {
in_front_matter = false;
content.clear();
}
if in_front_matter { front_matter.push(line); }
if pos == 0 && line.trim() == "---" { in_front_matter = true; }
});
// The front matter section hasn't been closed
if in_front_matter == true { front_matter.clear(); }
let cont = content.join("\n");
// Front Matter
let mut fm = match serde_yaml::from_str(front_matter.join("\n").as_str()) {
Ok(f) => f,
Err(_) => FrontMatter::default()
};
if fm.title == None {
let title = extract_title(&cont);
fm.title = Some(title);
}
Note::new(fm, cont)
}
pub fn to_text(&self) -> String {
let mut text = String::new();
let front_matter_text = match serde_yaml::to_string(&self.front_matter) {
Ok(fm_text) => fm_text,
Err(_e) => String::new()
};
text.push_str(&front_matter_text);
text.push_str("---\n");
text.push_str(&self.content);
text
}
pub fn get_title(&self) -> String {
match &self.front_matter.title {
Some(title) => title.clone(),
None => extract_title(&self.content)
}
}
}
fn extract_title<S>(note_text: S) -> String where S: AsRef<str> {
let mut options = Options::empty();
options.insert(Options::ENABLE_STRIKETHROUGH);
for line in note_text.as_ref().lines() {
let parser = Parser::new_ext(line, options);
let mut buffer = String::new();
for event in parser {
match event {
pulldown_cmark::Event::Text(text) => buffer.push_str(&text),
pulldown_cmark::Event::Code(text) => buffer.push_str(&text),
_ => {}
}
}
buffer = get_first_sentence(buffer);
if !buffer.is_empty() {
return buffer;
}
}
"untitled".to_string()
}
fn get_first_sentence<S>(text: S) -> String where S: AsRef<str> {
let sentence_separators = [ '.', '!', '?', '(' ];
let line = text.as_ref();
let mut start_index = 0;
for (index, c) in line.chars().enumerate() {
if !sentence_separators.contains(&c) {
start_index = index;
break;
}
}
let end_of_sentence = line[start_index..].find(|ref c| {
sentence_separators.contains(c)
});
if let Some(index) = end_of_sentence {
line[start_index..index + start_index].trim().to_string()
} else {
line.trim().to_string()
}
}
#[cfg(test)]
mod test {
use chrono::{NaiveDate, NaiveTime};
use super::Note;
#[test]
fn detects_front_matter() {
let text =
r#"---
title: test note
date: 2021-03-28
time: 17:08:13
---
```
This is a demo note.
```
With more than one line
Actually three.
And an extra line break.
"#;
let note = Note::from_text(text);
assert_eq!(Some("test note".to_string()), note.front_matter.title);
assert_eq!(NaiveDate::from_ymd(2021, 03, 28), note.front_matter.date);
assert_eq!(NaiveTime::from_hms(17, 08, 13), note.front_matter.time);
println!("{}", ¬e.content);
}
#[test]
fn detects_title() {
let text =
r#"```
This is a demo note.
```
With more than one line
Actually three.
And an extra line break.
"#;
let note = Note::from_text(text);
assert_eq!(Some("This is a demo note".to_string()), note.front_matter.title);
}
#[test]
fn detects_title_with_two_sentences() {
let text =
r#"```
This is a demo note. With two sentences.
```
With more than one line
Actually three.
And an extra line break.
"#;
let note = Note::from_text(text);
assert_eq!(Some("This is a demo note".to_string()), note.front_matter.title);
}
#[test]
fn detects_title_with_starting_periods() {
let text =
r#"
... This is a demo note. With two sentences. And three starting periods.
With more than one line
Actually three.
And an extra line break.
"#;
let note = Note::from_text(text);
assert_eq!(Some("This is a demo note".to_string()), note.front_matter.title);
}
#[test]
fn detects_title_with_starting_invalid_line() {
let text =
r#"
...???
... This is a demo note. With two sentences. And three starting periods.
With more than one line
Actually three.
And an extra line break.
"#;
let note = Note::from_text(text);
assert_eq!(Some("This is a demo note".to_string()), note.front_matter.title);
}
} |
pub fn autogenerate_task_name(current_date: chrono::Date<chrono::Local>) -> String {
current_date.format("task_%Y%m%d").to_string()
}
#[cfg(test)]
mod tests {
use super::*;
use chrono::Local;
use chrono::TimeZone;
#[test]
fn test_autogenerate_task_name() {
let mut dt = Local.ymd(1970, 1, 1);
assert_eq!(autogenerate_task_name(dt), "task_19700101");
dt = Local.ymd(2021, 5, 20);
assert_eq!(autogenerate_task_name(dt), "task_20210520");
}
}
|
use tokio::fs::File;
use super::consts::paths::CACHE_DIR_PATH;
#[cfg(test)]
mod tests;
pub async fn extract_tar(file_path: &str) -> Result<(), std::io::Error> {
use flate2::read::GzDecoder;
use tar::Archive;
let tar = File::open(file_path).await?.try_into_std().unwrap();
let tar = GzDecoder::new(tar);
let mut archive = Archive::new(tar);
archive.unpack(CACHE_DIR_PATH.as_path())
}
pub async fn extract_zip(file_path: &str) -> Result<(), std::io::Error> {
use zip::ZipArchive;
let file = File::open(file_path).await?.into_std().await;
let mut zip = ZipArchive::new(file)?;
for i in 0..zip.len() {
let arch_file = zip.by_index(i)?;
println!("{}", arch_file.name());
}
unimplemented!();
Ok(())
}
|
struct Point {
x: f64,
y: f64,
}
enum MaybePoint { ThePoint(Point), Nil, }
fn main() {
let p1 = Point{x: 1.0, y: 2.0,};
let p2 = box() Point{x: 3.0, y: 4.0,};
let p3 = ThePoint(Point{x: 5.0, y: 6.0,});
let p4 = box() ThePoint(Point{x: 5.0, y: 6.0,});
println!("Point on stack: {}" , & p1);
println!("Point on heap: {}" , & p2);
println!("MaybePoint on stack: {}" , & p3);
println!("MaybePoint on heap: {}" , & p4);
}
|
#[doc = "Register `BSRR` writer"]
pub type W = crate::W<BSRR_SPEC>;
#[doc = "Field `BS0` writer - Port x set bit y (y= 0..15)"]
pub type BS0_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `BS1` writer - Port x set bit y (y= 0..15)"]
pub type BS1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `BS3` writer - Port x set bit y (y= 0..15)"]
pub type BS3_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `BR0` writer - Port x set bit y (y= 0..15)"]
pub type BR0_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `BR1` writer - Port x reset bit y (y = 0..15)"]
pub type BR1_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
#[doc = "Field `BR3` writer - Port x reset bit y (y = 0..15)"]
pub type BR3_W<'a, REG, const O: u8> = crate::BitWriter<'a, REG, O>;
impl W {
#[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
#[inline(always)]
#[must_use]
pub fn bs0(&mut self) -> BS0_W<BSRR_SPEC, 0> {
BS0_W::new(self)
}
#[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
#[inline(always)]
#[must_use]
pub fn bs1(&mut self) -> BS1_W<BSRR_SPEC, 1> {
BS1_W::new(self)
}
#[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
#[inline(always)]
#[must_use]
pub fn bs3(&mut self) -> BS3_W<BSRR_SPEC, 3> {
BS3_W::new(self)
}
#[doc = "Bit 16 - Port x set bit y (y= 0..15)"]
#[inline(always)]
#[must_use]
pub fn br0(&mut self) -> BR0_W<BSRR_SPEC, 16> {
BR0_W::new(self)
}
#[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
#[inline(always)]
#[must_use]
pub fn br1(&mut self) -> BR1_W<BSRR_SPEC, 17> {
BR1_W::new(self)
}
#[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
#[inline(always)]
#[must_use]
pub fn br3(&mut self) -> BR3_W<BSRR_SPEC, 19> {
BR3_W::new(self)
}
#[doc = "Writes raw bits to the register."]
#[inline(always)]
pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
self.bits = bits;
self
}
}
#[doc = "GPIO port bit set/reset register\n\nYou can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`bsrr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
pub struct BSRR_SPEC;
impl crate::RegisterSpec for BSRR_SPEC {
type Ux = u32;
}
#[doc = "`write(|w| ..)` method takes [`bsrr::W`](W) writer structure"]
impl crate::Writable for BSRR_SPEC {
const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
}
#[doc = "`reset()` method sets BSRR to value 0"]
impl crate::Resettable for BSRR_SPEC {
const RESET_VALUE: Self::Ux = 0;
}
|
use core::convert::TryInto;
use atat::AtatClient;
use embedded_hal::digital::{InputPin, OutputPin};
use embedded_time::{duration::*, Clock};
use heapless::{ArrayLength, Bucket, Pos};
use crate::{
client::Device,
command::{
mobile_control::{types::Functionality, ModuleSwitchOff, SetModuleFunctionality},
system_features::{
types::{FSFactoryRestoreType, NVMFactoryRestoreType},
SetFactoryConfiguration,
},
AT,
},
error::{Error, GenericError},
sockets::Socket,
};
#[derive(Debug, Clone, Copy, PartialEq, Eq, defmt::Format)]
pub enum PowerState {
Unknown,
Off,
On,
TransientOff,
TransientOn,
}
impl<C, CLK, N, L, RST, DTR, PWR, VINT> Device<C, CLK, N, L, RST, DTR, PWR, VINT>
where
C: AtatClient,
CLK: Clock,
RST: OutputPin,
PWR: OutputPin,
DTR: OutputPin,
VINT: InputPin,
N: ArrayLength<Option<Socket<L, CLK>>>
+ ArrayLength<Bucket<u8, usize>>
+ ArrayLength<Option<Pos>>,
L: ArrayLength<u8>,
{
/// Check that the cellular module is alive.
///
/// See if the cellular module is responding at the AT interface by poking
/// it with "AT" up to `attempts` times, waiting 1 second for an "OK"
/// response each time
pub(crate) fn is_alive(&self, attempts: u8) -> Result<(), Error> {
let mut error = Error::BaudDetection;
for _ in 0..attempts {
match self.network.send_internal(&AT, false) {
Ok(_) => {
return Ok(());
}
Err(e) => error = e.into(),
};
}
Err(error)
}
/// Perform at full factory reset of the module, clearing all NVM sectors in the process
pub fn factory_reset(&mut self) -> Result<(), Error>
where
Generic<CLK::T>: TryInto<Milliseconds>,
{
self.network.send_internal(
&SetFactoryConfiguration {
fs_op: FSFactoryRestoreType::AllFiles,
nvm_op: NVMFactoryRestoreType::NVMFlashSectors,
},
false,
)?;
defmt::info!("Successfully factory reset modem!");
if self.soft_reset(true).is_err() {
self.hard_reset()?;
}
Ok(())
}
/// Reset the module by sending AT CFUN command
pub(crate) fn soft_reset(&mut self, sim_reset: bool) -> Result<(), Error>
where
Generic<CLK::T>: TryInto<Milliseconds>,
{
defmt::trace!(
"Attempting to soft reset of the modem with sim reset: {}.",
sim_reset
);
let fun = if sim_reset {
Functionality::SilentResetWithSimReset
} else {
Functionality::SilentReset
};
self.network
.send_internal(&SetModuleFunctionality { fun, rst: None }, false)?;
self.wait_power_state(PowerState::On, 30_000u32.milliseconds())?;
Ok(())
}
/// Reset the module by driving it's RESET_N pin low for 50 ms
///
/// **NOTE** This function will reset NVM settings!
pub fn hard_reset(&mut self) -> Result<(), Error>
where
Generic<CLK::T>: TryInto<Milliseconds>,
{
defmt::trace!("Attempting to hard reset of the modem.");
match self.config.rst_pin {
Some(ref mut rst) => {
// Apply Low pulse on RESET_N for 50 milliseconds to reset
rst.try_set_low().ok();
self.network
.status
.try_borrow()?
.timer
.new_timer(50.milliseconds())
.start()?
.wait()?;
rst.try_set_high().ok();
self.network
.status
.try_borrow()?
.timer
.new_timer(1.seconds())
.start()?
.wait()?;
}
None => {}
}
self.power_state = PowerState::Off;
self.power_on()?;
Ok(())
}
pub fn power_on(&mut self) -> Result<(), Error>
where
Generic<CLK::T>: TryInto<Milliseconds>,
{
defmt::info!(
"Attempting to power on the modem with PWR_ON pin: {=bool} and VInt pin: {=bool}.",
self.config.pwr_pin.is_some(),
self.config.vint_pin.is_some(),
);
if self.power_state()? != PowerState::On {
defmt::trace!("Powering modem on.");
match self.config.pwr_pin {
// Apply Low pulse on PWR_ON for 50 microseconds to power on
Some(ref mut pwr) => {
pwr.try_set_low().ok();
self.network
.status
.try_borrow()?
.timer
.new_timer(50.microseconds())
.start()?
.wait()?;
pwr.try_set_high().ok();
self.network
.status
.try_borrow()?
.timer
.new_timer(1.seconds())
.start()?
.wait()?;
if let Err(e) = self.wait_power_state(PowerState::On, 5_000u32.milliseconds()) {
defmt::error!("Failed to power on modem");
return Err(e);
} else {
defmt::trace!("Modem powered on");
}
}
_ => {
// Software restart
if self.soft_reset(false).is_err() {
self.hard_reset()?;
}
}
}
} else {
defmt::debug!("module is already on");
}
Ok(())
}
pub fn soft_power_off(&mut self) -> Result<(), Error> {
defmt::trace!("Attempting to soft power off the modem.");
self.network.send_internal(&ModuleSwitchOff, false)?;
self.power_state = PowerState::Off;
defmt::trace!("Modem powered off");
self.network
.status
.try_borrow()?
.timer
.new_timer(10.seconds())
.start()?
.wait()?;
Ok(())
}
pub fn hard_power_off(&mut self) -> Result<(), Error> {
defmt::trace!("Attempting to hard power off the modem.");
if self.power_state()? == PowerState::On {
match self.config.pwr_pin {
Some(ref mut pwr) => {
// Apply Low pulse on PWR_ON >= 1 second to power off
pwr.try_set_low().ok();
self.network
.status
.try_borrow()?
.timer
.new_timer(1.seconds())
.start()?
.wait()?;
pwr.try_set_high().ok();
self.power_state = PowerState::Off;
defmt::trace!("Modem powered off");
self.network
.status
.try_borrow()?
.timer
.new_timer(10.seconds())
.start()?
.wait()?;
}
_ => {
return Err(Error::Generic(GenericError::Unsupported));
}
}
}
Ok(())
}
/// Check the power state of the module, by probing `Vint` pin if available,
/// fallbacking to checking for AT responses through `is_alive`
pub fn power_state(&mut self) -> Result<PowerState, Error> {
match self.config.vint_pin {
Some(ref mut vint) => {
if vint
.try_is_high()
.map_err(|_| Error::Generic(GenericError::Unsupported))?
{
Ok(PowerState::On)
} else {
Ok(PowerState::Off)
}
}
_ => Ok(self.is_alive(2).map_or(PowerState::Off, |_| PowerState::On)),
}
}
/// Wait for the power state to change into `expected`, with a timeout
fn wait_power_state(
&mut self,
expected: PowerState,
timeout: Milliseconds<u32>,
) -> Result<(), Error>
where
Generic<CLK::T>: TryInto<Milliseconds>,
{
let now = self.network.status.try_borrow()?.timer.try_now().unwrap();
let mut res = false;
defmt::trace!("Waiting for the modem to reach {}.", expected);
while self
.network
.status
.try_borrow()?
.timer
.try_now()
.ok()
.and_then(|ms| ms.checked_duration_since(&now))
.and_then(|dur| dur.try_into().ok())
.unwrap()
< timeout
{
if self.power_state()? == expected {
res = true;
break;
}
self.network
.status
.try_borrow()?
.timer
.new_timer(5.milliseconds())
.start()?
.wait()?;
}
if res {
defmt::trace!("Success.");
Ok(())
} else {
defmt::error!("Modem never reach {}.", expected);
Err(Error::Generic(GenericError::Timeout))
}
}
}
|
use std::collections::HashMap;
fn main() {
// Vectors have their own methods and are basically like arrays.
let mut my_vec: Vec<i32> = Vec::new();
let my_vec_from_macro = vec![1, 2, 3, 4];
//let dne = my_vec_from_macro[100];
let mut scores = HashMap::new();
scores.insert(String::from("Blue Team"), 89);
scores.insert(String::from("Red Team"), 10);
// The Key and Value can be iterated over a for loop like so:
for (k, v) in &scores {
println!("{}: {}", k, v);
}
// VERY POWERFUL EXAMPLE OF HASH MAP AND .entry() function to count
// the number of occurences of a word in a string
let text = "hello world wonderful world";
let mut map = HashMap::new();
for word in text.split_whitespace() {
let count = map.entry(word).or_insert(0);
*count += 1;
}
println!("{:?}", map);
}
|
//! NOTE: this crate is really just a shim for testing
//! the other no-std crate.
mod framed;
mod multi_thread;
mod ring_around_the_senders;
mod single_thread;
#[cfg(test)]
mod tests {
use bbqueue::{BBBuffer, Error as BBQError};
#[test]
fn deref_deref_mut() {
let bb: BBBuffer<6> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split().unwrap();
let mut wgr = prod.grant_exact(1).unwrap();
// deref_mut
wgr[0] = 123;
assert_eq!(wgr.len(), 1);
wgr.commit(1);
// deref
let rgr = cons.read().unwrap();
assert_eq!(rgr[0], 123);
rgr.release(1);
}
#[test]
fn static_allocator() {
// Check we can make multiple static items...
static BBQ1: BBBuffer<6> = BBBuffer::new();
static BBQ2: BBBuffer<6> = BBBuffer::new();
let (mut prod1, mut cons1) = BBQ1.try_split().unwrap();
let (mut _prod2, mut cons2) = BBQ2.try_split().unwrap();
// ... and they aren't the same
let mut wgr1 = prod1.grant_exact(3).unwrap();
wgr1.copy_from_slice(&[1, 2, 3]);
wgr1.commit(3);
// no data here...
assert!(cons2.read().is_err());
// ...data is here!
let rgr1 = cons1.read().unwrap();
assert_eq!(&*rgr1, &[1, 2, 3]);
}
#[test]
fn release() {
// Check we can make multiple static items...
static BBQ1: BBBuffer<6> = BBBuffer::new();
static BBQ2: BBBuffer<6> = BBBuffer::new();
let (prod1, cons1) = BBQ1.try_split().unwrap();
let (prod2, cons2) = BBQ2.try_split().unwrap();
// We cannot release with the wrong prod/cons
let (prod2, cons2) = BBQ1.try_release(prod2, cons2).unwrap_err();
let (prod1, cons1) = BBQ2.try_release(prod1, cons1).unwrap_err();
// We cannot release with the wrong consumer...
let (prod1, cons2) = BBQ1.try_release(prod1, cons2).unwrap_err();
// ...or the wrong producer
let (prod2, cons1) = BBQ1.try_release(prod2, cons1).unwrap_err();
// We cannot release with a write grant in progress
let mut prod1 = prod1;
let wgr1 = prod1.grant_exact(3).unwrap();
let (prod1, mut cons1) = BBQ1.try_release(prod1, cons1).unwrap_err();
// We cannot release with a read grant in progress
wgr1.commit(3);
let rgr1 = cons1.read().unwrap();
let (prod1, cons1) = BBQ1.try_release(prod1, cons1).unwrap_err();
// But we can when everything is resolved
rgr1.release(3);
assert!(BBQ1.try_release(prod1, cons1).is_ok());
assert!(BBQ2.try_release(prod2, cons2).is_ok());
// And we can re-split on-demand
let _ = BBQ1.try_split().unwrap();
let _ = BBQ2.try_split().unwrap();
}
#[test]
fn direct_usage_sanity() {
// Initialize
let bb: BBBuffer<6> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split().unwrap();
assert_eq!(cons.read(), Err(BBQError::InsufficientSize));
// Initial grant, shouldn't roll over
let mut x = prod.grant_exact(4).unwrap();
// Still no data available yet
assert_eq!(cons.read(), Err(BBQError::InsufficientSize));
// Add full data from grant
x.copy_from_slice(&[1, 2, 3, 4]);
// Still no data available yet
assert_eq!(cons.read(), Err(BBQError::InsufficientSize));
// Commit data
x.commit(4);
::std::sync::atomic::fence(std::sync::atomic::Ordering::SeqCst);
let a = cons.read().unwrap();
assert_eq!(&*a, &[1, 2, 3, 4]);
// Release the first two bytes
a.release(2);
let r = cons.read().unwrap();
assert_eq!(&*r, &[3, 4]);
r.release(0);
// Grant two more
let mut x = prod.grant_exact(2).unwrap();
let r = cons.read().unwrap();
assert_eq!(&*r, &[3, 4]);
r.release(0);
// Add more data
x.copy_from_slice(&[11, 12]);
let r = cons.read().unwrap();
assert_eq!(&*r, &[3, 4]);
r.release(0);
// Commit
x.commit(2);
let a = cons.read().unwrap();
assert_eq!(&*a, &[3, 4, 11, 12]);
a.release(2);
let r = cons.read().unwrap();
assert_eq!(&*r, &[11, 12]);
r.release(0);
let mut x = prod.grant_exact(3).unwrap();
let r = cons.read().unwrap();
assert_eq!(&*r, &[11, 12]);
r.release(0);
x.copy_from_slice(&[21, 22, 23]);
let r = cons.read().unwrap();
assert_eq!(&*r, &[11, 12]);
r.release(0);
x.commit(3);
let a = cons.read().unwrap();
// NOTE: The data we just added isn't available yet,
// since it has wrapped around
assert_eq!(&*a, &[11, 12]);
a.release(2);
// And now we can see it
let r = cons.read().unwrap();
assert_eq!(&*r, &[21, 22, 23]);
r.release(0);
// Ask for something way too big
assert!(prod.grant_exact(10).is_err());
}
#[test]
fn zero_sized_grant() {
let bb: BBBuffer<1000> = BBBuffer::new();
let (mut prod, mut _cons) = bb.try_split().unwrap();
let size = 1000;
let grant = prod.grant_exact(size).unwrap();
grant.commit(size);
let grant = prod.grant_exact(0).unwrap();
grant.commit(0);
}
#[test]
fn frame_sanity() {
let bb: BBBuffer<1000> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split_framed().unwrap();
// One frame in, one frame out
let mut wgrant = prod.grant(128).unwrap();
assert_eq!(wgrant.len(), 128);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = idx as u8;
}
wgrant.commit(128);
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), 128);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, idx as u8);
}
rgrant.release();
// Three frames in, three frames out
let mut state = 0;
let states = [16usize, 32, 24];
for step in &states {
let mut wgrant = prod.grant(*step).unwrap();
assert_eq!(wgrant.len(), *step);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = (idx + state) as u8;
}
wgrant.commit(*step);
state += *step;
}
state = 0;
for step in &states {
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), *step);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, (idx + state) as u8);
}
rgrant.release();
state += *step;
}
}
#[test]
fn frame_wrap() {
let bb: BBBuffer<22> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split_framed().unwrap();
// 10 + 1 used
let mut wgrant = prod.grant(10).unwrap();
assert_eq!(wgrant.len(), 10);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = idx as u8;
}
wgrant.commit(10);
// 1 frame in queue
// 20 + 2 used (assuming u64 test platform)
let mut wgrant = prod.grant(10).unwrap();
assert_eq!(wgrant.len(), 10);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = idx as u8;
}
wgrant.commit(10);
// 2 frames in queue
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), 10);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, idx as u8);
}
rgrant.release();
// 1 frame in queue
// No more room!
assert!(prod.grant(10).is_err());
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), 10);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, idx as u8);
}
rgrant.release();
// 0 frames in queue
// 10 + 1 used (assuming u64 test platform)
let mut wgrant = prod.grant(10).unwrap();
assert_eq!(wgrant.len(), 10);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = idx as u8;
}
wgrant.commit(10);
// 1 frame in queue
// No more room!
assert!(prod.grant(10).is_err());
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), 10);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, idx as u8);
}
rgrant.release();
// 0 frames in queue
// No more frames!
assert!(cons.read().is_none());
}
#[test]
fn frame_big_little() {
let bb: BBBuffer<65536> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split_framed().unwrap();
// Create a frame that should take 3 bytes for the header
assert!(prod.grant(65534).is_err());
let mut wgrant = prod.grant(65533).unwrap();
assert_eq!(wgrant.len(), 65533);
for (idx, i) in wgrant.iter_mut().enumerate() {
*i = idx as u8;
}
// Only commit 127 bytes, which fit into a header of 1 byte
wgrant.commit(127);
let rgrant = cons.read().unwrap();
assert_eq!(rgrant.len(), 127);
for (idx, i) in rgrant.iter().enumerate() {
assert_eq!(*i, idx as u8);
}
rgrant.release();
}
#[test]
fn split_sanity_check() {
let bb: BBBuffer<10> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split().unwrap();
// Fill buffer
let mut wgrant = prod.grant_exact(10).unwrap();
assert_eq!(wgrant.len(), 10);
wgrant.copy_from_slice(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
wgrant.commit(10);
let rgrant = cons.split_read().unwrap();
assert_eq!(rgrant.combined_len(), 10);
assert_eq!(
rgrant.bufs(),
(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10][..], &[][..])
);
// Release part of the buffer
rgrant.release(6);
// Almost fill buffer again => | 11 | 12 | 13 | 14 | 15 | x | 7 | 8 | 9 | 10 |
let mut wgrant = prod.grant_exact(5).unwrap();
assert_eq!(wgrant.len(), 5);
wgrant.copy_from_slice(&[11, 12, 13, 14, 15]);
wgrant.commit(5);
let rgrant = cons.split_read().unwrap();
assert_eq!(rgrant.combined_len(), 9);
assert_eq!(
rgrant.bufs(),
(&[7, 8, 9, 10][..], &[11, 12, 13, 14, 15][..])
);
// Release part of the buffer => | x | x | x | 14 | 15 | x | x | x | x | x |
rgrant.release(7);
// Check that it is not possible to claim more space than what should be available
assert!(prod.grant_exact(6).is_err());
// Fill buffer to the end => | x | x | x | 14 | 15 | 21 | 22 | 23 | 24 | 25 |
let mut wgrant = prod.grant_exact(5).unwrap();
wgrant.copy_from_slice(&[21, 22, 23, 24, 25]);
wgrant.commit(5);
let rgrant = cons.split_read().unwrap();
assert_eq!(rgrant.combined_len(), 7);
assert_eq!(rgrant.bufs(), (&[14, 15, 21, 22, 23, 24, 25][..], &[][..]));
rgrant.release(0);
// Fill buffer to the end => | 26 | 27 | x | 14 | 15 | 21 | 22 | 23 | 24 | 25 |
let mut wgrant = prod.grant_exact(2).unwrap();
wgrant.copy_from_slice(&[26, 27]);
wgrant.commit(2);
// Fill buffer to the end => | x | 27 | x | x | x | x | x | x | x | x |
let rgrant = cons.split_read().unwrap();
assert_eq!(rgrant.combined_len(), 9);
assert_eq!(
rgrant.bufs(),
(&[14, 15, 21, 22, 23, 24, 25][..], &[26, 27][..])
);
rgrant.release(8);
let rgrant = cons.split_read().unwrap();
assert_eq!(rgrant.combined_len(), 1);
assert_eq!(rgrant.bufs(), (&[27][..], &[][..]));
rgrant.release(1);
}
#[test]
fn split_read_sanity_check() {
let bb: BBBuffer<6> = BBBuffer::new();
let (mut prod, mut cons) = bb.try_split().unwrap();
const ITERS: usize = 100000;
for i in 0..ITERS {
let j = (i & 255) as u8;
#[cfg(feature = "extra-verbose")]
println!("===========================");
#[cfg(feature = "extra-verbose")]
println!("INDEX: {:?}", j);
#[cfg(feature = "extra-verbose")]
println!("===========================");
#[cfg(feature = "extra-verbose")]
println!("START: {:?}", bb);
let mut wgr = prod.grant_exact(1).unwrap();
#[cfg(feature = "extra-verbose")]
println!("GRANT: {:?}", bb);
wgr[0] = j;
#[cfg(feature = "extra-verbose")]
println!("WRITE: {:?}", bb);
wgr.commit(1);
#[cfg(feature = "extra-verbose")]
println!("COMIT: {:?}", bb);
// This panicked before with Err(GrantInProgress), because SplitGrantR did not implement Drop
let rgr = cons.split_read().unwrap();
drop(rgr);
#[cfg(feature = "extra-verbose")]
println!("READ : {:?}", bb);
let rgr = cons.split_read().unwrap();
let (first, second) = rgr.bufs();
if first.len() == 1 {
assert_eq!(first[0], j);
} else if second.len() == 1 {
assert_eq!(second[0], j);
} else {
assert!(false, "wrong len");
}
#[cfg(feature = "extra-verbose")]
println!("RELSE: {:?}", bb);
rgr.release(1);
#[cfg(feature = "extra-verbose")]
println!("FINSH: {:?}", bb);
}
}
}
|
pub mod board;
pub mod engine;
pub mod game_repository;
pub mod controller;
pub mod errors; |
pub fn part_01_slow(data: String) -> i32 {
let numbers: Vec<i32> = data
.split_whitespace()
.map(|x| x.parse::<i32>().unwrap())
.collect();
for x in numbers.clone() {
for y in numbers.clone() {
for z in numbers.clone() {
if x + y + z == 2020 {
return x * y * z;
}
}
}
}
0
}
pub fn part_01_perm_01(data: String) -> i64 {
let numbers: Vec<_> = data
.split_whitespace()
.map(|x| x.parse::<i64>().unwrap())
.collect();
let mut result = 0;
permutator::large_combination(&numbers, 3, |x| {
if x.iter().fold(0, |init, &&x| init + x) == 2020 {
result = x.iter().fold(1, |init, &&x| init * x);
}
});
result
}
pub fn part_01(data: String) -> u64 {
use permutator::copy::LargeCombinationIterator;
let numbers: Vec<_> = data
.split_whitespace()
.map(|x| x.parse::<u64>().unwrap())
.collect();
let mut combinations = LargeCombinationIterator::new(&numbers, 3);
let combination: Option<Vec<u64>> = combinations.find(|comb| comb.iter().fold(0u64, |init, x| init + x) == 2020);
combination.unwrap().iter().fold(1, |init, &x| init * x)
} |
use std::{
cmp,
collections::{HashMap, VecDeque},
hash::{BuildHasherDefault, Hasher},
};
/// A fixed sized container that pops old elements as new ones arrive
#[derive(PartialEq, Debug)]
pub struct ByteBuffer<T> {
pub vec: Vec<T>,
limit: usize,
}
impl<T: std::marker::Copy> ByteBuffer<T> {
// Potential improvements: Use a circular buffer instead, and use a chained iterator when
// we need to return wrapped segments. Would save on allocations and moves.
// Performance of swapping direct slice loops with an iter would have to be checked.
pub fn new(limit: usize) -> ByteBuffer<T> {
ByteBuffer {
vec: Vec::with_capacity(limit),
limit,
}
}
pub fn push_all(&mut self, elements: &[T]) {
if self.vec.len() + elements.len() > self.limit {
let count_to_drop = (self.vec.len() + elements.len()) - self.limit;
self.vec.drain(0..count_to_drop);
}
self.vec.extend_from_slice(elements);
}
}
#[derive(PartialEq, Debug)]
pub struct ByteWindowAdvance<'a> {
pub evicted: &'a [u8],
pub admitted: &'a [u8],
pub window: &'a [u8],
}
// Maybe add an implementation for converting to a &[u8]?
/// Wrapper for a window view over a byte slice
#[derive(PartialEq, Debug)]
pub struct ByteWindow<'a> {
bytes: &'a [u8],
max_window_size: usize,
current_index: usize,
}
impl<'a> ByteWindow<'a> {
pub fn with_max_window_size(bytes: &'a [u8], max_window_size: usize) -> Self {
ByteWindow {
bytes,
max_window_size,
current_index: 0,
}
}
/// Moves the end-of-window pointer by count.
/// count is allowed to exceed the size of the underlying byte slice - this function and
/// the window() function will return empty slices if the count + max_slice_length exceeds
/// the byte slice length.
///
/// Returned struct contains the bytes that were evicted and admitted from/to the window.
/// ```
/// use sloppycomp::lz77::window_byte_container::{ByteWindow, ByteWindowAdvance};
/// let bytes = [b'b', b'c', b'd', b'e'];
/// let mut byte_window = ByteWindow::with_max_window_size(&bytes, 2);
/// let advancement = byte_window.advance(1);
/// assert_eq!(
/// ByteWindowAdvance {
/// evicted: &[],
/// admitted: &[b'b'],
/// window: &[b'b']
/// },
/// advancement
/// );
/// ```
///
/// It is possible for the same byte to be emitted and evicted in a single operation
/// if the count exceeds the max_window_size of the ByteWindow.
/// ```
/// use sloppycomp::lz77::window_byte_container::{ByteWindow, ByteWindowAdvance};
/// let bytes = [b'b', b'c', b'd', b'e'];
/// let mut byte_window = ByteWindow::with_max_window_size(&bytes, 2);
///
/// let door = byte_window.advance(5);
/// assert_eq!(
/// ByteWindowAdvance {
/// evicted: &[b'b', b'c', b'd'],
/// admitted: &[b'b', b'c', b'd', b'e'],
/// window: &[b'e']
/// },
/// door
/// );
/// ```
pub fn advance(&mut self, count: usize) -> ByteWindowAdvance<'a> {
let new_pointer = self.current_index + count;
self.advance_to_pointer(new_pointer)
}
pub fn advance_to_pointer(&mut self, pointer: usize) -> ByteWindowAdvance<'a> {
let new_start_index = pointer.saturating_sub(self.max_window_size);
let old_start_index = self.current_index.saturating_sub(self.max_window_size);
let end_index = cmp::min(self.bytes.len(), pointer);
let window = if new_start_index < end_index {
&self.bytes[new_start_index..end_index]
} else {
&[]
};
let admitted = if self.current_index < self.bytes.len() {
&self.bytes[self.current_index..end_index]
} else {
&[]
};
let evicted = if old_start_index < new_start_index && old_start_index < self.bytes.len() {
&self.bytes[old_start_index..new_start_index]
} else {
&[]
};
self.current_index = pointer;
ByteWindowAdvance {
evicted,
admitted,
window,
}
}
pub fn window(&self) -> &'a [u8] {
let start_index = self.current_index.saturating_sub(self.max_window_size);
let end_index = cmp::min(self.bytes.len(), self.current_index);
if start_index < self.bytes.len() {
&self.bytes[start_index..end_index]
} else {
&[]
}
}
}
/// ByteWindow that also tracks the locations of each byte in an O(1) lookup
///
/// After every admission and eviction the internal hashmap of byte values to indexes
/// is updated. Note that the indexes stored in this location are not restricted to the
/// visible byte window, they are global across the whole original byte slice.
/// This means we don't have to update values in the collection as we slide the window.
#[derive(PartialEq, Debug)]
pub struct IndexableByteWindow<'a> {
window: ByteWindow<'a>,
byte_locations: HashMap<u8, VecDeque<usize>, U8HasherBuilder>,
}
impl<'a> IndexableByteWindow<'a> {
pub fn with_max_window_size(bytes: &'a [u8], max_window_size: usize) -> Self {
IndexableByteWindow {
window: ByteWindow::with_max_window_size(bytes, max_window_size),
byte_locations:
HashMap::<u8, VecDeque<usize>, U8HasherBuilder>::with_capacity_and_hasher(
256,
U8HasherBuilder::default(),
),
}
}
pub fn advance(&mut self, count: usize) -> ByteWindowAdvance<'a> {
let result = self.window.advance(count);
self.update_byte_location_table(
result.admitted,
self.window.current_index - count,
result.evicted,
);
result
}
pub fn advance_to_pointer(&mut self, pointer: usize) -> ByteWindowAdvance<'a> {
self.advance(pointer - self.window.current_index)
}
pub fn window(&self) -> &'a [u8] {
self.window.window()
}
fn update_byte_location_table(
&mut self,
admitted: &[u8],
admission_offset: usize,
evicted: &[u8],
) {
admitted.iter().enumerate().for_each(|(i, u)| {
self.byte_locations
.entry(*u)
.or_default()
.push_back(i + admission_offset);
});
evicted.iter().for_each(|u| {
// we are moving through the slice from lowest index first, so we know
// that if we are removing an element from a given key, the element to
// remove must be first in the deque.
self.byte_locations.entry(*u).and_modify(|v| {
v.pop_front();
});
});
}
/// Returns a collection of byte values to their known location within the byte slice.
pub fn byte_locations(&self) -> &HashMap<u8, VecDeque<usize>, U8HasherBuilder> {
&self.byte_locations
}
/// Translates a location within the byte slice to a location within the
/// current visible window.
pub fn location_to_window_index(&self, location: usize) -> usize {
let offset = self
.window
.current_index
.saturating_sub(self.window.max_window_size);
#[cfg(debug_assertions)]
if location > self.window.current_index || location < offset {
panic!("Location must be indexable within the current visible window");
}
location - offset
}
}
// Custom hasher optimised for the u8 keys of the IndexableByteWindow's map.
#[derive(Default)]
pub struct U8Hasher {
hash: u8,
}
impl Hasher for U8Hasher {
fn finish(&self) -> u64 {
u64::from(self.hash)
}
fn write(&mut self, bytes: &[u8]) {
self.hash = bytes[0]
}
}
type U8HasherBuilder = BuildHasherDefault<U8Hasher>;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn push_all() {
let mut search_buffer: ByteBuffer<u8> = ByteBuffer::new(4);
search_buffer.push_all(&[b'a']);
search_buffer.push_all(&[b'b', b'c', b'd', b'e']);
assert_eq!(search_buffer.vec, vec![b'b', b'c', b'd', b'e']);
search_buffer.push_all(&[b'z']);
assert_eq!(search_buffer.vec, vec![b'c', b'd', b'e', b'z']);
}
}
#[cfg(test)]
mod byte_window_tests {
use super::*;
#[test]
fn advance_less_than_window_size() {
let bytes = [b'b', b'c', b'd', b'e'];
let mut byte_window = ByteWindow::with_max_window_size(&bytes, 2);
assert_eq!([] as [u8; 0], byte_window.window());
assert_window_advance(&mut byte_window, &[], &[b'b'], &[b'b']);
assert_window_advance(&mut byte_window, &[], &[b'c'], &[b'b', b'c']);
assert_window_advance(&mut byte_window, &[b'b'], &[b'd'], &[b'c', b'd']);
assert_window_advance(&mut byte_window, &[b'c'], &[b'e'], &[b'd', b'e']);
assert_window_advance(&mut byte_window, &[b'd'], &[], &[b'e']);
assert_window_advance(&mut byte_window, &[b'e'], &[], &[]);
assert_window_advance(&mut byte_window, &[], &[], &[]);
}
#[test]
fn advance_past_end_of_window() {
let bytes = [b'b', b'c', b'd', b'e'];
let mut byte_window = ByteWindow::with_max_window_size(&bytes, 2);
let door = byte_window.advance(5);
assert_eq!(
ByteWindowAdvance {
evicted: &[b'b', b'c', b'd'],
admitted: &[b'b', b'c', b'd', b'e'],
window: &[b'e']
},
door
);
assert_eq!([b'e'], byte_window.window());
}
#[test]
fn advance_past_end_of_window_byte_locations() {
let bytes = [b'b', b'c', b'd', b'e'];
let mut byte_window = IndexableByteWindow::with_max_window_size(&bytes, 2);
byte_window.advance(5);
assert_eq!(
byte_window.byte_locations().get(&b'e').unwrap().as_slices(),
(&[3][..], &[][..])
);
}
#[test]
fn location_to_window_index() {
let bytes = [b'b', b'c', b'd', b'e'];
let mut byte_window = IndexableByteWindow::with_max_window_size(&bytes, 2);
assert_eq!(0, byte_window.location_to_window_index(0));
byte_window.advance(4);
assert_eq!(0, byte_window.location_to_window_index(2));
assert_eq!(1, byte_window.location_to_window_index(3));
}
#[test]
fn advance_to_pointer() {
let bytes = [b'b', b'c', b'd', b'e'];
let mut byte_window = ByteWindow::with_max_window_size(&bytes, 2);
let door = byte_window.advance_to_pointer(3);
assert_eq!(
ByteWindowAdvance {
evicted: &[b'b'],
admitted: &[b'b', b'c', b'd'],
window: &[b'c', b'd']
},
door
);
assert_eq!([b'c', b'd'], byte_window.window());
}
fn assert_window_advance(
byte_window: &mut ByteWindow,
evicted: &[u8],
admitted: &[u8],
window: &[u8],
) {
let door = byte_window.advance(1);
assert_eq!(
ByteWindowAdvance {
evicted,
admitted,
window
},
door
);
assert_eq!(window, byte_window.window());
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.