crate | distributed SQL database

by crate Java Version: 4.7.1 License: Apache-2.0

Download this library from

kandi X-RAY | crate Summary

crate is a Java library typically used in Big Data, Hadoop applications. crate has no bugs, it has no vulnerabilities, it has build file available, it has a Permissive License and it has high support. You can download it from GitHub.

CrateDB is a distributed SQL database that makes it simple to store and analyze massive amounts of machine data in real-time.

Support

Quality

Security

License

Reuse

kandi-support Support

crate has a highly active ecosystem.
It has 3343 star(s) with 489 fork(s). There are 170 watchers for this library.
There were 2 major release(s) in the last 6 months.
There are 212 open issues and 1190 have been closed. On average issues are closed in 96 days. There are 24 open pull requests and 0 closed requests.
It has a positive sentiment in the developer community.
The latest version of crate is 4.7.1

crate Support

Best in #Java

Average in #Java

crate Support

Best in #Java

Average in #Java

quality kandi Quality

crate has 0 bugs and 0 code smells.

crate Quality

Best in #Java

Average in #Java

crate Quality

Best in #Java

Average in #Java

security Security

crate has no vulnerabilities reported, and its dependent libraries have no vulnerabilities reported.
crate code analysis shows 0 unresolved vulnerabilities.
There are 0 security hotspots that need review.

crate Security

Best in #Java

Average in #Java

crate Security

Best in #Java

Average in #Java

license License

crate is licensed under the Apache-2.0 License. This license is Permissive.
Permissive licenses have the least restrictions, and you can use them in most projects.

crate License

Best in #Java

Average in #Java

crate License

Best in #Java

Average in #Java

build Reuse

crate releases are available to install and integrate.
Build file is available. You can build the component from source.
crate saves you 1004263 person hours of effort in developing the same functionality from scratch.
It has 492615 lines of code, 42009 functions and 4751 files.
It has medium code complexity. Code complexity directly impacts maintainability of the code.

crate Reuse

Best in #Java

Average in #Java

crate Reuse

Best in #Java

Average in #Java

Top functions reviewed by kandi - BETA

kandi has reviewed crate and discovered the below as its top functions. This is intended to give you an instant insight into crate implemented functionality, and help decide if they suit your requirements.

Restores a snapshot from a repository .
Perform recovery operation .
Factory method to create a DateTimeFormatter for a given string .
Performs recovery .
Snap a shard .
Sets the new routing entry .
Convert a token to a string element .
Converts a glob pattern into a regular expression
Create a plan for a copy - from operation .
Starts a snapshot .

crate Key Features

CrateDB is a distributed SQL database that makes it simple to store and analyze massive amounts of machine data in real-time.

crate Examples and Code Snippets

See all related Code Snippets

Different behavior between match and unwrap

Copy

Download

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

-----------------------

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

let (_, handle) = OutputStream::try_default().unwrap();

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

let (_stream, handle) = OutputStream::try_default().unwrap();

let _ = m.lock().unwrap();

let _lock = m.lock().unwrap():

let lock = m.lock().unwrap();
...
drop(lock);

Specialising Range or overloading ".."

Copy

Download

use std::ops::{Index, IndexMut, Range, Deref, DerefMut};

#[repr(transparent)] // Because of this we can soundly cast `&{mut }[T]` to `&{mut }MySlice<T>`.
pub struct MySlice<T>([T]);

impl<'a, T> From<&'a [T]> for &'a MySlice<T> {
    fn from(v: &'a [T]) -> &'a MySlice<T> {
        unsafe { &*(v as *const [T] as *const MySlice<T>) }
    }
}
impl<'a, T> From<&'a mut [T]> for &'a mut MySlice<T> {
    fn from(v: &'a mut [T]) -> &'a mut MySlice<T> {
        unsafe { &mut *(v as *mut [T] as *mut MySlice<T>) }
    }
}

impl<T> Index<usize> for MySlice<T> {
    type Output = T;
    fn index(&self, idx: usize) -> &Self::Output { &self.0[idx] }
}
impl<T> IndexMut<usize> for MySlice<T> {
    fn index_mut(&mut self, idx: usize) -> &mut Self::Output { &mut self.0[idx] }
}

impl<T> Index<Range<usize>> for MySlice<T> {
    type Output = MySlice<T>;
    fn index(&self, idx: Range<usize>) -> &Self::Output { self.0[idx].into() }
}
impl<T> IndexMut<Range<usize>> for MySlice<T> {
    fn index_mut(&mut self, idx: Range<usize>) -> &mut Self::Output { (&mut self.0[idx]).into() }
}
// And so on, for all range types...

pub struct MyVec<T>(pub Vec<T>);

