text:
use crate::any::type_name;
use crate::fmt;
use crate::intrinsics;
use crate::mem::ManuallyDrop;
use crate::ptr;

/// A wrapper type to construct uninitialized instances of `T`.
///
/// # Initialization invariant
///
/// The compiler, in general, assumes that a variable is properly initialized
/// according to the requirements of the variable's type. For example, a variable of
/// reference type must be aligned and non-null. This is an invariant that must
/// *always* be upheld, even in unsafe code. As a consequence, zero-initializing a
/// variable of reference type causes instantaneous [undefined behavior][ub],
/// no matter whether that reference ever gets used to access memory:
///
/// ```rust,no_run
/// # #![allow(invalid_value)]
/// use std::mem::{self, MaybeUninit};
///
/// let x: &i32 = unsafe { mem::zeroed() }; // undefined behavior! ⚠
/// // The equivalent code with `MaybeUninit<&i32>`:
/// let x: &i32 = unsafe { MaybeUninit::zeroed().assume_init() }; // undefined behavior! ⚠
/// ```
///
/// This is exploited by the compiler for various optimizations, such as eliding
/// run-time checks and optimizing `enum` layout.
///
/// Similarly, entirely uninitialized memory may have any content, while a `bool` must
/// always be `true` or `false`. Hence, creating an uninitialized `bool` is undefined behavior:
///
/// ```rust,no_run
/// # #![allow(invalid_value)]
/// use std::mem::{self, MaybeUninit};
///
/// let b: bool = unsafe { mem::uninitialized() }; // undefined behavior! ⚠
/// // The equivalent code with `MaybeUninit<bool>`:
/// let b: bool = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠
/// ```
///
/// Moreover, uninitialized memory is special in that it does not have a fixed value ("fixed"
/// meaning "it won't change without being written to"). Reading the same uninitialized byte
/// multiple times can give different results. This makes it undefined behavior to have
/// uninitialized data in a variable even if that variable has an integer type, which otherwise can
/// hold any *fixed* bit pattern:
///
/// ```rust,no_run
/// # #![allow(invalid_value)]
/// use std::mem::{self, MaybeUninit};
///
/// let x: i32 = unsafe { mem::uninitialized() }; // undefined behavior! ⚠
/// // The equivalent code with `MaybeUninit<i32>`:
/// let x: i32 = unsafe { MaybeUninit::uninit().assume_init() }; // undefined behavior! ⚠
/// ```
/// (Notice that the rules around uninitialized integers are not finalized yet, but
/// until they are, it is advisable to avoid them.)
///
/// On top of that, remember that most types have additional invariants beyond merely
/// being considered initialized at the type level. For example, a `1`-initialized [`Vec<T>`]
/// is considered initialized (under the current implementation; this does not constitute
/// a stable guarantee) because the only requirement the compiler knows about it
/// is that the data pointer must be non-null. Creating such a `Vec<T>` does not cause
/// *immediate* undefined behavior, but will cause undefined behavior with most
/// safe operations (including dropping it).
///
/// [`Vec<T>`]: ../../std/vec/struct.Vec.html
///
/// # Examples
///
/// `MaybeUninit<T>` serves to enable unsafe code to deal with uninitialized data.
/// It is a signal to the compiler indicating that the data here might *not*
/// be initialized:
///
/// ```rust
/// use std::mem::MaybeUninit;
///
/// // Create an explicitly uninitialized reference. The compiler knows that data inside
/// // a `MaybeUninit<T>` may be invalid, and hence this is not UB:
/// let mut x = MaybeUninit::<&i32>::uninit();
/// // Set it to a valid value.
/// x.write(&0);
/// // Extract the initialized data -- this is only allowed *after* properly
/// // initializing `x`!
/// let x = unsafe { x.assume_init() };
/// ```
///
/// The compiler then knows to not make any incorrect assumptions or optimizations on this code.
///
/// You can think of `MaybeUninit<T>` as being a bit like `Option<T>` but without
/// any of the run-time tracking and without any of the safety checks.
///
/// ## out-pointers
///
/// You can use `MaybeUninit<T>` to implement "out-pointers": instead of returning data
/// from a function, pass it a pointer to some (uninitialized) memory to put the
/// result into. This can be useful when it is important for the caller to control
/// how the memory the result is stored in gets allocated, and you want to avoid
/// unnecessary moves.
///
/// ```
/// use std::mem::MaybeUninit;
///
/// unsafe fn make_vec(out: *mut Vec<i32>) {
///     // `write` does not drop the old contents, which is important.
///     out.write(vec![1, 2, 3]);
/// }
///
/// let mut v = MaybeUninit::uninit();
/// unsafe { make_vec(v.as_mut_ptr()); }
/// // Now we know `v` is initialized! This also makes sure the vector gets
/// // properly dropped.
/// let v = unsafe { v.assume_init() };
/// assert_eq!(&v, &[1, 2, 3]);
/// ```
///
/// ## Initializing an array element-by-element
///
/// `MaybeUninit<T>` can be used to initialize a large array element-by-element:
///
/// ```
/// use std::mem::{self, MaybeUninit};
///
/// let data = {
///     // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
///     // safe because the type we are claiming to have initialized here is a
///     // bunch of `MaybeUninit`s, which do not require initialization.
///     let mut data: [MaybeUninit<Vec<u32>>; 1000] = unsafe {
///         MaybeUninit::uninit().assume_init()
///     };
///
///     // Dropping a `MaybeUninit` does nothing. Thus using raw pointer
///     // assignment instead of `ptr::write` does not cause the old
///     // uninitialized value to be dropped. Also if there is a panic during
///     // this loop, we have a memory leak, but there is no memory safety
///     // issue.
///     for elem in &mut data[..] {
///         elem.write(vec![42]);
///     }
///
///     // Everything is initialized. Transmute the array to the
///     // initialized type.
///     unsafe { mem::transmute::<_, [Vec<u32>; 1000]>(data) }
/// };
///
/// assert_eq!(&data[0], &[42]);
/// ```
///
/// You can also work with partially initialized arrays, which could
/// be found in low-level datastructures.
///
/// ```
/// use std::mem::MaybeUninit;
/// use std::ptr;
///
/// // Create an uninitialized array of `MaybeUninit`. The `assume_init` is
/// // safe because the type we are claiming to have initialized here is a
/// // bunch of `MaybeUninit`s, which do not require initialization.
/// let mut data: [MaybeUninit<String>; 1000] = unsafe { MaybeUninit::uninit().assume_init() };
/// // Count the number of elements we have assigned.
/// let mut data_len: usize = 0;
///
/// for elem in &mut data[0..500] {
///     elem.write(String::from("hello"));
///     data_len += 1;
/// }
///
/// // For each item in the array, drop if we allocated it.
/// for elem in &mut data[0..data_len] {
///     unsafe { ptr::drop_in_place(elem.as_mut_ptr()); }
/// }
/// ```
///
/// ## Initializing a struct field-by-field
///
/// You can use `MaybeUninit<T>`, and the [`std::ptr::addr_of_mut`] macro, to initialize structs field by field:
///
/// ```rust
/// use std::mem::MaybeUninit;
/// use std::ptr::addr_of_mut;
///
/// #[derive(Debug, PartialEq)]
/// pub struct Foo {
///     name: String,
///     list: Vec<u8>,
/// }
///
/// let foo = {
///     let mut uninit: MaybeUninit<Foo> = MaybeUninit::uninit();
///     let ptr = uninit.as_mut_ptr();
///
///     // Initializing the `name` field
///     // Using `write` instead of assignment via `=` to not call `drop` on the
///     // old, uninitialized value.
///     unsafe { addr_of_mut!((*ptr).name).write("Bob".to_string()); }
///
///     // Initializing the `list` field
///     // If there is a panic here, then the `String` in the `name` field leaks.
///     unsafe { addr_of_mut!((*ptr).list).write(vec![0, 1, 2]); }
///
///     // All the fields are initialized, so we call `assume_init` to get an initialized Foo.
///     unsafe { uninit.assume_init() }
/// };
///
/// assert_eq!(
///     foo,
///     Foo {
///         name: "Bob".to_string(),
///         list: vec![0, 1, 2]
///     }
/// );
/// ```
/// [`std::ptr::addr_of_mut`]: crate::ptr::addr_of_mut
/// [ub]: ../../reference/behavior-considered-undefined.html
///
/// # Layout
///
/// `MaybeUninit<T>` is guaranteed to have the same size, alignment, and ABI as `T`:
///
/// ```rust
/// use std::mem::{MaybeUninit, size_of, align_of};
/// assert_eq!(size_of::<MaybeUninit<u64>>(), size_of::<u64>());
/// assert_eq!(align_of::<MaybeUninit<u64>>(), align_of::<u64>());
/// ```
///
/// However remember that a type *containing* a `MaybeUninit<T>` is not necessarily the same
/// layout; Rust does not in general guarantee that the fields of a `Foo<T>` have the same order as
/// a `Foo<U>` even if `T` and `U` have the same size and alignment. Furthermore because any bit
/// value is valid for a `MaybeUninit<T>` the compiler can't apply non-zero/niche-filling
/// optimizations, potentially resulting in a larger size:
///
/// ```rust
/// # use std::mem::{MaybeUninit, size_of};
/// assert_eq!(size_of::<Option<bool>>(), 1);
/// assert_eq!(size_of::<Option<MaybeUninit<bool>>>(), 2);
/// ```
///
/// If `T` is FFI-safe, then so is `MaybeUninit<T>`.
///
/// While `MaybeUninit` is `#[repr(transparent)]` (indicating it guarantees the same size,
/// alignment, and ABI as `T`), this does *not* change any of the previous caveats. `Option<T>` and
/// `Option<MaybeUninit<T>>` may still have different sizes, and types containing a field of type
/// `T` may be laid out (and sized) differently than if that field were `MaybeUninit<T>`.
/// `MaybeUninit` is a union type, and `#[repr(transparent)]` on unions is unstable (see [the
/// tracking issue](https://github.com/rust-lang/rust/issues/60405)). Over time, the exact
/// guarantees of `#[repr(transparent)]` on unions may evolve, and `MaybeUninit` may or may not
/// remain `#[repr(transparent)]`. That said, `MaybeUninit<T>` will *always* guarantee that it has
/// the same size, alignment, and ABI as `T`; it's just that the way `MaybeUninit` implements that
/// guarantee may evolve.
#[stable(feature = "maybe_uninit", since = "1.36.0")]
// Lang item so we can wrap other types in it. This is useful for generators.
#[lang = "maybe_uninit"]
#[derive(Copy)]
#[repr(transparent)]
pub union MaybeUninit<T> {
    uninit: (),
    value: ManuallyDrop<T>,
}

#[stable(feature = "maybe_uninit", since = "1.36.0")]
impl<T: Copy> Clone for MaybeUninit<T> {
    #[inline(always)]
    fn clone(&self) -> Self {
        // Not calling `T::clone()`, we cannot know if we are initialized enough for that.
        *self
    }
}

