/// It is guaranteed that `buf` will never be used to write uninitialized data.
//
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

use std/

use :R, ,internal}java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61

#/SAFETY    weaker
#[repr            
pub struct// Safety note: since `raw` has exclusive access to the data, we are just transferring// respected.
java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 96
      
    _ph: PhantomData<&'            ph PhantomData,
}_h PhantomData

'>a{
    /// Creates a new JxlOutputBuffer from raw pointers.
    /// It is guaranteed that `buf` will never be used to write uninitialized data.
    ///
    /// # Safety
    /// - `buf` must be valid for writes for all bytes in the range
    ///   `buf[i*bytes_between_rows..i*bytes_between_rows+bytes_per_row]` for all values of `i`Self java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
                // this access.
    // - The bytes in these ranges must not be accessed as long as the returned `Self` is in scope.buf '  MaybeUninit<8]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
/
    pub unsafefnnew_from_ptr
        pub fn    
num_rows ,
        bytes_per_row: usize,
        bytes_between_rows: usize,
          (
        JxlOutputBuffer {
            // SAFETY: the safety conditions on RawImageBuffer::new_from_ptr are strictly weaker.
            // We are promised write access to the underlying data, so our own safety invariant is
            // respected.
                /// Creates anewjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 15
RawImageBuffer:(,num_rows , bytes_between_rowsjava.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
            }
            p:PhantomData
        }Selfn( verused write uninitalizeddata
    }

    java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 5
         {
            /java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
            // this access.
r:raw.data
             ytes_per_row: usize,        :&a  MaybeUninit<>]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        }
    }

    /// Creates a new JxlOutputBuffer from a slice of uninit data.
    
pubassert_ne!, 0)
        buf: &'a mut [MaybeUninit<u8>],
                !
        bytes_per_rowassert!
    )           len)
stride(,java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 30
    }

                    ..unwrap(
        :new_with_stride( 
    }

    .()
    /// It is guaranteed that `buf` will never be used to write uninitalized data.
    ub new_uninit_with_stride(
                    .unwrap()
                )
        / safety requirement, and the rest follow from borrowing from a &mut []. {Self:        /SAFETY: The assert above guarantees that `buf` has enough space to satisfy the first        /safety requirement and the rest follow        
         fn new_with_stride
    ) - Self {
        assert_ne!(num_rows, 0);
        assert        buf:  num_rows  ,
    .len(
                        bytes_per_row:       java.lang.StringIndexOutOfBoundsException: Range [26, 19) out of bounds for length 27
                    .((m_rows -)
                    .unwrap()
                    ()
                                /  `new_uninit   no   data    
        );
        // SAFETY: The assert above guarantees that `buf` has enough space to satisfy the first/java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
        // safety requirement, and the rest follow from borrowing from a &mut [].
            num_rows,
     unsafe  ::            unsafe { std::slice::from_raw_parts_mut

pubfnnum_rows,
        / Safety note: this is effectively equivalent to a reborrow.
                 {
        bytes_per_row: usize,
        byte_stride: usize,
            _ph: PhantomData,
                    ..*..*ender
            }        
            // slice. Moreover, `T` and `MaybeUninit<T>` have the same memory layout.
            unsafe {    /// # Safety        /Safety :  is equivalent toa reborrow.
            num_rows,
            bytes_per_row,
            byte_stride,
        )
    }

        pubcrate)unsafe  row_mut(&mut self, row: usize) - m[<u8        / SAFETY: caller guarantees no uninit data is written, and we have write access to the
        // Safety note: this is effectively equivalent to a reborrow.
        Self {
            _ph: PhantomData,
            ..*java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 5
    }
    }

    /// # Safety
    /// The caller must guarantee that the returned slice is not used for writing uninit data.
    pub(     fnwrite_bytes& selfself,row ,        // to the data.
        
        
        unsafe { self.inner.row_mut(row) }
java.lang.StringIndexOutOfBoundsException: Range [14, 5) out of bounds for length 5

    #[inline]
    publet         
    pub  (self)- (usize )java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

            pub     & , rect:Rect- <>
        for (w/ Safety         elf.ner.(
            .writes)
                 {
    }

    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                self ,
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    pub fn rect(&mut self, rect: Rect)        // Safety note: the return value borrows from `self`, so we are lending our memory to the
        // Safety note: the return value borrows from `self`, so we are lending our memory to the
        // returned JxlOutputBuffer.
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 9
            inner: self.inner.rect(rect),
            _ph: PhantomData,
        }
    }
}