impl<T> Deref for MyVec<T> {
    type Target = MySlice<T>;
    fn deref(&self) -> &Self::Target { self.0.as_slice().into() }
}
impl<T> DerefMut for MyVec<T> {
    fn deref_mut(&mut self) -> &mut Self::Target { self.0.as_mut_slice().into() }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

-----------------------

// A dummy type to illustrate the types I want to work with
// Different TypeInfo will give me different and incompatible
// types that wrap integers, which is what I want.
trait TypeInfo {
    type WrappedType: num::PrimInt;
}

// A wrapper wraps the type from the TypeInfo trait;
// the TypeInfo trait specifies the type when I define what
// operations I will allow.
#[derive(Debug, Clone, Copy)]
struct Wrapper<T: TypeInfo>(T::WrappedType);

// Trait that determines which sequences an index can index
trait CanIndex<Seq: ?Sized> {}

// For indexing... (You get too deeply nested genetics without it)
// Maybe I can get rid of it, but that is for another day...
pub trait IndexType {
    fn as_index(&self) -> usize;
}
impl<TI> IndexType for Wrapper<TI>
where
    TI: TypeInfo<WrappedType = usize>,
{
    fn as_index(&self) -> usize {
        self.0
    }
}

// Generic index implementation. (The real situation is a bit more
// complicated because I need to specify which types each index type
// is allowed to index, but this is the gist of it)

// Indexing a single element in a vector
impl<TI, T> std::ops::Index<Wrapper<TI>> for Vec<T>
where
    TI: TypeInfo,
    TI: CanIndex<Vec<T>>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// Indexing a single element in a slice
impl<TI, T> std::ops::Index<Wrapper<TI>> for [T]
where
    TI: TypeInfo,
    TI: CanIndex<[T]>,
    Wrapper<TI>: IndexType,
{
    type Output = T;
    fn index(&self, i: Wrapper<TI>) -> &Self::Output {
        &self[i.as_index()]
    }
}

// My own type of ranges, now that I cannot use the built-in type...
/// Wrapper of Range that we can work with within Rust's type system
#[derive(Clone, Copy)]
pub enum Range<Idx> {
    Closed(Idx, Idx), // start..end
    Left(Idx),        // start..
    Right(Idx),       // ..end
    Full,             // ..
}

pub trait GenRange<R, Idx> {
    fn range(r: R) -> Range<Idx>;
}
/*

 Now implement that trait for the different range types.
 Is there a better way?

 */

// Now I can build ranges with this function:
pub fn range<Idx, R: GenRange<R, Idx>>(r: R) -> Range<Idx> {
    R::range(r)
}

impl<Idx, T> std::ops::Index<Range<Idx>> for Vec<T>
where
    Idx: IndexType,
    Idx: CanIndex<Vec<T>>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

impl<Idx, T> std::ops::Index<Range<Idx>> for [T]
where
    Idx: IndexType,
    Idx: CanIndex<[T]>,
{
    type Output = [T];
    fn index(&self, r: Range<Idx>) -> &Self::Output {
        match r {
            Range::Closed(start, end) => &self[start.as_index()..end.as_index()],
            Range::Left(start) => &self[start.as_index()..],
            Range::Right(end) => &self[..end.as_index()],
            Range::Full => &self[..],
        }
    }
}

How to import a function in main.rs

Copy

Download

crate::another_func_in_main();

use crate::another_func_in_main;

// Then in code, no need for a prefix:
another_func_in_main();

-----------------------

crate::another_func_in_main();

use crate::another_func_in_main;

// Then in code, no need for a prefix:
another_func_in_main();

How to return JSON as a response in Rust Rocket with auto field deserialising?

Copy

Download

use rocket::serde::json::Json;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
pub struct Printers {
    pub printers: Vec<Printer>,
}

#[derive(Serialize, Deserialize)]
pub struct Printer {
    pub device_type: String,
    pub uid: String,
    pub provider: String,
    pub name: String,
    pub connection: String,
    pub version: u8,
    pub manufacturer: String,
}

#[get("/printers")]
fn printers() -> Json<Printers> {
    todo!();
}

-----------------------

[dependencies]
## SEE HERE!! 
rocket = {version ="0.5.0-rc.1", features=["json"]}

# other properties omitted for brevity 

# You can remove this!! Rocket Contrib doesn't exist in Rocket V0.5 
#[dependencies.rocket_contrib]
#version = "0.4.10"
#default-features = false
#features = ["json"]

-----------------------

[package]
#...

[dependencies.rocket]
version = "0.5.0-rc.1"
features = ["json"]

[dependencies.serde]
version = "1.0.136"
features = ["derive"]

[dependencies]
#...

# rocket_contrib not required anymore

// rocket v0.5.0-rc.1
use rocket::{
   self,
   serde::{json::Json, Deserialize, Serialize},
};

#[derive(Deserialize, Serialize)]
struct User {
   name: String,
   age: u8,
}

#[rocket::post("/post", format = "json", data = "<user>")]
fn post_data(user: Json<User>) -> Json<User> {
   let name: String = user.name.clone();
   let age: u8 = user.age.clone();

   Json(User { name, age })
}

#[rocket::main]
async fn main() {
   if let Err(err) = rocket::build()
      .mount("/", rocket::routes![post_data])
      .launch()
      .await
   {
      println!("Rocket Rust couldn't take off successfully!");
      drop(err); // Drop initiates Rocket-formatted panic
   }
}

curl -d '{"age": 12,"name":"John Doe"}' -H 'Content-Type: application/json' 
http://localhost:8000/post

# Response
# {"name":"John Doe","age":12}

-----------------------

[package]
#...

[dependencies.rocket]
version = "0.5.0-rc.1"
features = ["json"]

[dependencies.serde]
version = "1.0.136"
features = ["derive"]

[dependencies]
#...

# rocket_contrib not required anymore

// rocket v0.5.0-rc.1
use rocket::{
   self,
   serde::{json::Json, Deserialize, Serialize},
};

#[derive(Deserialize, Serialize)]
struct User {
   name: String,
   age: u8,
}

#[rocket::post("/post", format = "json", data = "<user>")]
fn post_data(user: Json<User>) -> Json<User> {
   let name: String = user.name.clone();
   let age: u8 = user.age.clone();

   Json(User { name, age })
}

#[rocket::main]
async fn main() {
   if let Err(err) = rocket::build()
      .mount("/", rocket::routes![post_data])
      .launch()
      .await
   {
      println!("Rocket Rust couldn't take off successfully!");
      drop(err); // Drop initiates Rocket-formatted panic
   }
}

curl -d '{"age": 12,"name":"John Doe"}' -H 'Content-Type: application/json' 
http://localhost:8000/post

# Response
# {"name":"John Doe","age":12}

-----------------------

[package]
#...

[dependencies.rocket]
version = "0.5.0-rc.1"
features = ["json"]

[dependencies.serde]
version = "1.0.136"
features = ["derive"]

[dependencies]
#...

# rocket_contrib not required anymore

// rocket v0.5.0-rc.1
use rocket::{
   self,
   serde::{json::Json, Deserialize, Serialize},
};

#[derive(Deserialize, Serialize)]
struct User {
   name: String,
   age: u8,
}

#[rocket::post("/post", format = "json", data = "<user>")]
fn post_data(user: Json<User>) -> Json<User> {
   let name: String = user.name.clone();
   let age: u8 = user.age.clone();

   Json(User { name, age })
}

#[rocket::main]
async fn main() {
   if let Err(err) = rocket::build()
      .mount("/", rocket::routes![post_data])
      .launch()
      .await
   {
      println!("Rocket Rust couldn't take off successfully!");
      drop(err); // Drop initiates Rocket-formatted panic
   }
}

curl -d '{"age": 12,"name":"John Doe"}' -H 'Content-Type: application/json' 
http://localhost:8000/post

# Response
# {"name":"John Doe","age":12}

How to get UniquePtr<EnumMember> on the Rust side? (CXX crate)

Copy

Download

impl UniquePtr<SizeType> {}

WASM from Rust not returning the expected types

Copy

Download

#[no_mangle]
pub extern "C" fn say(output: &mut (*const u8, i32)) {
    let pointcut = "Hello World";

    output.1 = 11;
    output.0 = pointcut.as_ptr();
}

Struct padding rules in Rust

Copy

Download

struct ACG1 {
    upper: u32,
    time1: u16,
    time2: u16,
    lower: u16,
}

-----------------------

cargo clean
cargo rustc -- -Zprint-type-sizes

...
print-type-size type: `ACG1`: 12 bytes, alignment: 4 bytes
print-type-size     field `.upper`: 4 bytes
print-type-size     field `.time1`: 2 bytes
print-type-size     field `.time2`: 2 bytes
print-type-size     field `.lower`: 2 bytes
print-type-size     end padding: 2 bytes
print-type-size type: `ACG2`: 12 bytes, alignment: 4 bytes
print-type-size     field `.time1`: 2 bytes
print-type-size     field `.time2`: 2 bytes
print-type-size     field `.upper`: 4 bytes
print-type-size     field `.lower`: 2 bytes
print-type-size     end padding: 2 bytes

-----------------------

cargo clean
cargo rustc -- -Zprint-type-sizes

...
print-type-size type: `ACG1`: 12 bytes, alignment: 4 bytes
print-type-size     field `.upper`: 4 bytes
print-type-size     field `.time1`: 2 bytes
print-type-size     field `.time2`: 2 bytes
print-type-size     field `.lower`: 2 bytes
print-type-size     end padding: 2 bytes
print-type-size type: `ACG2`: 12 bytes, alignment: 4 bytes
print-type-size     field `.time1`: 2 bytes
print-type-size     field `.time2`: 2 bytes
print-type-size     field `.upper`: 4 bytes
print-type-size     field `.lower`: 2 bytes
print-type-size     end padding: 2 bytes

What is "<[_]>" in Rust?

Copy

Download

pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
    // ...
}