#[stable(feature = "maybe_uninit_debug", since = "1.41.0")]
impl<T> fmt::Debug for MaybeUninit<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.pad(type_name::<Self>())
    }
}

impl<T> MaybeUninit<T> {
    /// Creates a new `MaybeUninit<T>` initialized with the given value.
    /// It is safe to call [`assume_init`] on the return value of this function.
    ///
    /// Note that dropping a `MaybeUninit<T>` will never call `T`'s drop code.
    /// It is your responsibility to make sure `T` gets dropped if it got initialized.
    ///
    /// # Example
    ///
    /// ```
    /// use std::mem::MaybeUninit;
    ///
    /// let v: MaybeUninit<Vec<u8>> = MaybeUninit::new(vec![42]);
    /// ```
    ///
    /// [`assume_init`]: MaybeUninit::assume_init
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[rustc_const_stable(feature = "const_maybe_uninit", since = "1.36.0")]
    #[must_use = "use `forget` to avoid running Drop code"]
    #[inline(always)]
    pub const fn new(val: T) -> MaybeUninit<T> {
        MaybeUninit { value: ManuallyDrop::new(val) }
    }

    /// Creates a new `MaybeUninit<T>` in an uninitialized state.
    ///
    /// Note that dropping a `MaybeUninit<T>` will never call `T`'s drop code.
    /// It is your responsibility to make sure `T` gets dropped if it got initialized.
    ///
    /// See the [type-level documentation][MaybeUninit] for some examples.
    ///
    /// # Example
    ///
    /// ```
    /// use std::mem::MaybeUninit;
    ///
    /// let v: MaybeUninit<String> = MaybeUninit::uninit();
    /// ```
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[rustc_const_stable(feature = "const_maybe_uninit", since = "1.36.0")]
    #[must_use]
    #[inline(always)]
    #[rustc_diagnostic_item = "maybe_uninit_uninit"]
    pub const fn uninit() -> MaybeUninit<T> {
        MaybeUninit { uninit: () }
    }

    /// Create a new array of `MaybeUninit<T>` items, in an uninitialized state.
    ///
    /// Note: in a future Rust version this method may become unnecessary
    /// when Rust allows
    /// [inline const expressions](https://github.com/rust-lang/rust/issues/76001).
    /// The example below could then use `let mut buf = [const { MaybeUninit::<u8>::uninit() }; 32];`.
    ///
    /// # Examples
    ///
    /// ```no_run
    /// #![feature(maybe_uninit_uninit_array, maybe_uninit_extra, maybe_uninit_slice)]
    ///
    /// use std::mem::MaybeUninit;
    ///
    /// extern "C" {
    ///     fn read_into_buffer(ptr: *mut u8, max_len: usize) -> usize;
    /// }
    ///
    /// /// Returns a (possibly smaller) slice of data that was actually read
    /// fn read(buf: &mut [MaybeUninit<u8>]) -> &[u8] {
    ///     unsafe {
    ///         let len = read_into_buffer(buf.as_mut_ptr() as *mut u8, buf.len());
    ///         MaybeUninit::slice_assume_init_ref(&buf[..len])
    ///     }
    /// }
    ///
    /// let mut buf: [MaybeUninit<u8>; 32] = MaybeUninit::uninit_array();
    /// let data = read(&mut buf);
    /// ```
    #[unstable(feature = "maybe_uninit_uninit_array", issue = "none")]
    #[rustc_const_unstable(feature = "maybe_uninit_uninit_array", issue = "none")]
    #[must_use]
    #[inline(always)]
    pub const fn uninit_array<const LEN: usize>() -> [Self; LEN] {
        // SAFETY: An uninitialized `[MaybeUninit<_>; LEN]` is valid.
        unsafe { MaybeUninit::<[MaybeUninit<T>; LEN]>::uninit().assume_init() }
    }

    /// Creates a new `MaybeUninit<T>` in an uninitialized state, with the memory being
    /// filled with `0` bytes. It depends on `T` whether that already makes for
    /// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,
    /// but `MaybeUninit<&'static i32>::zeroed()` is not because references must not
    /// be null.
    ///
    /// Note that dropping a `MaybeUninit<T>` will never call `T`'s drop code.
    /// It is your responsibility to make sure `T` gets dropped if it got initialized.
    ///
    /// # Example
    ///
    /// Correct usage of this function: initializing a struct with zero, where all
    /// fields of the struct can hold the bit-pattern 0 as a valid value.
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let x = MaybeUninit::<(u8, bool)>::zeroed();
    /// let x = unsafe { x.assume_init() };
    /// assert_eq!(x, (0, false));
    /// ```
    ///
    /// *Incorrect* usage of this function: calling `x.zeroed().assume_init()`
    /// when `0` is not a valid bit-pattern for the type:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// enum NotZero { One = 1, Two = 2 }
    ///
    /// let x = MaybeUninit::<(u8, NotZero)>::zeroed();
    /// let x = unsafe { x.assume_init() };
    /// // Inside a pair, we create a `NotZero` that does not have a valid discriminant.
    /// // This is undefined behavior. ⚠
    /// ```
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[must_use]
    #[inline]
    #[rustc_diagnostic_item = "maybe_uninit_zeroed"]
    pub fn zeroed() -> MaybeUninit<T> {
        let mut u = MaybeUninit::<T>::uninit();
        // SAFETY: `u.as_mut_ptr()` points to allocated memory.
        unsafe {
            u.as_mut_ptr().write_bytes(0u8, 1);
        }
        u
    }

    /// Sets the value of the `MaybeUninit<T>`.
    ///
    /// This overwrites any previous value without dropping it, so be careful
    /// not to use this twice unless you want to skip running the destructor.
    /// For your convenience, this also returns a mutable reference to the
    /// (now safely initialized) contents of `self`.
    ///
    /// As the content is stored inside a `MaybeUninit`, the destructor is not
    /// run for the inner data if the MaybeUninit leaves scope without a call to
    /// [`assume_init`], [`assume_init_drop`], or similar. Code that receives
    /// the mutable reference returned by this function needs to keep this in
    /// mind. The safety model of Rust regards leaks as safe, but they are
    /// usually still undesirable. This being said, the mutable reference
    /// behaves like any other mutable reference would, so assigning a new value
    /// to it will drop the old content.
    ///
    /// [`assume_init`]: Self::assume_init
    /// [`assume_init_drop`]: Self::assume_init_drop
    ///
    /// # Examples
    ///
    /// Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Vec<u8>>::uninit();
    ///
    /// {
    ///     let hello = x.write((&b"Hello, world!").to_vec());
    ///     // Setting hello does not leak prior allocations, but drops them
    ///     *hello = (&b"Hello").to_vec();
    ///     hello[0] = 'h' as u8;
    /// }
    /// // x is initialized now:
    /// let s = unsafe { x.assume_init() };
    /// assert_eq!(b"hello", s.as_slice());
    /// ```
    ///
    /// This usage of the method causes a leak:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<String>::uninit();
    ///
    /// x.write("Hello".to_string());
    /// // This leaks the contained string:
    /// x.write("hello".to_string());
    /// // x is initialized now:
    /// let s = unsafe { x.assume_init() };
    /// ```
    ///
    /// This method can be used to avoid unsafe in some cases. The example below
    /// shows a part of an implementation of a fixed sized arena that lends out
    /// pinned references.
    /// With `write`, we can avoid the need to write through a raw pointer:
    ///
    /// ```rust
    /// use core::pin::Pin;
    /// use core::mem::MaybeUninit;
    ///
    /// struct PinArena<T> {
    ///     memory: Box<[MaybeUninit<T>]>,
    ///     len: usize,
    /// }
    ///
    /// impl <T> PinArena<T> {
    ///     pub fn capacity(&self) -> usize {
    ///         self.memory.len()
    ///     }
    ///     pub fn push(&mut self, val: T) -> Pin<&mut T> {
    ///         if self.len >= self.capacity() {
    ///             panic!("Attempted to push to a full pin arena!");
    ///         }
    ///         let ref_ = self.memory[self.len].write(val);
    ///         self.len += 1;
    ///         unsafe { Pin::new_unchecked(ref_) }
    ///     }
    /// }
    /// ```
    #[stable(feature = "maybe_uninit_write", since = "1.55.0")]
    #[rustc_const_unstable(feature = "const_maybe_uninit_write", issue = "63567")]
    #[inline(always)]
    pub const fn write(&mut self, val: T) -> &mut T {
        *self = MaybeUninit::new(val);
        // SAFETY: We just initialized this value.
        unsafe { self.assume_init_mut() }
    }

    /// Gets a pointer to the contained value. Reading from this pointer or turning it
    /// into a reference is undefined behavior unless the `MaybeUninit<T>` is initialized.
    /// Writing to memory that this pointer (non-transitively) points to is undefined behavior
    /// (except inside an `UnsafeCell<T>`).
    ///
    /// # Examples
    ///
    /// Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Vec<u32>>::uninit();
    /// x.write(vec![0, 1, 2]);
    /// // Create a reference into the `MaybeUninit<T>`. This is okay because we initialized it.
    /// let x_vec = unsafe { &*x.as_ptr() };
    /// assert_eq!(x_vec.len(), 3);
    /// ```
    ///
    /// *Incorrect* usage of this method:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// let x = MaybeUninit::<Vec<u32>>::uninit();
    /// let x_vec = unsafe { &*x.as_ptr() };
    /// // We have created a reference to an uninitialized vector! This is undefined behavior. ⚠
    /// ```
    ///
    /// (Notice that the rules around references to uninitialized data are not finalized yet, but
    /// until they are, it is advisable to avoid them.)
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[rustc_const_stable(feature = "const_maybe_uninit_as_ptr", since = "1.59.0")]
    #[inline(always)]
    pub const fn as_ptr(&self) -> *const T {
        // `MaybeUninit` and `ManuallyDrop` are both `repr(transparent)` so we can cast the pointer.
        self as *const _ as *const T
    }

    /// Gets a mutable pointer to the contained value. Reading from this pointer or turning it
    /// into a reference is undefined behavior unless the `MaybeUninit<T>` is initialized.
    ///
    /// # Examples
    ///
    /// Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Vec<u32>>::uninit();
    /// x.write(vec![0, 1, 2]);
    /// // Create a reference into the `MaybeUninit<Vec<u32>>`.
    /// // This is okay because we initialized it.
    /// let x_vec = unsafe { &mut *x.as_mut_ptr() };
    /// x_vec.push(3);
    /// assert_eq!(x_vec.len(), 4);
    /// ```
    ///
    /// *Incorrect* usage of this method:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Vec<u32>>::uninit();
    /// let x_vec = unsafe { &mut *x.as_mut_ptr() };
    /// // We have created a reference to an uninitialized vector! This is undefined behavior. ⚠
    /// ```
    ///
    /// (Notice that the rules around references to uninitialized data are not finalized yet, but
    /// until they are, it is advisable to avoid them.)
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[rustc_const_unstable(feature = "const_maybe_uninit_as_mut_ptr", issue = "75251")]
    #[inline(always)]
    pub const fn as_mut_ptr(&mut self) -> *mut T {
        // `MaybeUninit` and `ManuallyDrop` are both `repr(transparent)` so we can cast the pointer.
        self as *mut _ as *mut T
    }