Should I take `self` by value or mutable reference when using the Builder pattern?

Copy

Download

pub struct Builder {
    name: Option<String>,
    stack_size: Option<usize>,
}

pub struct Command {
    program: CString,
    args: Vec<CString>,
    env: CommandEnv,
    stdin: Option<Stdio>,
    stdout: Option<Stdio>,
    stderr: Option<Stdio>,
    // ...
}

pub struct OpenOptions {
    read: bool,
    write: bool,
    append: bool,
    truncate: bool,
    create: bool,
    create_new: bool,
    // ...
}

-----------------------

pub struct Builder {
    name: Option<String>,
    stack_size: Option<usize>,
}

pub struct Command {
    program: CString,
    args: Vec<CString>,
    env: CommandEnv,
    stdin: Option<Stdio>,
    stdout: Option<Stdio>,
    stderr: Option<Stdio>,
    // ...
}

pub struct OpenOptions {
    read: bool,
    write: bool,
    append: bool,
    truncate: bool,
    create: bool,
    create_new: bool,
    // ...
}

-----------------------

pub struct Builder {
    name: Option<String>,
    stack_size: Option<usize>,
}

pub struct Command {
    program: CString,
    args: Vec<CString>,
    env: CommandEnv,
    stdin: Option<Stdio>,
    stdout: Option<Stdio>,
    stderr: Option<Stdio>,
    // ...
}

pub struct OpenOptions {
    read: bool,
    write: bool,
    append: bool,
    truncate: bool,
    create: bool,
    create_new: bool,
    // ...
}

How do I statically link a Haskell library with a Rust project?

Copy

Download

ghc -c -staticlib Lib.hs cwrapper.c -o libtesths.a