    /// Extracts the value from the `MaybeUninit<T>` container. This is a great way
    /// to ensure that the data will get dropped, because the resulting `T` is
    /// subject to the usual drop handling.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that the `MaybeUninit<T>` really is in an initialized
    /// state. Calling this when the content is not yet fully initialized causes immediate undefined
    /// behavior. The [type-level documentation][inv] contains more information about
    /// this initialization invariant.
    ///
    /// [inv]: #initialization-invariant
    ///
    /// On top of that, remember that most types have additional invariants beyond merely
    /// being considered initialized at the type level. For example, a `1`-initialized [`Vec<T>`]
    /// is considered initialized (under the current implementation; this does not constitute
    /// a stable guarantee) because the only requirement the compiler knows about it
    /// is that the data pointer must be non-null. Creating such a `Vec<T>` does not cause
    /// *immediate* undefined behavior, but will cause undefined behavior with most
    /// safe operations (including dropping it).
    ///
    /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
    ///
    /// # Examples
    ///
    /// Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<bool>::uninit();
    /// x.write(true);
    /// let x_init = unsafe { x.assume_init() };
    /// assert_eq!(x_init, true);
    /// ```
    ///
    /// *Incorrect* usage of this method:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// let x = MaybeUninit::<Vec<u32>>::uninit();
    /// let x_init = unsafe { x.assume_init() };
    /// // `x` had not been initialized yet, so this last line caused undefined behavior. ⚠
    /// ```
    #[stable(feature = "maybe_uninit", since = "1.36.0")]
    #[rustc_const_stable(feature = "const_maybe_uninit_assume_init", since = "1.59.0")]
    #[inline(always)]
    #[rustc_diagnostic_item = "assume_init"]
    #[track_caller]
    pub const unsafe fn assume_init(self) -> T {
        // SAFETY: the caller must guarantee that `self` is initialized.
        // This also means that `self` must be a `value` variant.
        unsafe {
            intrinsics::assert_inhabited::<T>();
            ManuallyDrop::into_inner(self.value)
        }
    }

    /// Reads the value from the `MaybeUninit<T>` container. The resulting `T` is subject
    /// to the usual drop handling.
    ///
    /// Whenever possible, it is preferable to use [`assume_init`] instead, which
    /// prevents duplicating the content of the `MaybeUninit<T>`.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that the `MaybeUninit<T>` really is in an initialized
    /// state. Calling this when the content is not yet fully initialized causes undefined
    /// behavior. The [type-level documentation][inv] contains more information about
    /// this initialization invariant.
    ///
    /// Moreover, similar to the [`ptr::read`] function, this function creates a
    /// bitwise copy of the contents, regardless whether the contained type
    /// implements the [`Copy`] trait or not. When using multiple copies of the
    /// data (by calling `assume_init_read` multiple times, or first calling
    /// `assume_init_read` and then [`assume_init`]), it is your responsibility
    /// to ensure that that data may indeed be duplicated.
    ///
    /// [inv]: #initialization-invariant
    /// [`assume_init`]: MaybeUninit::assume_init
    ///
    /// # Examples
    ///
    /// Correct usage of this method:
    ///
    /// ```rust
    /// #![feature(maybe_uninit_extra)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<u32>::uninit();
    /// x.write(13);
    /// let x1 = unsafe { x.assume_init_read() };
    /// // `u32` is `Copy`, so we may read multiple times.
    /// let x2 = unsafe { x.assume_init_read() };
    /// assert_eq!(x1, x2);
    ///
    /// let mut x = MaybeUninit::<Option<Vec<u32>>>::uninit();
    /// x.write(None);
    /// let x1 = unsafe { x.assume_init_read() };
    /// // Duplicating a `None` value is okay, so we may read multiple times.
    /// let x2 = unsafe { x.assume_init_read() };
    /// assert_eq!(x1, x2);
    /// ```
    ///
    /// *Incorrect* usage of this method:
    ///
    /// ```rust,no_run
    /// #![feature(maybe_uninit_extra)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Option<Vec<u32>>>::uninit();
    /// x.write(Some(vec![0, 1, 2]));
    /// let x1 = unsafe { x.assume_init_read() };
    /// let x2 = unsafe { x.assume_init_read() };
    /// // We now created two copies of the same vector, leading to a double-free ⚠ when
    /// // they both get dropped!
    /// ```
    #[unstable(feature = "maybe_uninit_extra", issue = "63567")]
    #[rustc_const_unstable(feature = "maybe_uninit_extra", issue = "63567")]
    #[inline(always)]
    #[track_caller]
    pub const unsafe fn assume_init_read(&self) -> T {
        // SAFETY: the caller must guarantee that `self` is initialized.
        // Reading from `self.as_ptr()` is safe since `self` should be initialized.
        unsafe {
            intrinsics::assert_inhabited::<T>();
            self.as_ptr().read()
        }
    }

    /// Drops the contained value in place.
    ///
    /// If you have ownership of the `MaybeUninit`, you can also use
    /// [`assume_init`] as an alternative.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that the `MaybeUninit<T>` really is
    /// in an initialized state. Calling this when the content is not yet fully
    /// initialized causes undefined behavior.
    ///
    /// On top of that, all additional invariants of the type `T` must be
    /// satisfied, as the `Drop` implementation of `T` (or its members) may
    /// rely on this. For example, setting a [`Vec<T>`] to an invalid but
    /// non-null address makes it initialized (under the current implementation;
    /// this does not constitute a stable guarantee), because the only
    /// requirement the compiler knows about it is that the data pointer must be
    /// non-null. Dropping such a `Vec<T>` however will cause undefined
    /// behaviour.
    ///
    /// [`assume_init`]: MaybeUninit::assume_init
    /// [`Vec<T>`]: ../../std/vec/struct.Vec.html
    #[unstable(feature = "maybe_uninit_extra", issue = "63567")]
    pub unsafe fn assume_init_drop(&mut self) {
        // SAFETY: the caller must guarantee that `self` is initialized and
        // satisfies all invariants of `T`.
        // Dropping the value in place is safe if that is the case.
        unsafe { ptr::drop_in_place(self.as_mut_ptr()) }
    }

    /// Gets a shared reference to the contained value.
    ///
    /// This can be useful when we want to access a `MaybeUninit` that has been
    /// initialized but don't have ownership of the `MaybeUninit` (preventing the use
    /// of `.assume_init()`).
    ///
    /// # Safety
    ///
    /// Calling this when the content is not yet fully initialized causes undefined
    /// behavior: it is up to the caller to guarantee that the `MaybeUninit<T>` really
    /// is in an initialized state.
    ///
    /// # Examples
    ///
    /// ### Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// let mut x = MaybeUninit::<Vec<u32>>::uninit();
    /// // Initialize `x`:
    /// x.write(vec![1, 2, 3]);
    /// // Now that our `MaybeUninit<_>` is known to be initialized, it is okay to
    /// // create a shared reference to it:
    /// let x: &Vec<u32> = unsafe {
    ///     // SAFETY: `x` has been initialized.
    ///     x.assume_init_ref()
    /// };
    /// assert_eq!(x, &vec![1, 2, 3]);
    /// ```
    ///
    /// ### *Incorrect* usages of this method:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// let x = MaybeUninit::<Vec<u32>>::uninit();
    /// let x_vec: &Vec<u32> = unsafe { x.assume_init_ref() };
    /// // We have created a reference to an uninitialized vector! This is undefined behavior. ⚠
    /// ```
    ///
    /// ```rust,no_run
    /// use std::{cell::Cell, mem::MaybeUninit};
    ///
    /// let b = MaybeUninit::<Cell<bool>>::uninit();
    /// // Initialize the `MaybeUninit` using `Cell::set`:
    /// unsafe {
    ///     b.assume_init_ref().set(true);
    ///    // ^^^^^^^^^^^^^^^
    ///    // Reference to an uninitialized `Cell<bool>`: UB!
    /// }
    /// ```
    #[stable(feature = "maybe_uninit_ref", since = "1.55.0")]
    #[rustc_const_stable(feature = "const_maybe_uninit_assume_init", since = "1.59.0")]
    #[cfg_attr(bootstrap, rustc_allow_const_fn_unstable(const_raw_ptr_deref))]
    #[inline(always)]
    pub const unsafe fn assume_init_ref(&self) -> &T {
        // SAFETY: the caller must guarantee that `self` is initialized.
        // This also means that `self` must be a `value` variant.
        unsafe {
            intrinsics::assert_inhabited::<T>();
            &*self.as_ptr()
        }
    }

    /// Gets a mutable (unique) reference to the contained value.
    ///
    /// This can be useful when we want to access a `MaybeUninit` that has been
    /// initialized but don't have ownership of the `MaybeUninit` (preventing the use
    /// of `.assume_init()`).
    ///
    /// # Safety
    ///
    /// Calling this when the content is not yet fully initialized causes undefined
    /// behavior: it is up to the caller to guarantee that the `MaybeUninit<T>` really
    /// is in an initialized state. For instance, `.assume_init_mut()` cannot be used to
    /// initialize a `MaybeUninit`.
    ///
    /// # Examples
    ///
    /// ### Correct usage of this method:
    ///
    /// ```rust
    /// use std::mem::MaybeUninit;
    ///
    /// # unsafe extern "C" fn initialize_buffer(buf: *mut [u8; 1024]) { *buf = [0; 1024] }
    /// # #[cfg(FALSE)]
    /// extern "C" {
    ///     /// Initializes *all* the bytes of the input buffer.
    ///     fn initialize_buffer(buf: *mut [u8; 1024]);
    /// }
    ///
    /// let mut buf = MaybeUninit::<[u8; 1024]>::uninit();
    ///
    /// // Initialize `buf`:
    /// unsafe { initialize_buffer(buf.as_mut_ptr()); }
    /// // Now we know that `buf` has been initialized, so we could `.assume_init()` it.
    /// // However, using `.assume_init()` may trigger a `memcpy` of the 1024 bytes.
    /// // To assert our buffer has been initialized without copying it, we upgrade
    /// // the `&mut MaybeUninit<[u8; 1024]>` to a `&mut [u8; 1024]`:
    /// let buf: &mut [u8; 1024] = unsafe {
    ///     // SAFETY: `buf` has been initialized.
    ///     buf.assume_init_mut()
    /// };
    ///
    /// // Now we can use `buf` as a normal slice:
    /// buf.sort_unstable();
    /// assert!(
    ///     buf.windows(2).all(|pair| pair[0] <= pair[1]),
    ///     "buffer is sorted",
    /// );
    /// ```
    ///
    /// ### *Incorrect* usages of this method:
    ///
    /// You cannot use `.assume_init_mut()` to initialize a value:
    ///
    /// ```rust,no_run
    /// use std::mem::MaybeUninit;
    ///
    /// let mut b = MaybeUninit::<bool>::uninit();
    /// unsafe {
    ///     *b.assume_init_mut() = true;
    ///     // We have created a (mutable) reference to an uninitialized `bool`!
    ///     // This is undefined behavior. ⚠
    /// }
    /// ```
    ///
    /// For instance, you cannot [`Read`] into an uninitialized buffer:
    ///
    /// [`Read`]: https://doc.rust-lang.org/std/io/trait.Read.html
    ///
    /// ```rust,no_run
    /// use std::{io, mem::MaybeUninit};
    ///
    /// fn read_chunk (reader: &'_ mut dyn io::Read) -> io::Result<[u8; 64]>
    /// {
    ///     let mut buffer = MaybeUninit::<[u8; 64]>::uninit();
    ///     reader.read_exact(unsafe { buffer.assume_init_mut() })?;
    ///                             // ^^^^^^^^^^^^^^^^^^^^^^^^
    ///                             // (mutable) reference to uninitialized memory!
    ///                             // This is undefined behavior.
    ///     Ok(unsafe { buffer.assume_init() })
    /// }
    /// ```
    ///
    /// Nor can you use direct field access to do field-by-field gradual initialization:
    ///
    /// ```rust,no_run
    /// use std::{mem::MaybeUninit, ptr};
    ///
    /// struct Foo {
    ///     a: u32,
    ///     b: u8,
    /// }
    ///
    /// let foo: Foo = unsafe {
    ///     let mut foo = MaybeUninit::<Foo>::uninit();
    ///     ptr::write(&mut foo.assume_init_mut().a as *mut u32, 1337);
    ///                  // ^^^^^^^^^^^^^^^^^^^^^
    ///                  // (mutable) reference to uninitialized memory!
    ///                  // This is undefined behavior.
    ///     ptr::write(&mut foo.assume_init_mut().b as *mut u8, 42);
    ///                  // ^^^^^^^^^^^^^^^^^^^^^
    ///                  // (mutable) reference to uninitialized memory!
    ///                  // This is undefined behavior.
    ///     foo.assume_init()
    /// };
    /// ```
    #[stable(feature = "maybe_uninit_ref", since = "1.55.0")]
    #[rustc_const_unstable(feature = "const_maybe_uninit_assume_init", issue = "none")]
    #[inline(always)]
    pub const unsafe fn assume_init_mut(&mut self) -> &mut T {
        // SAFETY: the caller must guarantee that `self` is initialized.
        // This also means that `self` must be a `value` variant.
        unsafe {
            intrinsics::assert_inhabited::<T>();
            &mut *self.as_mut_ptr()
        }
    }

    /// Extracts the values from an array of `MaybeUninit` containers.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that all elements of the array are
    /// in an initialized state.
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(maybe_uninit_uninit_array)]
    /// #![feature(maybe_uninit_array_assume_init)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut array: [MaybeUninit<i32>; 3] = MaybeUninit::uninit_array();
    /// array[0].write(0);
    /// array[1].write(1);
    /// array[2].write(2);
    ///
    /// // SAFETY: Now safe as we initialised all elements
    /// let array = unsafe {
    ///     MaybeUninit::array_assume_init(array)
    /// };
    ///
    /// assert_eq!(array, [0, 1, 2]);
    /// ```
    #[unstable(feature = "maybe_uninit_array_assume_init", issue = "80908")]
    #[inline(always)]
    #[track_caller]
    pub unsafe fn array_assume_init<const N: usize>(array: [Self; N]) -> [T; N] {
        // SAFETY:
        // * The caller guarantees that all elements of the array are initialized
        // * `MaybeUninit<T>` and T are guaranteed to have the same layout
        // * `MaybeUninit` does not drop, so there are no double-frees
        // And thus the conversion is safe
        unsafe {
            intrinsics::assert_inhabited::<[T; N]>();
            (&array as *const _ as *const [T; N]).read()
        }
    }

    /// Assuming all the elements are initialized, get a slice to them.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that the `MaybeUninit<T>` elements
    /// really are in an initialized state.
    /// Calling this when the content is not yet fully initialized causes undefined behavior.
    ///
    /// See [`assume_init_ref`] for more details and examples.
    ///
    /// [`assume_init_ref`]: MaybeUninit::assume_init_ref
    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[inline(always)]
    pub const unsafe fn slice_assume_init_ref(slice: &[Self]) -> &[T] {
        // SAFETY: casting slice to a `*const [T]` is safe since the caller guarantees that
        // `slice` is initialized, and`MaybeUninit` is guaranteed to have the same layout as `T`.
        // The pointer obtained is valid since it refers to memory owned by `slice` which is a
        // reference and thus guaranteed to be valid for reads.
        unsafe { &*(slice as *const [Self] as *const [T]) }
    }

    /// Assuming all the elements are initialized, get a mutable slice to them.
    ///
    /// # Safety
    ///
    /// It is up to the caller to guarantee that the `MaybeUninit<T>` elements
    /// really are in an initialized state.
    /// Calling this when the content is not yet fully initialized causes undefined behavior.
    ///
    /// See [`assume_init_mut`] for more details and examples.
    ///
    /// [`assume_init_mut`]: MaybeUninit::assume_init_mut
    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[rustc_const_unstable(feature = "const_maybe_uninit_assume_init", issue = "none")]
    #[inline(always)]
    pub const unsafe fn slice_assume_init_mut(slice: &mut [Self]) -> &mut [T] {
        // SAFETY: similar to safety notes for `slice_get_ref`, but we have a
        // mutable reference which is also guaranteed to be valid for writes.
        unsafe { &mut *(slice as *mut [Self] as *mut [T]) }
    }

    /// Gets a pointer to the first element of the array.
    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[inline(always)]
    pub const fn slice_as_ptr(this: &[MaybeUninit<T>]) -> *const T {
        this.as_ptr() as *const T
    }

    /// Gets a mutable pointer to the first element of the array.
    #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
    #[inline(always)]
    pub const fn slice_as_mut_ptr(this: &mut [MaybeUninit<T>]) -> *mut T {
        this.as_mut_ptr() as *mut T
    }

    /// Copies the elements from `src` to `this`, returning a mutable reference to the now initialized contents of `this`.
    ///
    /// If `T` does not implement `Copy`, use [`write_slice_cloned`]
    ///
    /// This is similar to [`slice::copy_from_slice`].
    ///
    /// # Panics
    ///
    /// This function will panic if the two slices have different lengths.
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(maybe_uninit_write_slice)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut dst = [MaybeUninit::uninit(); 32];
    /// let src = [0; 32];
    ///
    /// let init = MaybeUninit::write_slice(&mut dst, &src);
    ///
    /// assert_eq!(init, src);
    /// ```
    ///
    /// ```
    /// #![feature(maybe_uninit_write_slice, vec_spare_capacity)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut vec = Vec::with_capacity(32);
    /// let src = [0; 16];
    ///
    /// MaybeUninit::write_slice(&mut vec.spare_capacity_mut()[..src.len()], &src);
    ///
    /// // SAFETY: we have just copied all the elements of len into the spare capacity
    /// // the first src.len() elements of the vec are valid now.
    /// unsafe {
    ///     vec.set_len(src.len());
    /// }
    ///
    /// assert_eq!(vec, src);
    /// ```
    ///
    /// [`write_slice_cloned`]: MaybeUninit::write_slice_cloned
    #[unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
    pub fn write_slice<'a>(this: &'a mut [MaybeUninit<T>], src: &[T]) -> &'a mut [T]
    where
        T: Copy,
    {
        // SAFETY: &[T] and &[MaybeUninit<T>] have the same layout
        let uninit_src: &[MaybeUninit<T>] = unsafe { super::transmute(src) };

        this.copy_from_slice(uninit_src);

        // SAFETY: Valid elements have just been copied into `this` so it is initialized
        unsafe { MaybeUninit::slice_assume_init_mut(this) }
    }

    /// Clones the elements from `src` to `this`, returning a mutable reference to the now initialized contents of `this`.
    /// Any already initialized elements will not be dropped.
    ///
    /// If `T` implements `Copy`, use [`write_slice`]
    ///
    /// This is similar to [`slice::clone_from_slice`] but does not drop existing elements.
    ///
    /// # Panics
    ///
    /// This function will panic if the two slices have different lengths, or if the implementation of `Clone` panics.
    ///
    /// If there is a panic, the already cloned elements will be dropped.
    ///
    /// # Examples
    ///
    /// ```
    /// #![feature(maybe_uninit_write_slice)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut dst = [MaybeUninit::uninit(), MaybeUninit::uninit(), MaybeUninit::uninit(), MaybeUninit::uninit(), MaybeUninit::uninit()];
    /// let src = ["wibbly".to_string(), "wobbly".to_string(), "timey".to_string(), "wimey".to_string(), "stuff".to_string()];
    ///
    /// let init = MaybeUninit::write_slice_cloned(&mut dst, &src);
    ///
    /// assert_eq!(init, src);
    /// ```
    ///
    /// ```
    /// #![feature(maybe_uninit_write_slice, vec_spare_capacity)]
    /// use std::mem::MaybeUninit;
    ///
    /// let mut vec = Vec::with_capacity(32);
    /// let src = ["rust", "is", "a", "pretty", "cool", "language"];
    ///
    /// MaybeUninit::write_slice_cloned(&mut vec.spare_capacity_mut()[..src.len()], &src);
    ///
    /// // SAFETY: we have just cloned all the elements of len into the spare capacity
    /// // the first src.len() elements of the vec are valid now.
    /// unsafe {
    ///     vec.set_len(src.len());
    /// }
    ///
    /// assert_eq!(vec, src);
    /// ```
    ///
    /// [`write_slice`]: MaybeUninit::write_slice
    #[unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
    pub fn write_slice_cloned<'a>(this: &'a mut [MaybeUninit<T>], src: &[T]) -> &'a mut [T]
    where
        T: Clone,
    {
        // unlike copy_from_slice this does not call clone_from_slice on the slice
        // this is because `MaybeUninit<T: Clone>` does not implement Clone.

        struct Guard<'a, T> {
            slice: &'a mut [MaybeUninit<T>],
            initialized: usize,
        }

        impl<'a, T> Drop for Guard<'a, T> {
            fn drop(&mut self) {
                let initialized_part = &mut self.slice[..self.initialized];
                // SAFETY: this raw slice will contain only initialized objects
                // that's why, it is allowed to drop it.
                unsafe {
                    crate::ptr::drop_in_place(MaybeUninit::slice_assume_init_mut(initialized_part));
                }
            }
        }

        assert_eq!(this.len(), src.len(), "destination and source slices have different lengths");
        // NOTE: We need to explicitly slice them to the same length
        // for bounds checking to be elided, and the optimizer will
        // generate memcpy for simple cases (for example T = u8).
        let len = this.len();
        let src = &src[..len];

        // guard is needed b/c panic might happen during a clone
        let mut guard = Guard { slice: this, initialized: 0 };

        for i in 0..len {
            guard.slice[i].write(src[i].clone());
            guard.initialized += 1;
        }

        super::forget(guard);

        // SAFETY: Valid elements have just been written into `this` so it is initialized
        unsafe { MaybeUninit::slice_assume_init_mut(this) }
    }
}