extern "C" {
    pub fn addTwo(x: i32) -> i32;
    pub fn init();
    pub fn fin();
}

fn main() {
    unsafe {
        init();
        println!("{}", addTwo(40));
        fin();
    }
}

% cargo run -q
42

-----------------------

ghc -c -staticlib Lib.hs cwrapper.c -o libtesths.a

extern "C" {
    pub fn addTwo(x: i32) -> i32;
    pub fn init();
    pub fn fin();
}

fn main() {
    unsafe {
        init();
        println!("{}", addTwo(40));
        fin();
    }
}

% cargo run -q
42

-----------------------

ghc -c -staticlib Lib.hs cwrapper.c -o libtesths.a

extern "C" {
    pub fn addTwo(x: i32) -> i32;
    pub fn init();
    pub fn fin();
}

fn main() {
    unsafe {
        init();
        println!("{}", addTwo(40));
        fin();
    }
}

% cargo run -q
42

See all related Code Snippets

Community Discussions

Trending Discussions on crate

Different behavior between match and unwrap
What is the built-in `#[main]` attribute?
Specialising Range or overloading ".."
How to import a function in main.rs
How to return JSON as a response in Rust Rocket with auto field deserialising?
How to get UniquePtr<EnumMember> on the Rust side? (CXX crate)
WASM from Rust not returning the expected types
Struct padding rules in Rust
What is "<[_]>" in Rust?
Should I take `self` by value or mutable reference when using the Builder pattern?

Trending Discussions on crate

QUESTION

Different behavior between match and unwrap

Asked 2022-Mar-15 at 18:39

I have done a small program, and it shows a weird behavior that I cannot explain. I am using rodio crate to try out some audio stuff.

I have done two programs that, in my opinion, should give the same result.

The first one I use matches to handle errors:

let sink : Option<Sink> = match rodio::OutputStream::try_default() {
        Ok((_, handle)) => {
            match Sink::try_new(&handle) {
                Ok(s) => Some(s),
                Err(_e) => None,
            }
        },
        Err(_e) => None,
};
println!("{}", sink.unwrap().len());

In the last one, I have used unwrap instead.

let (_, handle) = rodio::OutputStream::try_default().unwrap();
let s = Sink::try_new(&handle).unwrap();
println!("{}",s.len());

The first one executes the print statement as expected, while the last one panics in the second unwrap.

It is very strange to me as soon as there is no error propagation, implicit conversions or other things that can explain that. The problem here is not related to the error itself but the difference between the two codes.

ANSWER

Answered 2021-Sep-30 at 19:08

The issue is one of scoping and an implementation detail of rodio: the one critical item here is OutputStream::try_default(), it doesn't really matter how you handle Sink::try_new(&handle) it'll always behave the same, not so try_default, if you match or if let it it'll work fine, if you unwrap it it'll fail.

But why would that be, the two should be equivalent. The answer is in the details of rodio, specifically of OutputStreamHandle:

pub struct OutputStreamHandle {
    mixer: Weak<DynamicMixerController<f32>>,
}

So an OutputStreamHandle (OSH thereafter) only holds a weakref to a DynamicMixerController, to which the OutputStream (OS thereafter) holds a strong reference.

This means the OSH only "works" as long as the OS is alive.

let (_, handle) = OutputStream::try_default().unwrap();

does not name the OS, so doesn't hold onto it, it's immediately dropped, the Arc is released and the OSH holds onto nothing, and the sink is unhappy.

How can the other one work then? Because

    if let Ok((_, handle)) = OutputStream::try_default() {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }

is really rather

{
    let _var = OutputStream::try_default();
    if let Ok((_, handle)) = _var {
        let sink = Sink::try_new(&handle).unwrap();
        println!("match {}", sink.len());
    }
}

so the match/if let itself is keeping the Result alive, which is a blessing here (but causes issues just the next question over).

Since the Result is kept alive, the tuple is kept alive, the OutputStream is kept alive, the Arc is kept alive, and thus the OSH has a working mixer, which the sink can make use of.

You can fix the issue of the second version by binding the OutputStream to a "proper" name e.g.

let (_stream, handle) = OutputStream::try_default().unwrap();

prefixing a name with _ will create the binding for real, but will suppress the "unused variable" warning.

FWIW being careful around this sort of things is incredibly important around RAII types whose values you "don't need", most commonly mutexes protecting code as opposed to data:

let _ = m.lock().unwrap();

doesn't do anything, the mutex guard is not kept alive, so the lock is immediately released. In that case, you'd rather

let _lock = m.lock().unwrap():

or even better

let lock = m.lock().unwrap();
...
drop(lock);

Source https://stackoverflow.com/questions/69393226

QUESTION

What is the built-in `#[main]` attribute?

Asked 2022-Feb-15 at 23:57

I have been using the #[tokio::main] macro in one of my programs. After importing main and using it unqualified, I encountered an unexpected error.

use tokio::main;

#[main]
async fn main() {}

error[E0659]: `main` is ambiguous
 --> src/main.rs:3:3
  |
3 | #[main]
  |   ^^^^ ambiguous name
  |
  = note: ambiguous because of a name conflict with a builtin attribute
  = note: `main` could refer to a built-in attribute

I've been scouring the documentation but I haven't been able to find this built-in #[main] attribute described anywhere. The Rust Reference contains an index of built-in attributes. The index doesn't include #[main], though it does include an attribute named #[no_main].