text:
namespace ProgrammingLanguage {

    using namespace clang::ast_matchers;

    //find func with try catch in it
    extern StatementMatcher tryInFuncMatcherPL;

    class TryInFuncPrinter : public MatchFinder::MatchCallback {
    public:
        virtual void run(const MatchFinder::MatchResult &Result);
    };
}
#endif

redpajama_set_name: RedPajamaGithub


text:
// Filename: UFunction.h
// Created on 19 Mar 2004 by Boyce Griffith
//
// Copyright (c) 2002-2013, Boyce Griffith
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright
//      notice, this list of conditions and the following disclaimer in the
//      documentation and/or other materials provided with the distribution.
//
//    * Neither the name of New York University nor the names of its
//      contributors may be used to endorse or promote products derived from
//      this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.

#ifndef included_UFunction
#define included_UFunction

/////////////////////////////// INCLUDES /////////////////////////////////////

// IBTK INCLUDES
#include <ibtk/CartGridFunction.h>

// SAMRAI INCLUDES
#include <CartesianGridGeometry.h>

// BLITZ++ INCLUDES
#include <blitz/tinyvec2.h>

// C++ namespace delcarations
#include <ibamr/app_namespaces.h>

/////////////////////////////// CLASS DEFINITION /////////////////////////////

/*!
 * \brief Class to initialize the value of the advection velocity u.
 */
class UFunction
    : public CartGridFunction
{
public:
    /*!
     * \brief Constructor.
     */
    UFunction(
        const string& object_name,
        Pointer<GridGeometry<NDIM> > grid_geom,
        Pointer<Database> input_db);

    /*!
     * \brief Destructor.
     */
    ~UFunction();

    /*!
     * Indicates whether the concrete CartGridFunction object is time
     * dependent.
     */
    bool
    isTimeDependent() const
        { return true; }

    /*!
     * Set the data on the patch interior to some values.
     */
    void
    setDataOnPatch(
        int data_idx,
        Pointer<Variable<NDIM> > var,
        Pointer<Patch<NDIM> > patch,
        double data_time,
        bool initial_time=false,
        Pointer<PatchLevel<NDIM> > level=Pointer<PatchLevel<NDIM> >(NULL));

protected:

private:
    /*!
     * \brief Default constructor.
     *
     * \note This constructor is not implemented and should not be used.
     */
    UFunction();

    /*!
     * \brief Copy constructor.
     *
     * \note This constructor is not implemented and should not be used.
     *
     * \param from The value to copy to this object.
     */
    UFunction(
        const UFunction& from);

    /*!
     * \brief Assignment operator.
     *
     * \note This operator is not implemented and should not be used.
     *
     * \param that The value to assign to this object.
     *
     * \return A reference to this object.
     */
    UFunction&
    operator=(
        const UFunction& that);

    /*!
     * Read input values, indicated above, from given database.
     */
    void
    getFromInput(
        Pointer<Database> db);

    /*
     * The object name is used as a handle to databases stored in restart files
     * and for error reporting purposes.
     */
    string d_object_name;

    /*
     * The grid geometry.
     */
    Pointer<CartesianGridGeometry<NDIM> > d_grid_geom;

    /*
     * The center of the initial data.
     */
    TinyVector<double,NDIM> d_X;

    /*
     * The initialization type.
     */
    string d_init_type;

    /*
     * The amplification and frequency of the sin wave used in setting
     * velocities.
     */
    TinyVector<double,NDIM> d_kappa, d_omega;

    /*
     * Parameters for uniform constant velocity.
     */
    TinyVector<double,NDIM> d_uniform_u;
};

/////////////////////////////// INLINE ///////////////////////////////////////

//#include "UFunction.I"

//////////////////////////////////////////////////////////////////////////////

#endif //#ifndef included_UFunction


text:
class Jazz2FormatDataBlock {
public:
    Jazz2FormatDataBlock(QByteArray originalData, bool compressed, quint32 len, quint8 idx = 0);

    bool readBool();
    char readChar();
    quint16 readUShort();
    quint32 readUInt();
    float readFloat();
    QByteArray readRawBytes(int n);
    void discardBytes(int n);
    void clear();
    int length();

private:
    QByteArray data;
    std::unique_ptr<QDataStream> stream;

    QByteArray convertQUintToByteArray(quint32 val);

    template<typename T>
    T readValue();
};


text:
#import <Foundation/Foundation.h>

#import "RTCMacros.h"
#import "RTCVideoEncoder.h"

RTC_OBJC_EXPORT
@interface RTCVideoEncoderVP9 : NSObject

/* This returns a VP9 encoder that can be returned from a RTCVideoEncoderFactory injected into
 * RTCPeerConnectionFactory. Even though it implements the RTCVideoEncoder protocol, it can not be
 * used independently from the RTCPeerConnectionFactory.
 */
+ (id<RTCVideoEncoder>)vp9Encoder;

@end


text:
import Modal from 'flarum/components/Modal';
import Button from 'flarum/components/Button';

export default class FlagPostModal extends Modal {
  init() {
    super.init();

    this.success = false;

    this.reason = m.prop('');
    this.reasonDetail = m.prop('');
  }

  className() {
    return 'FlagPostModal Modal--small';
  }

  title() {
    return app.translator.trans('flarum-flags.forum.flag_post.title');
  }

  content() {
    if (this.success) {
      return (

{app.translator.trans('flarum-flags.forum.flag_post.confirmation_message')}

              <Button className="Button Button--primary Button--block" onclick={this.hide.bind(this)}>
                {app.translator.trans('flarum-flags.forum.flag_post.dismiss_button')}
              </Button>

      );
    }

    const guidelinesUrl = app.forum.attribute('guidelinesUrl');

    return (

                <input type="radio" name="reason" checked={this.reason() === 'off_topic'} value="off_topic" onclick={m.withAttr('value', this.reason)}/>
                {app.translator.trans('flarum-flags.forum.flag_post.reason_off_topic_label')}
                {app.translator.trans('flarum-flags.forum.flag_post.reason_off_topic_text')}

                <input type="radio" name="reason" checked={this.reason() === 'inappropriate'} value="inappropriate" onclick={m.withAttr('value', this.reason)}/>
                {app.translator.trans('flarum-flags.forum.flag_post.reason_inappropriate_label')}
                {app.translator.trans('flarum-flags.forum.flag_post.reason_inappropriate_text', {
                  a: guidelinesUrl ?  : undefined
                })}

                <input type="radio" name="reason" checked={this.reason() === 'spam'} value="spam" onclick={m.withAttr('value', this.reason)}/>
                {app.translator.trans('flarum-flags.forum.flag_post.reason_spam_label')}
                {app.translator.trans('flarum-flags.forum.flag_post.reason_spam_text')}

                <input type="radio" name="reason" checked={this.reason() === 'other'} value="other" onclick={m.withAttr('value', this.reason)}/>
                {app.translator.trans('flarum-flags.forum.flag_post.reason_other_label')}
                {this.reason() === 'other' ? (
                  <textarea className="FormControl" value={this.reasonDetail()} oninput={m.withAttr('value', this.reasonDetail)}></textarea>
                ) : ''}

            <Button
              className="Button Button--primary Button--block"
              type="submit"
              loading={this.loading}
              disabled={!this.reason()}>
              {app.translator.trans('flarum-flags.forum.flag_post.submit_button')}
            </Button>

    );
  }

  onsubmit(e) {
    e.preventDefault();

    this.loading = true;

    app.store.createRecord('flags').save({
      reason: this.reason() === 'other' ? null : this.reason(),
      reasonDetail: this.reasonDetail(),
      relationships: {
        user: app.session.user,
        post: this.props.post
      }
    })
      .then(() => this.success = true)
      .catch(() => {})
      .then(this.loaded.bind(this));
  }
}


text:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace VectorAccelerator
{
    /// <summary>
    /// The tag refers to a temporary NArray (i.e. one that is temporarily created within the context)
    /// </summary>
    public class LocalNArrayTag
    {
        public int Index { get; private set; }

        public LocalNArrayTag(int index)
        {
            Index = index;
        }
    }
}


text:
// Generated by Haxe 3.4.0
#ifndef INCLUDED_kha_input_Keyboard
#define INCLUDED_kha_input_Keyboard

#ifndef HXCPP_H
#include <hxcpp.h>
#endif

#ifndef INCLUDED_kha_network_Controller
#include <kha/network/Controller.h>
#endif
HX_DECLARE_CLASS2(haxe,io,Bytes)
HX_DECLARE_CLASS1(kha,Key)
HX_DECLARE_CLASS2(kha,input,Keyboard)
HX_DECLARE_CLASS2(kha,network,Controller)

namespace kha{
namespace input{

class HXCPP_CLASS_ATTRIBUTES Keyboard_obj : public  ::kha::network::Controller_obj
{
	public:
		typedef  ::kha::network::Controller_obj super;
		typedef Keyboard_obj OBJ_;
		Keyboard_obj();

	public:
		enum { _hx_ClassId = 0x58f0db11 };

		void __construct();
		inline void *operator new(size_t inSize, bool inContainer=true,const char *inName="kha.input.Keyboard")
			{ return hx::Object::operator new(inSize,inContainer,inName); }
		inline void *operator new(size_t inSize, int extra)
			{ return hx::Object::operator new(inSize+extra,true,"kha.input.Keyboard"); }
		static hx::ObjectPtr< Keyboard_obj > __new();
		static hx::ObjectPtr< Keyboard_obj > __alloc(hx::Ctx *_hx_ctx);
		static void * _hx_vtable;
		static Dynamic __CreateEmpty();
		static Dynamic __Create(hx::DynamicArray inArgs);
		//~Keyboard_obj();

		HX_DO_RTTI_ALL;
		hx::Val __Field(const ::String &inString, hx::PropertyAccess inCallProp);
		static bool __GetStatic(const ::String &inString, Dynamic &outValue, hx::PropertyAccess inCallProp);
		hx::Val __SetField(const ::String &inString,const hx::Val &inValue, hx::PropertyAccess inCallProp);
		static bool __SetStatic(const ::String &inString, Dynamic &ioValue, hx::PropertyAccess inCallProp);
		void __GetFields(Array< ::String> &outFields);
		static void __register();
		void __Mark(HX_MARK_PARAMS);
		void __Visit(HX_VISIT_PARAMS);
		bool _hx_isInstanceOf(int inClassId);
		::String __ToString() const { return HX_HCSTRING("Keyboard","\xc7","\x78","\xdb","\x41"); }

		static void __boot();
		static  ::Dynamic __meta__;
		static  ::kha::input::Keyboard get(hx::Null< int >  num);
		static ::Dynamic get_dyn();