I did a search of the rustlang/rust repository, and found some code that seems related, but it seems to use a pair of macros named #[start] and #[rustc_main], with no mention of #[main] itself. (Neither of those macros appears to be usable on stable, with #[start] emitting an error that it's unstable, and #[rustc_main] emitting an error that it's only meant for internal use by the compiler.)

My guess from the name would have been that it's meant to mark a different function as an entry-point instead of main, but it also doesn't seem to do that:

#[main]
fn something_else() {
    println!("this does not run");
}

fn main() {
    println!("this runs");
}

Rust Analyzer didn't have much to offer:

What does the built-in #[main] attribute do, aside from conflicting with my imports? 😉

ANSWER

Answered 2022-Feb-15 at 23:57

#[main] is an old, unstable attribute that was mostly removed from the language in 1.53.0. However, the removal missed one line, with the result you see: the attribute had no effect, but it could be used on stable Rust without an error, and conflicted with imported attributes named main. This was a bug, not intended behaviour. It has been fixed as of nightly-2022-02-10 and 1.59.0-beta.8. Your example with use tokio::main; and #[main] can now run without error.

Before it was removed, the unstable #[main] was used to specify the entry point of a program. Alex Crichton described the behaviour of it and related attributes in a 2016 comment on GitHub:

Ah yes, we've got three entry points. I.. think this is how they work:

First, #[start], the receiver of int argc and char **argv. This is literally the symbol main (or what is called by that symbol generated in the compiler).

Next, there's #[lang = "start"]. If no #[start] exists in the crate graph then the compiler generates a main function that calls this. This functions receives argc/argv along with a third argument that is a function pointer to the #[main] function (defined below). Importantly, #[lang = "start"] can be located in a library. For example it's located in the standard library (libstd).

Finally, #[main], the main function for an executable. This is passed no arguments and is called by #[lang = "start"] (if it decides to). The standard library uses this to initialize itself and then call the Rust program. This, if not specified, defaults to fn main at the top.

So to answer your question, this isn't the same as #[start]. To answer your other (possibly not yet asked) question, yes we have too many entry points.

Source https://stackoverflow.com/questions/71024443

QUESTION

Specialising Range or overloading ".."

Asked 2022-Feb-10 at 05:54

I have a little library where I can define integer types. These are intended for type-safe indexing into arrays and strings in the kind of algorithms I often write. For example, I can use it to define an offset type, Offset and an index type, Idx such that you can get an Offset by subtracting two Idx, you can get Idx by adding or subtracting Offset, but you cannot for example multiple or add Idx.

let (i,j): (Idx,Idx) = ...;
let offset: Offset = j - i; // Subtracting indices gives an offset
let k: Idx = j + offset; // Adding an offset to an index gives an index
// let _ = i + j; -- You can't add indices

I managed (with some difficulty) to implement std::iter::Step so I can also iterate through a range of indices

for k in i .. j { /* ... */ }

but now I've set my eyes on a higher goal: I also want to use ranges of these types to slice into sequences

let v: Vec<sometype> = vec![...];
let w: &[sometype] = &v[i..j]; // Slice with a range of Idx

This should be a simple matter of implementing std::ops::Index and std::ops::IndexMut, except that the type system won't let me implement

impl<I,T> std::ops::Index<std::ops::Range<I>> for Vec<T>
where I: /* my types */
{ ... }

for a wrapper type, or a generic

impl<I,T> std::ops::Index<std::ops::Range<Wrapper<I>>> for Vec<T>
where I: /* my types */
{ ... }

where Wrapper is the type I actually use and I a trait that helps me write generic code.

The problem is that both Index and Range are defined outside of my crate, so this kind of specialisation is not allowed. Or is it?

Is there any way that I can implement a trait for a generic type outside my crate when its generic parameters are from within my crate?

Or, better still, is there any way to tap into the syntactic sugar of the .. operator, so I can get a wrapped type? What I really want is to wrap Range to get the same behaviour and then some. I can do that by wrapping Range and implementing Deref, but if I go that route, I lose the syntactic sugar of the .. operator.

It is not a big problem, but I can imagine some confusion when you could write

for k in i .. j { /* ... */ }

like you can for the built-in types, but you have to use

let w: &[type] = &v[range(i,j)];

for slicing. It gets even more cumbersome if I want to allow slices such as i.., ..j to be wrapped. (The .. slice doesn't matter here, it won't get my types anyway). If I did that, I would need constructors for three types of ranges, or some ugly wrapping using Option, I think.

The .. syntactic sugar is really neat, but from what I have explored you just cannot use that much for ranges of your own types. You can define ranges and you can, with some hacking, iterate through them, but you can't index with them.

Tell me I'm wrong, or let me know if there are any tricks that gets the job done, or even half-done. Or, if this is indeed impossible, let me know so I can stop wasting time on it and write a wrapper class and give up on the .. operator.

Update I have put a simplified example in playgrounds

ANSWER

Answered 2022-Feb-10 at 05:54

No, you can't.

By definition of the orphan rules:

Given impl<P1..=Pn> Trait<T1..=Tn> for T0, an impl is valid only if at least one of the following is true:

Trait is a local trait

All of

At least one of the types T0..=Tn must be a local type. Let Ti be the first such type.

No uncovered type parameters P1..=Pn may appear in T0..Ti (excluding Ti)

Only the appearance of uncovered type parameters is restricted. Note that for the purposes of coherence, fundamental types are special. The T in Box is not considered covered, and Box is considered local.

Local trait