		static  ::kha::input::Keyboard instance;
		void notify( ::Dynamic downListener, ::Dynamic upListener);
		::Dynamic notify_dyn();

		void remove( ::Dynamic downListener, ::Dynamic upListener);
		::Dynamic remove_dyn();

		virtual void show();
		::Dynamic show_dyn();

		virtual void hide();
		::Dynamic hide_dyn();

		::Array< ::Dynamic> downListeners;
		::Array< ::Dynamic> upListeners;
		void sendDownEvent( ::kha::Key key,::String _hx_char);
		::Dynamic sendDownEvent_dyn();

		void sendUpEvent( ::kha::Key key,::String _hx_char);
		::Dynamic sendUpEvent_dyn();

		virtual void _receive( ::haxe::io::Bytes bytes);

};

} // end namespace kha
} // end namespace input

#endif /* INCLUDED_kha_input_Keyboard */


text:
def count_inversion(sequence):
    flag, answer, sequence = True, 0, list(sequence)
    while flag:
        flag = False
        for i in xrange(1, len(sequence)):
            if sequence[i-1] > sequence[i]:
                sequence[i], sequence[i-1] = sequence[i-1], sequence[i]
                answer += 1
                flag = True
    return answer

def test_function():
    assert count_inversion((1, 2, 5, 3, 4, 7, 6)) == 3, "Example"
    assert count_inversion((0, 1, 2, 3)) == 0, "Sorted"
    assert count_inversion((99, -99)) == 1, "Two numbers"
    assert count_inversion((5, 3, 2, 1, 0)) == 10, "Reversed"


text:
NS_ASSUME_NONNULL_BEGIN

@interface UITextField (SUIAdditions)

@property (nonatomic) IBInspectable BOOL sui_showKeyboard;

- (void)sui_dismissKeyboard;

@end

NS_ASSUME_NONNULL_END


text:
package com.deleidos.rtws.commons.util.repository;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ConfigDirSystemRepository extends AbstractSystemRepository {

	private File configPath = null;

	/** Configuration Path */
	public void setConfigPath(String configPath) {
		this.configPath = new File(configPath);
	}
	public String getConfigPath() {
		return this.configPath.getPath();
	}

	public void initialize() { }
	public void dispose() { }

	@Override
	public void setCredentials(RepositoryCredentials credentials) {
		// No credentials for config file based repositories
	}

	@Override
	public void createUserStructures(RepositoryCredentials credentials, String userName) {
		// No users for config based repositories
	}

	@Override
	public void deleteUserStructures(RepositoryCredentials credentials, String userName) {
		// No users for config based repositories
	}

	@Override
	public void createPath(Visibility visibility, String path) {
		File pathFile = new File(configPath, path);
		if (!pathFile.exists()) {
			if (!pathFile.mkdir()) {
				throw new SystemRepositoryException("createPath failed for " + pathFile.getPath());
			}
		}
	}

	@Override
	public void deletePath(Visibility visibility, String path) {
		File pathFile = new File(configPath, path);
		if (pathFile.exists()) {
			if (!pathFile.delete()) {
				throw new SystemRepositoryException("deletePath failed for " + pathFile.getPath());
			}
		}
	}

	@Override
	public void store(Visibility visibility, String path, String filename, InputStream data) {
		try {
			File pathFile = new File(configPath, path);
			File file = new File(pathFile, filename);
			BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(file));
			int c;
			while ((c = data.read()) != -1) {
			    out.write(c);
			}
			data.close();
		    out.close();
		}
		catch (IOException e) {
			throw new SystemRepositoryException("Cannot store " + filename, e);
		}
	}

	@Override
	public InputStream retrieve(Visibility visibility, String path, String filename, String userName) {
		InputStream result = null;
		File pathFile = new File(configPath, path);
		File file = new File(pathFile, filename);
		try {
			result = new FileInputStream(file);
		}
		catch (FileNotFoundException e) {
			throw new SystemRepositoryException("Cannot retrieve " + file.getPath(), e);
		}
		return result;
	}

	@Override
	public void delete(Visibility visibility, String path, String filename) {
		File pathFile = new File(configPath, path);
		File file = new File(pathFile, filename);
		if (!file.delete()) {
			throw new SystemRepositoryException("delete failed for " + file.getPath());
		}
	}

	@Override
	public List<RepoFile> listFiles(Visibility visibility, String path, final String filterPattern, String userName) {

		// Assume the first pattern has the file set name in it
		FilenameFilter filter = new FilenameFilter() {
			public boolean accept(File dir, String name) {
				if ((filterPattern == null) || (name.contains(filterPattern))) {
					return true;
				}
				return false;
			}
		};

		File pathFile = new File(configPath, path);
		File[] files = pathFile.listFiles(filter);

		ArrayList<RepoFile> result = new ArrayList<RepoFile>();
		for (File currFile : files) {
			RepoFile currRepoFile = new RepoFile();
			currRepoFile.setName(currFile.getName());
			currRepoFile.setDirectory(currFile.isDirectory());
			result.add(currRepoFile);
		}

		Collections.sort(result, new RepoFileComparator());

		return result;
	}

}


text:
(function() {

/**
 * @fileoverview Utility for generating an VP9 codec string.
 *
 * VP9 Metadata is used to construct an VP9 codec string.
 * Values are not provided if we don't have a test stream that uses that value.
 *
 * @see https://www.webmproject.org/vp9/mp4/
 */
const VP9Codec = {};

/**
 * An integer that specifies the VP9 codec profile.
 * @enum {number}
 */
VP9Codec.Profile = {
  /**
   * Bit Depth: 8 or 10
   * Monochrome Support: Yes
   * Chrome subsampling: YUV 4:2:0
   */
  VP9_MAIN: 0,
  VP9_2: 2,
};

/**
 * @enum {number}
 */
VP9Codec.BitDepth = {
  SDR: 8,
  HDR: 10,
};

/**
 * @enum {number}
 */
VP9Codec.ChromaSubsampling = {
  YUV_420: 1,  // YUV 4:2:0
};

/**
 * @enum {number}
 */
VP9Codec.ColorPrimaries = {
  CP_BT_709: 1,   // BT.709
  CP_BT_2020: 9,  // BT.2020
};

/**
 * @enum {number}
 */
VP9Codec.TransferCharacteristics = {
  TC_BT_709: 1,       // BT.709
  TC_SMPTE_2084: 16,  // SMPTE ST 2084, ITU BT.2100 PQ
  TC_HLG: 18,         // BT.2100 HLG, ARIB STD-B67
};

/**
 * @enum {number}
 */
VP9Codec.MatrixCoefficients = {
  MC_BT_709: 1,       // BT.709
  MC_BT_2020_NCL: 9,  // BT.2020 non-constant luminance, BT.2100 YCbCr
};

/**
 * @enum {number}
 */
VP9Codec.VideoFullRangeFlag = {
  TV: 0,  // TV (limited) range
};

/**
 * Returns the value of seq_level_idx as defined in the spec.
 * @param {string} level e.g. '2.1'
 * @return {number} the corresponding integer 21.
 */
VP9Codec.seqLevelIdx = function(level) {
  var xY = level.split('.');
  var x = parseInt(xY[0], 10);
  var y = parseInt(xY[1], 10);
  return x * 10 + y;
};

VP9Codec.defaultVp9Metadata = function() {
  return {
    profile: this.Profile.VP9_MAIN,
    level: '5.1',
    bitDepth: this.BitDepth.SDR,
    chromaSubsampling: this.ChromaSubsampling.YUV_420,
    colorPrimaries: this.ColorPrimaries.CP_BT_709,
    transferCharacteristics: this.TransferCharacteristics.TC_BT_709,
    matrixCoefficients: this.MatrixCoefficients.MC_BT_709,
    videoFullRangeFlag: this.VideoFullRangeFlag.TV,
  };
};

/**
 * Default HDR metadata without detiailed HDR characteristics.
 */
VP9Codec.defaultHdrMetadata = function() {
  return {
    profile: this.Profile.VP9_2,
    level: '5.1',
    bitDepth: this.BitDepth.HDR,
    chromaSubsampling: this.ChromaSubsampling.YUV_420,
    colorPrimaries: this.ColorPrimaries.CP_BT_2020,
    matrixCoefficients: this.MatrixCoefficients.MC_BT_2020_NCL,
    videoFullRangeFlag: this.VideoFullRangeFlag.TV,
  };
};

/**
 * Common overrides for HDR HLG streams.
 */
VP9Codec.hlgMetadata = function() {
  return Object.assign({}, this.defaultHdrMetadata(), {
    transferCharacteristics: this.TransferCharacteristics.TC_HLG,
  });
};

/**
 * Common overrides for HDR PQ streams.
 */
VP9Codec.pqMetadata = function() {
  return Object.assign({}, this.defaultHdrMetadata(), {
    transferCharacteristics: this.TransferCharacteristics.TC_SMPTE_2084,
  });
};

/**
 * Returns an VP9 codecs parameter string,
 * e.g. "vp09.02.10.10.01.09.16.09.01".
 * See https://www.webmproject.org/vp9/mp4/
 * @param {!object} metadataOverrides Values that differ from the defaults
 *   in defaultVp9Metadata.
 * @param {?boolean=} forceLongForm If false, return a short form codec string
 *   if no optional metadata values are overridden.
 * @param {!string} forceForm return the correspondning codec string
 *   L - longForm, M - Medium form.
 * @return {string}
 */
VP9Codec.codecString = function(metadataOverrides, forceForm = null) {
  const defaultMetadata = this.defaultVp9Metadata();
  const longFormRequired = vp9Metadata => {
    const optionalKeys = [
      'chromaSubsampling',
      'colorPrimaries',
      'matrixCoefficients',
      'transferCharacteristics',
      'videoFullRangeFlag',
    ];
    for (let i = 0; i < optionalKeys.length; i++) {
      const key = optionalKeys[i];
      if (vp9Metadata[key] != defaultMetadata[key]) {
        return true;
      }
    }
    return false;
  };

  const vp9Metadata = Object.assign({}, defaultMetadata, metadataOverrides);

  // Mandatory values
  const outputArray = ['vp09'];
  outputArray.push(vp9Metadata.profile.toString().padStart(2, '0'));
  outputArray.push(
      `${this.seqLevelIdx(vp9Metadata.level).toString().padStart(2, '0')}`);
  outputArray.push(vp9Metadata.bitDepth.toString().padStart(2, '0'));

  // Optional values
  if (longFormRequired(vp9Metadata) && forceForm != 'M') {
    forceForm = 'L';
  }
  if (forceForm && forceForm != 'L' && forceForm != 'M') {
    util.dlog(2, 'Invalid parameter: forceForm must be either \'L\' or \'M\'.');
  } else if (forceForm) {
    outputArray.push(vp9Metadata.chromaSubsampling.toString().padStart(2, '0'));
    outputArray.push(vp9Metadata.colorPrimaries.toString().padStart(2, '0'));
    outputArray.push(
        vp9Metadata.transferCharacteristics.toString().padStart(2, '0'));
    outputArray.push(
        vp9Metadata.matrixCoefficients.toString().padStart(2, '0'));

    if (forceForm == 'L') {
      outputArray.push(
          vp9Metadata.videoFullRangeFlag.toString().padStart(2, '0'));
    }
  }
  return outputArray.join('.');
};

/**
 * Add common HDR HLG metadata before generating the codec string.
 * @param {!object} metadataOverrides Values that differ from the
 *     defaults
 *   in hlgMetadata or defaultVp9Metadata.
 * @return {string}
 */
VP9Codec.hlgCodecString = function(metadataOverrides) {
  return this.codecString(
      Object.assign({}, this.hlgMetadata(), metadataOverrides));
};

/**
 * Add common HDR PQ metadata before generating the codec string.
 * @param {!object} metadataOverrides Values that differ from the
 *     defaults
 *   in pqMetadata or defaultVp9Metadata.
 * @return {string}
 */
VP9Codec.pqCodecString = function(metadataOverrides) {
  return this.codecString(
      Object.assign({}, this.pqMetadata(), metadataOverrides));
};

window.VP9Codec = VP9Codec;
})();