A trait which was defined in the current crate. A trait definition is local or not independent of applied type arguments. Given trait Foo<T, U>, Foo is always local, regardless of the types substituted for T and U.

Local type

A struct, enum, or union which was defined in the current crate. This is not affected by applied type arguments. struct Foo is considered local, but Vec<Foo> is not. LocalType<ForeignType> is local. Type aliases do not affect locality.

As neither Index nor Range nor Vec are local, and Range is not a fundamental type, you cannot impl<T> Index<Range<...>> for Vec<T>, no matter what you put in the place of the ....

The reason for these rules is that nothing prevents Range or Vec from implementing impl<T, Idx> Index<Range<Idx>> for Vec<T>. Such impl does not exist, and probably never will, but the rules are the same among all types, and in the general case this definitely can happen.

You cannot overload the range operator either - it always creates a Range (or RangeInclusive, RangeFull, etc.).

The only solution I can think about is to create a newtype wrapper for Vec, as suggested in the comments.

If you want your vector to return a wrapped slice, you can use a bit of unsafe code:

use std::ops::{Index, IndexMut, Range, Deref, DerefMut};

#[repr(transparent)] // Because of this we can soundly cast `&{mut }[T]` to `&{mut }MySlice<T>`.
pub struct MySlice<T>([T]);

impl<'a, T> From<&'a [T]> for &'a MySlice<T> {
    fn from(v: &'a [T]) -> &'a MySlice<T> {
        unsafe { &*(v as *const [T] as *const MySlice<T>) }
    }
}
impl<'a, T> From<&'a mut [T]> for &'a mut MySlice<T> {
    fn from(v: &'a mut [T]) -> &'a mut MySlice<T> {
        unsafe { &mut *(v as *mut [T] as *mut MySlice<T>) }
    }
}

impl<T> Index<usize> for MySlice<T> {
    type Output = T;
    fn index(&self, idx: usize) -> &Self::Output { &self.0[idx] }
}
impl<T> IndexMut<usize> for MySlice<T> {
    fn index_mut(&mut self, idx: usize) -> &mut Self::Output { &mut self.0[idx] }
}

impl<T> Index<Range<usize>> for MySlice<T> {
    type Output = MySlice<T>;
    fn index(&self, idx: Range<usize>) -> &Self::Output { self.0[idx].into() }
}
impl<T> IndexMut<Range<usize>> for MySlice<T> {
    fn index_mut(&mut self, idx: Range<usize>) -> &mut Self::Output { (&mut self.0[idx]).into() }
}
// And so on, for all range types...

pub struct MyVec<T>(pub Vec<T>);

impl<T> Deref for MyVec<T> {
    type Target = MySlice<T>;
    fn deref(&self) -> &Self::Target { self.0.as_slice().into() }
}
impl<T> DerefMut for MyVec<T> {
    fn deref_mut(&mut self) -> &mut Self::Target { self.0.as_mut_slice().into() }
}

Source https://stackoverflow.com/questions/71017029

QUESTION

How to return JSON as a response in Rust Rocket with auto field deserialising?

Asked 2022-Jan-29 at 09:52

I'm trying to create a Printing Server in rust and face a problem when trying to send JSON as a response.

I've found on the Rocket documentation that is really easy to send JSON as a response: You just have to use the Serde library.

Unfortunatly, that wasn't so simple for me...

Here is my current code :

#[derive(Serialize,Deserialize)]
pub struct Printers {
    pub printers: Vec<Printer>,
}

#[derive(Serialize,Deserialize)]
pub struct Printer {
    pub device_type: String,
    pub uid: String,
    pub provider: String,
    pub name: String,
    pub connection: String,
    pub version: u8,
    pub manufacturer: String,
}

/**
 * Here is my main problem 
 *   -> I want to send back the Printers Object as a JSON
 */
#[get("/printers")]
fn printers(key: ApiKey<'_>) -> Json<Printers> {
    let resp = crate::get_printers::get();
    Json(resp)
}

Here is the error code :

   --> src/order_route.rs:25:33
    |