try {
  exports.VP9Codec = window.VP9Codec;
} catch (e) {
  // do nothing, this function is not supposed to work for browser, but it's for
  // Node js to generate json file instead.
}


text: <!doctype html>   <meta charset="utf-8"> <title></title> <meta name="description" content=""> <meta name="viewport" content="width=device-width">  <link rel="stylesheet" href="styles/vendor.3fc6b73d.css"> <link rel="stylesheet" href="styles/main.23fd591d.css">


text:
from . import cpuinfo, progressbar
from .misc import *
from .time import *


text:
Ti=Global Alliance for Genomics and Health

sec=<b>Global Alliance for Genomics and Health</b> – a collaborative community of individuals and organizations that collectively provide foundational policy, technology standards, leadership, and sustainment to enable the ethical and productive processing and use of genomic and health-related data.

=[G/Z/Base]


text:
package io.reactivex.netty.contexts.http;

import com.netflix.server.context.ContextSerializationException;
import io.netty.handler.codec.http.DefaultHttpRequest;
import io.netty.handler.codec.http.DefaultHttpResponse;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.reactivex.netty.contexts.BidirectionalTestContext;
import io.reactivex.netty.contexts.BidirectionalTestContextSerializer;
import io.reactivex.netty.contexts.ContextAttributeStorageHelper;
import io.reactivex.netty.contexts.ContextKeySupplier;
import io.reactivex.netty.contexts.ContextsContainer;
import io.reactivex.netty.contexts.ContextsContainerImpl;
import io.reactivex.netty.contexts.RxContexts;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;

/**
 * @author Nitesh Kant
 */
public class ClientHandlerTest {

    public static final String CTX_1_NAME = "ctx1";
    public static final BidirectionalTestContext CTX_1_VAL = new BidirectionalTestContext(CTX_1_NAME);

    @Before
    public void setUp() throws Exception {
        System.err.print(">>>> ClientHandlerTest.setUp()");
        RxContexts.DEFAULT_CORRELATOR.dumpThreadState(System.err);
    }

    @After
    public void tearDown() throws Exception {
        System.err.print(">>>> ClientHandlerTest.tearDown()");
        RxContexts.DEFAULT_CORRELATOR.dumpThreadState(System.err);
    }

    @Test
    public void testRequest() throws Exception {
        HandlerHolder holder = new HandlerHolder(false, "ClientHandlerTest.testRequest");
        sendRequestAndAssert(holder);
    }

    @Test
    public void testResponse() throws Exception {
        HandlerHolder holder = new HandlerHolder(false, "ClientHandlerTest.testResponse");
        sendRequestAndAssert(holder);

        HttpResponse response = createResponseWithCtxHeaders(holder);

        holder.handler.channelRead(holder.ctx, response);

        ContextsContainer container = ContextAttributeStorageHelper.getContainer(holder.ctx, holder.requestId);
        Assert.assertEquals("Context not available in client response", CTX_1_VAL, container.getContext(CTX_1_NAME));
    }

    private static DefaultHttpResponse createResponseWithCtxHeaders(HandlerHolder holder)
            throws ContextSerializationException {
        DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
        holder.addSerializedContext(response, CTX_1_NAME, CTX_1_VAL, new BidirectionalTestContextSerializer());
        return response;
    }

    private static void sendRequestAndAssert(HandlerHolder holder) throws Exception {
        holder.correlator.onNewServerRequest(holder.requestId, new ContextsContainerImpl(holder.keySupplier));

        try {
            DefaultHttpRequest request = new DefaultHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "");
            holder.addSerializedContext(request, CTX_1_NAME, CTX_1_VAL, new BidirectionalTestContextSerializer());
            holder.handler.write(holder.ctx, request, holder.ctx.newPromise());

            Assert.assertNotNull("Context container not set after request sent.",
                                 ContextAttributeStorageHelper.getContainer(holder.ctx, holder.requestId));

            ContextKeySupplier supplier = new HttpContextKeySupplier(request.headers());
            ContextsContainer container = new ContextsContainerImpl(supplier);

            Assert.assertEquals("Context not available in the container.", CTX_1_VAL, container.getContext(CTX_1_NAME));
            Assert.assertEquals("Request Id header not added.", holder.getRequestId(),
                                request.headers().get(holder.getProvider().getRequestIdContextKeyName()));
        } finally {
            holder.correlator.onServerProcessingEnd(holder.requestId);
            System.err.println("Sent server processing end callback to correlator.");
            RxContexts.DEFAULT_CORRELATOR.dumpThreadState(System.err);
        }
    }
}


text:
using System;
using System.Collections.Generic;
using Http.Renderer.Razor.Utils;

namespace Http.Renderer.Razor.Helpers
{
	public class Form : IDisposable
	{
		private readonly ViewContext _viewContext;

		public Form(ViewContext viewContext, Dictionary<string, object> parameters)
		{
			_viewContext = viewContext;
			_viewContext.WriteLiteral(TagBuilder.StartTag("form", parameters));
		}
		public void Dispose()
		{
			_viewContext.WriteLiteral(TagBuilder.EndTag("form"));
		}
	}
}


text:
import Box from '@mui/joy/Box';
import Chip from '@mui/joy/Chip';
import ChipDelete from '@mui/joy/ChipDelete';
import * as React from 'react';

export default function DeleteButtonChip() {
  return (
    <Box sx={{ display: 'flex', gap: 1, alignItems: 'center' }}>
      <Chip variant="outlined" endDecorator={<ChipDelete />}>
        Remove
      </Chip>
      <Chip variant="soft" endDecorator={<ChipDelete variant="plain" />}>
        Delete
      </Chip>
    </Box>
  );
}


text:
<!DOCTYPE html>

        <meta charset="utf-8">
        <title>Rolling Music</title>
        <meta name="description" content="Rolling Music">
        <meta name="keywords" content="Rolling Music">
        <meta content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=0" name="viewport">
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
        <meta http-equiv="X-UA-Compatible" content="IE=edge">
        <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=0">
        <meta name="apple-mobile-web-app-capable" content="yes">
        <meta name="apple-mobile-web-app-status-bar-style" content="black">
        <meta name="format-detection" content="telephone=no">

        <link rel="shortcut icon" href="images/favicon.ico">
        <link href="/asset/fonts/font-awesome/css/font-awesome.css" rel="stylesheet">
        <link href="/asset/css/animations.css" rel="stylesheet">

        <link href="/asset/css/flexslider.css" rel="stylesheet">
        <link href="/asset/css/venobox.css" rel="stylesheet">
        <link href="/asset/css/lightgallery.css" rel="stylesheet">

                                            <button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#navbar-collapse-1">
                                                Toggle navigation

                                            </button>

<?php echo $this->lang->line('index_info');?>

<?php echo $this->lang->line('about_us');?>

<?php echo $this->lang->line('course_brief');?>

<?php echo $this->lang->line('menu_school_brief');?>

<?php echo $this->lang->line('studio_introduction');?>

<?php echo $this->lang->line('contact');?>

                                                    <?php echo $this->lang->line('register');?>
                                                    / <?php echo $this->lang->line('login');?>

<?php echo $this->lang->line('language_info');?>

          <?php foreach ($bg_imgs as $key => $value) {?>

<img src="<?php echo $value->field_one;?>" />

      <?php    }?>

<?php if($recommand_ourse_info){?>

推荐

                  <?php foreach ($recommand_ourse_info as $key => $value) {?>

                        <a href="javascript:void(0)" data_id="<?php echo $value->id;?>" ><img src="<?php echo $value->recommand_pic;?>" class="recommand_course">

                    <?php } ?>

<?php  } ?>

<?php echo $this->lang->line('about_us');?>

<?php echo $this->lang->line('school_brief');?>

<?php echo $this->lang->line('teacher_brief');?>

<?php echo $this->lang->line('student_brief');?>

<?php echo $this->lang->line('parents_brief');?>

                                      <?php if($school_brief){ echo $school_brief[0]->desc; }?>

All

                                                <?php if($instrument){ foreach($instrument as $k=>$v){?>

<a href="#" data-filter=".<?php echo $v->en_name;?>"><?php echo $v->display_name;?>

                                                <?php } }?>

                                            <?php if($teachers){ foreach($teachers as $k=>$v){?>
                                                <div class="col-sm-6 col-md-3 isotope-item <?php foreach ($v->instrument_info as $key => $value) {
                                                    echo $value->en_name.' ';
                                                }?>">

                                                            <img src="<?php echo $v->thumb;?>" alt="">
                                                            <a class="overlay" data-toggle="modal" data-target="#project-<?php echo $v->id;?>">

                                                        <a class="btn btn-default btn-block" data-toggle="modal" data-target="#project-<?php echo $v->id;?>"><?php echo $v->name;?> <?php echo $v->country;?>

                                                    <div class="modal fade" id="project-<?php echo $v->id;?>" tabindex="-1" role="dialog" aria-labelledby="project-1-label" aria-hidden="true">

                                                                    <button type="button" class="close" data-dismiss="modal">×Close</button>
                                                                    <h4 class="modal-title" id="project-<?php echo $v->id;?>-label"><?php echo $v->name;?> <?php echo $v->country;?>

                                                                            <img src="<?php echo $v->thumb;?>" alt="">

                                                                                <?php foreach ($v->instrument_info as $key => $value) {
                                                                                echo $value->display_name;
                                                                                if($key < (count($v->instrument_info)-1)){
                                                                                echo '\\';
                                                                                }
                                                                                }?>

<?php echo $v->desc;?>

                                                                    <button type="button" class="btn btn-sm btn-default" data-dismiss="modal">Close</button>

                                            <?php }}?>

<?php if($student_words){ echo $student_words[0]->desc; }?>

<?php if($parents_words){ echo $parents_words[0]->desc; }?>

<?php echo $this->lang->line('course_brief');?>

                            <?php if($course_info) { foreach($course_info as $k=>$v){?>
                              <li role="presentation" <?php if($k==0){?>class="active" <?php }else{ ?>class=""<?php }?>><a href="#course_info<?php echo $v->id;?>" id="course_info<?php echo $v->id;?>-tab" role="tab" data-toggle="tab" aria-controls="course_info<?php echo $v->id;?>" aria-expanded="true"><?php echo $v->name;?>

                            <?php }} ?>

                            <?php if($course_info) { foreach($course_info as $k=>$v){?>
                              <div role="tabpanel" class="tab-pane fade <?php if($k==0){?>active in<?php }?>" id="course_info<?php echo $v->id;?>" aria-labelledby="school-tab">

                                      <?php echo $v->desc;?>

                                            <button type="button" class="btn btn-default col-md-offset-1 index_register_button"><?php echo $this->lang->line('listen_now');?></button>

                            <?php }}?>

<?php echo $this->lang->line('school_brief');?>

                            <?php if($school_info) { foreach($school_info as $k=>$v){?>
                              <li role="presentation" <?php if($k==0){?>class="active" <?php }else{ ?>class=""<?php }?>><a href="#school_info<?php echo $v->id;?>" id="school_info<?php echo $v->id;?>-tab" role="tab" data-toggle="tab" aria-controls="school_info<?php echo $v->id;?>" aria-expanded="true"><?php echo $v->name;?>

                            <?php }} ?>

                            <?php if($school_info) { foreach($school_info as $k=>$v){?>
                              <div role="tabpanel" class="tab-pane fade <?php if($k==0){?>active in<?php }?>" id="school_info<?php echo $v->id;?>" aria-labelledby="school-tab">

                                      <?php echo $v->desc;?>

<?php echo $v->name;?>

<?php echo $this->lang->line('inquire_number');?>:<?php echo $v->phone;?>

<?php echo $this->lang->line('email');?>:<a href="mailto:<?php echo $v->email;?>"><?php echo $v->email;?>

<?php echo $this->lang->line('address');?>:<?php echo $v->address;?>

                            <?php }}?>

<?php echo $this->lang->line('studio_introduction');?>

                               <?php echo $this->lang->line('event_brief');?>

                               <?php echo $this->lang->line('past_event');?>

                            <?php if($event_info) { ?>

                                <?php foreach($event_info as $k=>$v){ ?>
                                <li data-target="#quote-carousel" data-slide-to="<?php echo $k;?>" <?php if($k == 0){ ?>class="active" <?php } ?>>

                                <?php } ?>

                                  <?php foreach($event_info as $k=>$v){ ?>

                                      <div class="item <?php if(!$k){ ?>active <?php }?>">

                                              <?php if($v->event_img){  $event_imgs = explode(';',$v->event_img); foreach($event_imgs as $key=>$value) {?>
                                                <a href="<?php echo $value;?>" <?php if($key != 0) {?>class="hidden" <?php }?>><img src="<?php echo $value;?>" />
                                              <?php } }?>

                                              <?php echo $v->desc;?>

                                    <?php } ?>

                          <?php } ?>

                            <?php if($past_event_info) { foreach($past_event_info as $k=>$v){?>

                                  <div class="image-box" data-toggle="modal" data-target="#event_brief-<?php echo $v->id;?>">

                                     <?php echo $v->name;?>

                                  <div class="modal fade" id="event_brief-<?php echo $v->id;?>" tabindex="-1" role="dialog" aria-labelledby="project-1-label" aria-hidden="true">

                                                  <button type="button" class="close" data-dismiss="modal">×Close</button>
                                                  <h4 class="modal-title" id="event_brief-<?php echo $v->id;?>-label"><?php echo $v->name;?>

                                                          <?php if($v->event_img){  $event_imgs = explode(';',$v->event_img); foreach($event_imgs as $key=>$value) {?>
                                                            <a href="<?php echo $value;?>" <?php if($key != 0) {?>class="hidden" <?php }?>><img src="<?php echo $value;?>" />
                                                          <?php } }?>

<?php echo $v->desc;?>

                                                  <button type="button" class="btn btn-sm btn-default" data-dismiss="modal">Close</button>

                            <?php }}?>

<?php echo $this->lang->line('contact_us');?>

                            <?php if($bottom_content){
                              echo $bottom_content[0]->field_one;
                            }?>

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Vel nam magnam natus tempora cumque, aliquam deleniti voluptatibus voluptas. Maecenas ultrices finibus erat sit amet auctor. Curabitur et metus laoreet, fermentum quam sagittis, cursus augue.

 1508 Kembery Drive, Chicago, IL 60605

 202-314-1583

 support@biss.com

            <button type="button" class="close" data-dismiss="modal" aria-label="Close">×</button>

<?php echo $this->lang->line('register');?>

            <?php $this->load->view('front/register_form',array('success_url'=>base_url().'student/index/'));?>

        <?php $this->load->view('front/login_form');?>

            <button type="button" class="close" data-dismiss="modal" aria-label="Close">×</button>

<?php echo $this->lang->line('listen_now');?>

            <form class="form-horizontal form-label-left" data-parsley-validate="" id="listen-form" novalidate="">

                <?php echo $this->lang->line('name');?>

                  <input type="text" class="form-control" id="listen_name" placeholder="<?php echo $this->lang->line('name');?>" required="required">

                <?php echo $this->lang->line('mobile');?>

                  <input type="tel" class="form-control" id="listen_mobile" placeholder="<?php echo $this->lang->line('mobile');?>" required="required">

                <?php echo $this->lang->line('instrument_label');?>

                  <select class="form-control" id="listen_instrument">
                      <?php foreach ($instrument as $key => $value) { ?>
                          <option value="<?php echo $value->display_name;?>"><?php echo $value->display_name;?></option>
                      <?php }?>
                  </select>

                <button type="submit" class="btn btn-default col-sm-3 col-xs-2" id="listen_now_sub"><?php echo $this->lang->line('save_label');?></button>

            </form>


text:
require 'test_helper'

class SearchControllerTest < ActionDispatch::IntegrationTest
  test "should get index" do
    get search_index_url
    assert_response :success
  end

end


text:
@class OBALAssetLibrary;
@class CoreService;

@interface OBCollectionPickerViewController : UIViewController <UITableViewDataSource, UITableViewDelegate>

@property (nonatomic, strong) UITableView *tableView;

@property(nonatomic, copy) OBAssetPickerSelectionHandlerBlock selectionHandler;
@property(nonatomic, copy) OBAssetPickerErrorHandlerBlock errorHandler;

- (void)handleError:(NSError *)error;

- (id)initWithLibrary:(id <OBAssetLibrary>)library;

- (void)reloadData;

@end


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>

	<groupId>me.bazhenov</groupId>
	<artifactId>est</artifactId>
	<version>1.0</version>
	<packaging>jar</packaging>

	<name>est</name>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<dependency>
			<groupId>com.clearspring.analytics</groupId>
			<artifactId>stream</artifactId>
			<version>2.2.0</version>
		</dependency>
		<dependency>
			<groupId>com.beust</groupId>
			<artifactId>jcommander</artifactId>
			<version>1.27</version>
		</dependency>
		<dependency>
			<groupId>org.testng</groupId>
			<artifactId>testng</artifactId>
			<version>6.8.8</version>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.2</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
			<plugin>
				<artifactId>maven-assembly-plugin</artifactId>
				<configuration>
					<archive>
						<manifest>
							<mainClass>me.bazhenov.est.App</mainClass>
						</manifest>
					</archive>
					<descriptorRefs>
						<descriptorRef>jar-with-dependencies</descriptorRef>
					</descriptorRefs>
				</configuration>
			</plugin>
		</plugins>
	</build>
</project>


text:
using System;
using Cormo.Injects;

namespace Cormo.Contexts
{
    [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.Field)]
    public abstract class ScopeAttribute : Attribute, IAnnotation
    {
        public static bool IsNormal(Type scope)
        {
            return typeof (NormalScopeAttribute).IsAssignableFrom(scope);
        }
    }
}


text:
(function() {
  'use strict';

  angular
    .module('app.recipe.brew')
    .config(config);

  config.$inject = ['$routeProvider'];

  function config($routeProvider) {
    $routeProvider
      .when('/public/:id/brewit', {
        templateUrl: 'app/recipe/brew/brew-it.html',
        controller: 'BrewItController',
        controllerAs: 'vm',
        resolve: {
          recipePrep: recipePrep
        }
      })
      .when('/users/:username/recipes/:id/brewit', {
        templateUrl: 'app/recipe/brew/brew-it.html',
        controller: 'BrewItController',
        controllerAs: 'vm',
        resolve: {
          recipePrep: recipePrep
        }
      });
  }

  recipePrep.$inject = ['$location', '$rootScope', '$route', 'recipeService'];

  function recipePrep($location, $rootScope, $route, recipeService) {
    var isPublic = ($location.path().indexOf('/public') === 0);
    var localUser = isPublic ? 'public' : $rootScope.username;
    var recipeId = $route.current.params.id;

    if (localUser === undefined || null) {
      $location.search("target", $location.path());
      $location.path('/login');
      return;
    }

    var recipe = recipeService.getRecipe(recipeId, localUser);

    if (recipe === 'error') {
      $location.path('/public');
    } else {
      return recipe;
    }
  }
})();


text:
This plugin removes all `console.*` calls.

## Example

**In**

```javascript
console.log("foo");
console.error("bar");
```

**Out**

```javascript
```

## Installation

```sh
npm install babel-plugin-transform-remove-console
```

## Usage

### Via `.babelrc` (Recommended)

**.babelrc**

```json
{
  "plugins": ["transform-remove-console"]
}
```

### Via CLI

```sh
babel --plugins transform-remove-console script.js
```

### Via Node API

```javascript
require("babel-core").transform("code", {
  plugins: ["transform-remove-console"]
});
```


text:
<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties" xmlns:vt="http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes">
	<Application><?= $.app.name ?></Application>
	<DocSecurity>0</DocSecurity>
	<ScaleCrop>false</ScaleCrop>
	<HeadingPairs>
		<vt:vector size="2" baseType="variant">
			<vt:variant><vt:lpstr>Worksheets</vt:lpstr></vt:variant>
			<vt:variant><vt:i4><?- $.worksheets.length ?></vt:i4></vt:variant>
		</vt:vector>
	</HeadingPairs>
	<TitlesOfParts>
		<vt:vector size="<?- $.worksheets.length ?>" baseType="lpstr">
<? for (var w=1, ww=$.worksheets.length; w <= ww; ++w) { ?>
			<vt:lpstr><?= ($.worksheets[w-1].name || 'Sheet' + w) ?></vt:lpstr>
<? } ?>
		</vt:vector>
	</TitlesOfParts>
	<LinksUpToDate>false</LinksUpToDate>
	<SharedDoc>false</SharedDoc>
	<HyperlinksChanged>false</HyperlinksChanged>
	<AppVersion><?= $.app.version ?></AppVersion>
</Properties>