25  | fn printers(key: ApiKey<'_>) -> Json<Printers> {
    |                                 ^^^^^^^^^^^^^^ the trait `Responder<'_, '_>` is not implemented for `rocket_contrib::json::Json<order_route::Printers>`
    |
note: required by `route::handler::<impl Outcome<rocket::Response<'o>, Status, rocket::Data<'o>>>::from`
   --> ********/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.5.0-rc.1/src/route/handler.rs:188:5
    |
188 |     pub fn from<R: Responder<'r, 'o>>(req: &'r Request<'_>, responder: R) -> Outcome<'r> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

It seems I need a trait to do this, but don't know how to create it, If someone could help me to find a solution, I will be greatful.

[EDIT]

Here is the Cargo.toml file

[package]
name = "test"
version = "0.0.0"
edition = "2018"
[dependencies]
rocket = "0.5.0-rc.1"
reqwest = { version = "0.11", features = ["blocking", "json"] }
openssl = { version = "0.10", features = ["vendored"] }
json = "0.12.4"
serde = "1.0.127"
serde_json = "1.0.66"

[dependencies.rocket_contrib]
version = "0.4.10"
default-features = false
features = ["json"]

[workspace]
members = [
    ""
]

And here is the full stacktrace

*****:~/*****/label-printer-server-rust/server$ cargo run
   Compiling hello v0.0.0 (/home/*****/*****/label-printer-server-rust/server)
error[E0277]: the trait bound `rocket_contrib::json::Json<order_route::Printers>: Responder<'_, '_>` is not satisfied
   --> src/order_route.rs:25:33
    |
25  | fn printers(key: ApiKey<'_>) -> Json<Printers> {
    |                                 ^^^^^^^^^^^^^^ the trait `Responder<'_, '_>` is not implemented for `rocket_contrib::json::Json<order_route::Printers>`
    |
note: required by `route::handler::<impl Outcome<rocket::Response<'o>, Status, rocket::Data<'o>>>::from`
   --> /home/*****/.cargo/registry/src/github.com-1ecc6299db9ec823/rocket-0.5.0-rc.1/src/route/handler.rs:188:5
    |
188 |     pub fn from<R: Responder<'r, 'o>>(req: &'r Request<'_>, responder: R) -> Outcome<'r> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0308]: mismatched types
  --> src/order_route.rs:27:10
   |
27 |     Json(resp)
   |          ^^^^ expected struct `order_route::Printers`, found enum `Result`
   |
   = note: expected struct `order_route::Printers`
                found enum `Result<structures::Printers, Box<dyn StdError>>`

Some errors have detailed explanations: E0277, E0308.
For more information about an error, try `rustc --explain E0277`.
error: could not compile `hello` due to 2 previous errors

ANSWER

Answered 2021-Aug-06 at 14:23

You are using rocket 0.5.0-rc.1 and rocket_contrib 0.4.10. While Json from rocket_contrib does implement Responder, it implements the Responder trait of Rocket v4, not that of Rocket v5.

In Rocket v5, Json is not part of rocket_contib anymore, but included in the rocket crate (note that you need to enable the json feature on the rocket crate):

use rocket::serde::json::Json;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
pub struct Printers {
    pub printers: Vec<Printer>,
}

#[derive(Serialize, Deserialize)]
pub struct Printer {
    pub device_type: String,
    pub uid: String,
    pub provider: String,
    pub name: String,
    pub connection: String,
    pub version: u8,
    pub manufacturer: String,
}

#[get("/printers")]
fn printers() -> Json<Printers> {
    todo!();
}

Note that you can now also remove rocket_contrib from your Cargo.toml (as you are not using any features from it).

Source https://stackoverflow.com/questions/68682054

QUESTION

WASM from Rust not returning the expected types

Asked 2022-Jan-18 at 09:48

Hey @all I was playing with WebAssembly Studio and created an empty Rust project.

In my Rust code, I'm returning the pointer and the length for my "Hello World" string. Compiling worked fine, but I was expecting the resulting WASM to have a function returning two i32. But I found a function taking one i32 and returning nothing.

Why is the function not having the signature fn () -> (i32,i32) ?
How am I supposed to extract the two values from the WASM module? (Using Rust-wasmtime)

Below you can find the code snippets I'm talking about. Thanks in advance!

#[no_mangle]
pub extern "C" fn say() -> (*const u8,i32)  {
    let pointcut = "Hello World";

    (pointcut.as_ptr(),11)
}

(module
  (type $t0 (func (param i32)))
  (func $say (export "say") (type $t0) (param $p0 i32)
    get_local $p0
    i32.const 11
    i32.store offset=4
    get_local $p0
    i32.const 1024
    i32.store)
  (table $T0 1 1 anyfunc)
  (memory $memory (export "memory") 17)
  (data (i32.const 1024) "Hello World"))

ANSWER

Answered 2022-Jan-18 at 09:48

WebAssembly got the ability to return multiple values just recently. The compiler used doesn't seem to support this yet or doesn't use it for compatibility reasons, i.e. for runtimes that don't know this feature yet.

Therefore, the compiler rewrites the code as follows:

#[no_mangle]
pub extern "C" fn say(output: &mut (*const u8, i32)) {
    let pointcut = "Hello World";

    output.1 = 11;
    output.0 = pointcut.as_ptr();
}

At least this leads to the same WebAssembly code as your code. The parameter output corresponds to $p0 in the WebAssembly code.

The WebAssembly code now does the following:

First, the number 11 is written to the second item in the tuple, so at the memory address of output + 4. The offset is 4 bytes because the first i32 of the tuple has 4 bytes.

Second, the memory address of the string pointcut is written to the first value of the tuple. As you can see in the data section of the generated WebAssembly code, the string was put into linear memory at memory address 1024. Note: pointcut is a string literal and therefore static, so it does not live on the stack, which would be illegal (as already commented by Coder-256) ~~and would result in a compiler error~~. EDIT: No compile error because of raw pointer. Lifetime checks are only performed for references.

So to get the two values, you have to allocate 8 bytes of memory (for the two i32) in linear memory, call the function with a pointer to this memory area, and then read both values. It may be more convenient to split the function into two separate functions, where one returns the pointer and the other the length. At least, this would make extracting the values easier because both functions would return a single i32.

EDIT: I found an article from Mozilla which also explains my thoughts in the section about "wasm-bindgen".

Source https://stackoverflow.com/questions/70641080

QUESTION

Struct padding rules in Rust

Asked 2022-Jan-05 at 06:29

Recently when I was learning Type Layout in Rust (https://doc.rust-lang.org/reference/type-layout.html), I saw that struct in Rust supports the #[repr(C)] directive, so I wanna to see the difference between the default(Rust) representation and C-like representation. Here comes the code:

use type_layout::TypeLayout;

#[derive(TypeLayout)]
struct ACG1 {
    time1: u16, // 2
    time2: u16, // 2
    upper: u32, // 4
    lower: u16, // 2
}

#[derive(TypeLayout)]
#[repr(C)]
struct ACG2 {
    time1: u16, // 2
    time2: u16, // 2
    upper: u32, // 4
    lower: u16, // 2
}
fn main() {
    println!("ACG1: {}", ACG1::type_layout());
    println!("ACG2: {}", ACG2::type_layout());
}

and I get the following output: I understand the rules for padding the #[repr(C)]structure and the size of the structure as a whole, but what confused me is the Rust representation struct ACG1, I can't find any clear documentation on Rust padding rules, and I think the padding size should also be included in the overall size of the structure, but why is the size of ACG1 only 12 bytes?

BTW, This is the crate I used to assist in printing the layout of the structure: https://crates.io/crates/type-layout

ANSWER

Answered 2022-Jan-05 at 04:26

This crate does not seem to account for field reordering. It appears the compiler reordered the struct to have upper first:

struct ACG1 {
    upper: u32,
    time1: u16,
    time2: u16,
    lower: u16,
}

Its somewhat hard to see, but the derive macro implementation checks the difference between fields in declared order. So in this sense, there are 4 bytes of "padding" between the beginning of the struct and the first field (time1) and 4 bytes of "padding" between the third field (upper) and fourth field (lower). There is an issue filed that it doesn't work for non-#[repr(C)] structs, so I would not recommend using this crate for this purpose.

As far as Rust's rules go, the reference says "There are no guarantees of data layout made by [the default] representation." So in theory, the compiler can do whatever it wants and reorder fields based on access patterns. But in practice, I don't think its that elaborate and organizing by field size is a simple way to minimize padding.

Source https://stackoverflow.com/questions/70587534

QUESTION

Should I take `self` by value or mutable reference when using the Builder pattern?

Asked 2021-Dec-19 at 02:26

So far, I've seen two builder patterns in official Rust code and other crates:

impl DataBuilder {
    pub fn new() -> DataBuilder { ... }
    pub fn arg1(&mut self, arg1: Arg1Type) -> &mut Builder { ... }
    pub fn arg2(&mut self, arg2: Arg2Type) -> &mut Builder { ... }
    ...
    pub fn build(&self) -> Data { ... }
}

impl DataBuilder {
    pub fn new() -> DataBuilder { ... }
    pub fn arg1(self, arg1: Arg1Type) -> Builder { ... }
    pub fn arg2(self, arg2: Arg2Type) -> Builder { ... }
    ...
    pub fn build(self) -> Data { ... }
}

I'm writing a new crate and I'm a bit confused which pattern I should choose. I know it will be painful if I change some APIs later, so I want to make the decision now.

I understand the semantic difference between them, but which one should we prefer in practical situations? Or how should we choose between them? Why?

ANSWER

Answered 2021-Dec-19 at 02:26

Is it beneficial to build multiple values from the same builder?

If yes, use &mut self
If no, use self

Consider std::thread::Builder which is a builder for std::thread::Thread. It uses Option fields internally to configure how to build the thread:

pub struct Builder {
    name: Option<String>,
    stack_size: Option<usize>,
}

It uses self to .spawn() the thread because it needs ownership of the name. It could theoretically use &mut self and .take() the name out of the field, but then subsequent calls to .spawn() wouldn't create identical results, which is kinda bad design. It could choose to .clone() the name, but then there's an additional and often unneeded cost to spawn a thread. Using &mut self would be a detriment.

Consider std::process::Command which serves as a builder for a std::process::Child. It has fields containing the program, args, environment, and pipe configuration:

pub struct Command {
    program: CString,
    args: Vec<CString>,
    env: CommandEnv,
    stdin: Option<Stdio>,
    stdout: Option<Stdio>,
    stderr: Option<Stdio>,
    // ...
}

It uses &mut self to .spawn() because it does not take ownership of these fields to create the Child. It has to internally copy all that data over to the OS anyway, so there's no reason to consume self. There's also a tangible benefit and use-case to spawning multiple child processes with the same configuration.

Consider std::fs::OpenOptions which serves as a builder for std::fs::File. It only stores basic configuration:

pub struct OpenOptions {
    read: bool,
    write: bool,
    append: bool,
    truncate: bool,
    create: bool,
    create_new: bool,
    // ...
}

It uses &mut self to .open() because it does not need ownership of anything to work. It is somewhat similar to the thread builder since there is a path associated with a file just as there is a name associated with a thread, however, the file path is only passed in to .open() and not stored along with the builder. There's a use-case for opening multiple files with the same configuration.

The considerations above really only cover the semantics of self in the .build() method, but there's plenty of justification that if you pick one method you should use that for the interim methods as well:

API consistency
chaining (&mut self) -> &mut Self into build(self) obviously wouldn't compile
using (self) -> Self into build(&mut self) would limit the flexibility of the builder to be reused long-term

Source https://stackoverflow.com/questions/70408356

Community Discussions, Code Snippets contain sources that include Stack Exchange Network

Vulnerabilities

No vulnerabilities reported

Install crate

You can download it from GitHub.
You can use crate like any standard Java library. Please include the the jar files in your classpath. You can also use any IDE and you can run and debug the crate component as you would do with any other Java program. Best practice is to use a build tool that supports dependency management such as Maven or Gradle. For Maven installation, please refer maven.apache.org. For Gradle installation, please refer gradle.org .

Support

For any new features, suggestions and bugs create an issue on GitHub. If you have any questions check and ask questions on community page Stack Overflow .