NextGraph
/
oxigraph
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Activity

Use `Self::AssocName` to simplify declarations

Browse Source 
To keep with DRY principle, I think it makes it a bit less redundant to reuse the Self::<associated_type_name> structure in the well known trait implementations - keeps it consistent with the trait decl too.
pull/739/head
Yuri Astrakhan 11 months ago committed by Thomas Tanon
parent 51941c0dc5
commit 2b8df24b8b
37 changed files with 131 additions and 139 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 10
      js/src/model.rs
  2. 12
      lib/oxrdf/src/dataset.rs
  3. 4
      lib/oxrdf/src/graph.rs
  4. 4
      lib/oxrdf/src/interning.rs
  5. 10
      lib/oxrdf/src/parser.rs
  6. 2
      lib/oxrdfio/src/parser.rs
  7. 2
      lib/oxrdfxml/src/parser.rs
  8. 2
      lib/oxsdatatypes/src/boolean.rs
  9. 32
      lib/oxsdatatypes/src/date_time.rs
  10. 12
      lib/oxsdatatypes/src/decimal.rs
  11. 2
      lib/oxsdatatypes/src/double.rs
  12. 16
      lib/oxsdatatypes/src/duration.rs
  13. 2
      lib/oxsdatatypes/src/float.rs
  14. 6
      lib/oxsdatatypes/src/integer.rs
  15. 2
      lib/oxttl/src/lexer.rs
  16. 2
      lib/oxttl/src/n3.rs
  17. 2
      lib/oxttl/src/nquads.rs
  18. 2
      lib/oxttl/src/ntriples.rs
  19. 2
      lib/oxttl/src/trig.rs
  20. 2
      lib/oxttl/src/turtle.rs
  21. 2
      lib/sparesults/src/parser.rs
  22. 14
      lib/sparesults/src/solution.rs
  23. 6
      lib/spargebra/src/query.rs
  24. 26
      lib/spargebra/src/term.rs
  25. 6
      lib/spargebra/src/update.rs
  26. 4
      lib/src/io/format.rs
  27. 4
      lib/src/io/read.rs
  28. 12
      lib/src/sparql/algebra.rs
  29. 22
      lib/src/sparql/eval.rs
  30. 4
      lib/src/sparql/model.rs
  31. 16
      lib/src/sparql/service.rs
  32. 4
      lib/src/storage/backend/rocksdb.rs
  33. 6
      lib/src/storage/mod.rs
  34. 6
      lib/src/storage/small_string.rs
  35. 4
      lib/src/store.rs
  36. 4
      testsuite/src/manifest.rs
  37. 2
      testsuite/src/sparql_evaluator.rs

10
js/src/model.rs
Unescape View File

@ -564,7 +564,7 @@ impl From<Quad> for JsTerm {
impl TryFrom<JsTerm> for NamedNode { impl TryFrom<JsTerm> for NamedNode {
type Error = JsValue; type Error = JsValue;
fn try_from(value: JsTerm) -> Result<Self, JsValue> { fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
match value { match value {
JsTerm::NamedNode(node) => Ok(node.into()), JsTerm::NamedNode(node) => Ok(node.into()),
JsTerm::BlankNode(node) => Err(format_err!( JsTerm::BlankNode(node) => Err(format_err!(
@ -588,7 +588,7 @@ impl TryFrom<JsTerm> for NamedNode {
impl TryFrom<JsTerm> for NamedOrBlankNode { impl TryFrom<JsTerm> for NamedOrBlankNode {
type Error = JsValue; type Error = JsValue;
fn try_from(value: JsTerm) -> Result<Self, JsValue> { fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
match value { match value {
JsTerm::NamedNode(node) => Ok(node.into()), JsTerm::NamedNode(node) => Ok(node.into()),
JsTerm::BlankNode(node) => Ok(node.into()), JsTerm::BlankNode(node) => Ok(node.into()),
@ -614,7 +614,7 @@ impl TryFrom<JsTerm> for NamedOrBlankNode {
impl TryFrom<JsTerm> for Subject { impl TryFrom<JsTerm> for Subject {
type Error = JsValue; type Error = JsValue;
fn try_from(value: JsTerm) -> Result<Self, JsValue> { fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
match value { match value {
JsTerm::NamedNode(node) => Ok(node.into()), JsTerm::NamedNode(node) => Ok(node.into()),
JsTerm::BlankNode(node) => Ok(node.into()), JsTerm::BlankNode(node) => Ok(node.into()),
@ -637,7 +637,7 @@ impl TryFrom<JsTerm> for Subject {
impl TryFrom<JsTerm> for Term { impl TryFrom<JsTerm> for Term {
type Error = JsValue; type Error = JsValue;
fn try_from(value: JsTerm) -> Result<Self, JsValue> { fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
match value { match value {
JsTerm::NamedNode(node) => Ok(node.into()), JsTerm::NamedNode(node) => Ok(node.into()),
JsTerm::BlankNode(node) => Ok(node.into()), JsTerm::BlankNode(node) => Ok(node.into()),
@ -657,7 +657,7 @@ impl TryFrom<JsTerm> for Term {
impl TryFrom<JsTerm> for GraphName { impl TryFrom<JsTerm> for GraphName {
type Error = JsValue; type Error = JsValue;
fn try_from(value: JsTerm) -> Result<Self, JsValue> { fn try_from(value: JsTerm) -> Result<Self, Self::Error> {
match value { match value {
JsTerm::NamedNode(node) => Ok(node.into()), JsTerm::NamedNode(node) => Ok(node.into()),
JsTerm::BlankNode(node) => Ok(node.into()), JsTerm::BlankNode(node) => Ok(node.into()),

12
lib/oxrdf/src/dataset.rs
Unescape View File

@ -927,7 +927,7 @@ impl<'a> IntoIterator for &'a Dataset {
type Item = QuadRef<'a>; type Item = QuadRef<'a>;
type IntoIter = Iter<'a>; type IntoIter = Iter<'a>;
fn into_iter(self) -> Iter<'a> { fn into_iter(self) -> Self::IntoIter {
self.iter() self.iter()
} }
} }
@ -1285,7 +1285,7 @@ impl<'a> IntoIterator for GraphView<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
type IntoIter = GraphViewIter<'a>; type IntoIter = GraphViewIter<'a>;
fn into_iter(self) -> GraphViewIter<'a> { fn into_iter(self) -> Self::IntoIter {
self.iter() self.iter()
} }
} }
@ -1294,7 +1294,7 @@ impl<'a, 'b> IntoIterator for &'b GraphView<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
type IntoIter = GraphViewIter<'a>; type IntoIter = GraphViewIter<'a>;
fn into_iter(self) -> GraphViewIter<'a> { fn into_iter(self) -> Self::IntoIter {
self.iter() self.iter()
} }
} }
@ -1496,7 +1496,7 @@ impl<'a> IntoIterator for &'a GraphViewMut<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
type IntoIter = GraphViewIter<'a>; type IntoIter = GraphViewIter<'a>;
fn into_iter(self) -> GraphViewIter<'a> { fn into_iter(self) -> Self::IntoIter {
self.iter() self.iter()
} }
} }
@ -1527,7 +1527,7 @@ pub struct Iter<'a> {
impl<'a> Iterator for Iter<'a> { impl<'a> Iterator for Iter<'a> {
type Item = QuadRef<'a>; type Item = QuadRef<'a>;
fn next(&mut self) -> Option<QuadRef<'a>> { fn next(&mut self) -> Option<Self::Item> {
self.inner self.inner
.next() .next()
.map(|(s, p, o, g)| self.dataset.decode_spog((s, p, o, g))) .map(|(s, p, o, g)| self.dataset.decode_spog((s, p, o, g)))
@ -1551,7 +1551,7 @@ pub struct GraphViewIter<'a> {
impl<'a> Iterator for GraphViewIter<'a> { impl<'a> Iterator for GraphViewIter<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
fn next(&mut self) -> Option<TripleRef<'a>> { fn next(&mut self) -> Option<Self::Item> {
self.inner self.inner
.next() .next()
.map(|(_, s, p, o)| self.dataset.decode_spo((s, p, o))) .map(|(_, s, p, o)| self.dataset.decode_spo((s, p, o)))

4
lib/oxrdf/src/graph.rs
Unescape View File

@ -229,7 +229,7 @@ impl<'a> IntoIterator for &'a Graph {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
type IntoIter = Iter<'a>; type IntoIter = Iter<'a>;
fn into_iter(self) -> Iter<'a> { fn into_iter(self) -> Self::IntoIter {
self.iter() self.iter()
} }
} }
@ -276,7 +276,7 @@ pub struct Iter<'a> {
impl<'a> Iterator for Iter<'a> { impl<'a> Iterator for Iter<'a> {
type Item = TripleRef<'a>; type Item = TripleRef<'a>;
fn next(&mut self) -> Option<TripleRef<'a>> { fn next(&mut self) -> Option<Self::Item> {
self.inner.next() self.inner.next()
} }
} }

4
lib/oxrdf/src/interning.rs
Unescape View File

@ -510,8 +510,8 @@ struct IdentityHasherBuilder;
impl BuildHasher for IdentityHasherBuilder { impl BuildHasher for IdentityHasherBuilder {
type Hasher = IdentityHasher; type Hasher = IdentityHasher;
fn build_hasher(&self) -> IdentityHasher { fn build_hasher(&self) -> Self::Hasher {
IdentityHasher::default() Self::Hasher::default()
} }
} }

10
lib/oxrdf/src/parser.rs
Unescape View File

@ -25,7 +25,7 @@ impl FromStr for NamedNode {
/// ///
/// assert_eq!(NamedNode::from_str("<http://example.com>").unwrap(), NamedNode::new("http://example.com").unwrap()) /// assert_eq!(NamedNode::from_str("<http://example.com>").unwrap(), NamedNode::new("http://example.com").unwrap())
/// ``` /// ```
fn from_str(s: &str) -> Result<Self, TermParseError> { fn from_str(s: &str) -> Result<Self, Self::Err> {
let (term, left) = read_named_node(s)?; let (term, left) = read_named_node(s)?;
if !left.is_empty() { if !left.is_empty() {
return Err(TermParseError::msg( return Err(TermParseError::msg(
@ -47,7 +47,7 @@ impl FromStr for BlankNode {
/// ///
/// assert_eq!(BlankNode::from_str("_:ex").unwrap(), BlankNode::new("ex").unwrap()) /// assert_eq!(BlankNode::from_str("_:ex").unwrap(), BlankNode::new("ex").unwrap())
/// ``` /// ```
fn from_str(s: &str) -> Result<Self, TermParseError> { fn from_str(s: &str) -> Result<Self, Self::Err> {
let (term, left) = read_blank_node(s)?; let (term, left) = read_blank_node(s)?;
if !left.is_empty() { if !left.is_empty() {
return Err(TermParseError::msg( return Err(TermParseError::msg(
@ -75,7 +75,7 @@ impl FromStr for Literal {
/// assert_eq!(Literal::from_str("-122.23").unwrap(), Literal::new_typed_literal("-122.23", xsd::DECIMAL)); /// assert_eq!(Literal::from_str("-122.23").unwrap(), Literal::new_typed_literal("-122.23", xsd::DECIMAL));
/// assert_eq!(Literal::from_str("-122e+1").unwrap(), Literal::new_typed_literal("-122e+1", xsd::DOUBLE)); /// assert_eq!(Literal::from_str("-122e+1").unwrap(), Literal::new_typed_literal("-122e+1", xsd::DOUBLE));
/// ``` /// ```
fn from_str(s: &str) -> Result<Self, TermParseError> { fn from_str(s: &str) -> Result<Self, Self::Err> {
let (term, left) = read_literal(s)?; let (term, left) = read_literal(s)?;
if !left.is_empty() { if !left.is_empty() {
return Err(TermParseError::msg("Invalid literal serialization")); return Err(TermParseError::msg("Invalid literal serialization"));
@ -100,7 +100,7 @@ impl FromStr for Term {
/// Literal::new_simple_literal("o") /// Literal::new_simple_literal("o")
/// ).into()); /// ).into());
/// ``` /// ```
fn from_str(s: &str) -> Result<Self, TermParseError> { fn from_str(s: &str) -> Result<Self, Self::Err> {
let (term, left) = read_term(s, 0)?; let (term, left) = read_term(s, 0)?;
if !left.is_empty() { if !left.is_empty() {
return Err(TermParseError::msg("Invalid term serialization")); return Err(TermParseError::msg("Invalid term serialization"));
@ -120,7 +120,7 @@ impl FromStr for Variable {
/// ///
/// assert_eq!(Variable::from_str("$foo").unwrap(), Variable::new("foo").unwrap()) /// assert_eq!(Variable::from_str("$foo").unwrap(), Variable::new("foo").unwrap())
/// ``` /// ```
fn from_str(s: &str) -> Result<Self, TermParseError> { fn from_str(s: &str) -> Result<Self, Self::Err> {
if !s.starts_with('?') && !s.starts_with('$') { if !s.starts_with('?') && !s.starts_with('$') {
return Err(TermParseError::msg( return Err(TermParseError::msg(
"Variable serialization should start with ? or $", "Variable serialization should start with ? or $",

2
lib/oxrdfio/src/parser.rs
Unescape View File

@ -382,7 +382,7 @@ enum FromReadQuadReaderKind<R: Read> {
impl<R: Read> Iterator for FromReadQuadReader<R> { impl<R: Read> Iterator for FromReadQuadReader<R> {
type Item = Result<Quad, ParseError>; type Item = Result<Quad, ParseError>;
fn next(&mut self) -> Option<Result<Quad, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some(match &mut self.parser { Some(match &mut self.parser {
FromReadQuadReaderKind::N3(parser) => match parser.next()? { FromReadQuadReaderKind::N3(parser) => match parser.next()? {
Ok(quad) => self.mapper.map_n3_quad(quad), Ok(quad) => self.mapper.map_n3_quad(quad),

2
lib/oxrdfxml/src/parser.rs
Unescape View File

@ -212,7 +212,7 @@ pub struct FromReadRdfXmlReader<R: Read> {
impl<R: Read> Iterator for FromReadRdfXmlReader<R> { impl<R: Read> Iterator for FromReadRdfXmlReader<R> {
type Item = Result<Triple, ParseError>; type Item = Result<Triple, ParseError>;
fn next(&mut self) -> Option<Result<Triple, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(triple) = self.results.pop() { if let Some(triple) = self.results.pop() {
return Some(Ok(triple)); return Some(Ok(triple));

2
lib/oxsdatatypes/src/boolean.rs
Unescape View File

@ -66,7 +66,7 @@ impl FromStr for Boolean {
type Err = ParseBoolError; type Err = ParseBoolError;
#[inline] #[inline]
fn from_str(input: &str) -> Result<Self, ParseBoolError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
Ok(match input { Ok(match input {
"true" | "1" => true, "true" | "1" => true,
"false" | "0" => false, "false" | "0" => false,

32
lib/oxsdatatypes/src/date_time.rs
Unescape View File

@ -256,7 +256,7 @@ impl TryFrom<Date> for DateTime {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(date: Date) -> Result<Self, DateTimeOverflowError> { fn try_from(date: Date) -> Result<Self, Self::Error> {
Self::new( Self::new(
date.year(), date.year(),
date.month(), date.month(),
@ -272,7 +272,7 @@ impl TryFrom<Date> for DateTime {
impl FromStr for DateTime { impl FromStr for DateTime {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, date_time_lexical_rep) ensure_complete(input, date_time_lexical_rep)
} }
} }
@ -528,7 +528,7 @@ impl From<DateTime> for Time {
impl FromStr for Time { impl FromStr for Time {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, time_lexical_rep) ensure_complete(input, time_lexical_rep)
} }
} }
@ -762,7 +762,7 @@ impl TryFrom<DateTime> for Date {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(date_time: DateTime) -> Result<Self, DateTimeOverflowError> { fn try_from(date_time: DateTime) -> Result<Self, Self::Error> {
Self::new( Self::new(
date_time.year(), date_time.year(),
date_time.month(), date_time.month(),
@ -775,7 +775,7 @@ impl TryFrom<DateTime> for Date {
impl FromStr for Date { impl FromStr for Date {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, date_lexical_rep) ensure_complete(input, date_lexical_rep)
} }
} }
@ -896,7 +896,7 @@ impl TryFrom<DateTime> for GYearMonth {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(date_time: DateTime) -> Result<Self, DateTimeOverflowError> { fn try_from(date_time: DateTime) -> Result<Self, Self::Error> {
Self::new( Self::new(
date_time.year(), date_time.year(),
date_time.month(), date_time.month(),
@ -917,7 +917,7 @@ impl From<Date> for GYearMonth {
impl FromStr for GYearMonth { impl FromStr for GYearMonth {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, g_year_month_lexical_rep) ensure_complete(input, g_year_month_lexical_rep)
} }
} }
@ -1031,7 +1031,7 @@ impl TryFrom<DateTime> for GYear {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(date_time: DateTime) -> Result<Self, DateTimeOverflowError> { fn try_from(date_time: DateTime) -> Result<Self, Self::Error> {
Self::new(date_time.year(), date_time.timezone_offset()) Self::new(date_time.year(), date_time.timezone_offset())
} }
} }
@ -1041,7 +1041,7 @@ impl TryFrom<Date> for GYear {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(date: Date) -> Result<Self, DateTimeOverflowError> { fn try_from(date: Date) -> Result<Self, Self::Error> {
Self::new(date.year(), date.timezone_offset()) Self::new(date.year(), date.timezone_offset())
} }
} }
@ -1050,7 +1050,7 @@ impl TryFrom<GYearMonth> for GYear {
type Error = DateTimeOverflowError; type Error = DateTimeOverflowError;
#[inline] #[inline]
fn try_from(year_month: GYearMonth) -> Result<Self, DateTimeOverflowError> { fn try_from(year_month: GYearMonth) -> Result<Self, Self::Error> {
Self::new(year_month.year(), year_month.timezone_offset()) Self::new(year_month.year(), year_month.timezone_offset())
} }
} }
@ -1058,7 +1058,7 @@ impl TryFrom<GYearMonth> for GYear {
impl FromStr for GYear { impl FromStr for GYear {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, g_year_lexical_rep) ensure_complete(input, g_year_lexical_rep)
} }
} }
@ -1186,7 +1186,7 @@ impl From<Date> for GMonthDay {
impl FromStr for GMonthDay { impl FromStr for GMonthDay {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, g_month_day_lexical_rep) ensure_complete(input, g_month_day_lexical_rep)
} }
} }
@ -1315,7 +1315,7 @@ impl From<GMonthDay> for GMonth {
impl FromStr for GMonth { impl FromStr for GMonth {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, g_month_lexical_rep) ensure_complete(input, g_month_lexical_rep)
} }
} }
@ -1436,7 +1436,7 @@ impl From<GMonthDay> for GDay {
impl FromStr for GDay { impl FromStr for GDay {
type Err = ParseDateTimeError; type Err = ParseDateTimeError;
fn from_str(input: &str) -> Result<Self, ParseDateTimeError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
ensure_complete(input, g_day_lexical_rep) ensure_complete(input, g_day_lexical_rep)
} }
} }
@ -1499,7 +1499,7 @@ impl TryFrom<DayTimeDuration> for TimezoneOffset {
type Error = InvalidTimezoneError; type Error = InvalidTimezoneError;
#[inline] #[inline]
fn try_from(value: DayTimeDuration) -> Result<Self, InvalidTimezoneError> { fn try_from(value: DayTimeDuration) -> Result<Self, Self::Error> {
let offset_in_minutes = value.minutes() + value.hours() * 60; let offset_in_minutes = value.minutes() + value.hours() * 60;
let result = Self::new( let result = Self::new(
offset_in_minutes offset_in_minutes
@ -1519,7 +1519,7 @@ impl TryFrom<Duration> for TimezoneOffset {
type Error = InvalidTimezoneError; type Error = InvalidTimezoneError;
#[inline] #[inline]
fn try_from(value: Duration) -> Result<Self, InvalidTimezoneError> { fn try_from(value: Duration) -> Result<Self, Self::Error> {
DayTimeDuration::try_from(value) DayTimeDuration::try_from(value)
.map_err(|_| InvalidTimezoneError { .map_err(|_| InvalidTimezoneError {
offset_in_minutes: 0, offset_in_minutes: 0,

12
lib/oxsdatatypes/src/decimal.rs
Unescape View File

@ -361,7 +361,7 @@ impl TryFrom<i128> for Decimal {
type Error = TooLargeForDecimalError; type Error = TooLargeForDecimalError;
#[inline] #[inline]
fn try_from(value: i128) -> Result<Self, TooLargeForDecimalError> { fn try_from(value: i128) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
value: value value: value
.checked_mul(DECIMAL_PART_POW) .checked_mul(DECIMAL_PART_POW)
@ -374,7 +374,7 @@ impl TryFrom<u128> for Decimal {
type Error = TooLargeForDecimalError; type Error = TooLargeForDecimalError;
#[inline] #[inline]
fn try_from(value: u128) -> Result<Self, TooLargeForDecimalError> { fn try_from(value: u128) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
value: i128::try_from(value) value: i128::try_from(value)
.map_err(|_| TooLargeForDecimalError)? .map_err(|_| TooLargeForDecimalError)?
@ -395,7 +395,7 @@ impl TryFrom<Float> for Decimal {
type Error = TooLargeForDecimalError; type Error = TooLargeForDecimalError;
#[inline] #[inline]
fn try_from(value: Float) -> Result<Self, TooLargeForDecimalError> { fn try_from(value: Float) -> Result<Self, Self::Error> {
Double::from(value).try_into() Double::from(value).try_into()
} }
} }
@ -405,7 +405,7 @@ impl TryFrom<Double> for Decimal {
#[inline] #[inline]
#[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)] #[allow(clippy::cast_precision_loss, clippy::cast_possible_truncation)]
fn try_from(value: Double) -> Result<Self, TooLargeForDecimalError> { fn try_from(value: Double) -> Result<Self, Self::Error> {
let shifted = f64::from(value) * (DECIMAL_PART_POW as f64); let shifted = f64::from(value) * (DECIMAL_PART_POW as f64);
if (i128::MIN as f64) <= shifted && shifted <= (i128::MAX as f64) { if (i128::MIN as f64) <= shifted && shifted <= (i128::MAX as f64) {
Ok(Self { Ok(Self {
@ -448,7 +448,7 @@ impl TryFrom<Decimal> for Integer {
type Error = TooLargeForIntegerError; type Error = TooLargeForIntegerError;
#[inline] #[inline]
fn try_from(value: Decimal) -> Result<Self, TooLargeForIntegerError> { fn try_from(value: Decimal) -> Result<Self, Self::Error> {
Ok(i64::try_from( Ok(i64::try_from(
value value
.value .value
@ -464,7 +464,7 @@ impl FromStr for Decimal {
type Err = ParseDecimalError; type Err = ParseDecimalError;
/// Parses decimals lexical mapping /// Parses decimals lexical mapping
fn from_str(input: &str) -> Result<Self, ParseDecimalError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
// (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+) // (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)
let input = input.as_bytes(); let input = input.as_bytes();
if input.is_empty() { if input.is_empty() {

2
lib/oxsdatatypes/src/double.rs
Unescape View File

@ -189,7 +189,7 @@ impl FromStr for Double {
type Err = ParseFloatError; type Err = ParseFloatError;
#[inline] #[inline]
fn from_str(input: &str) -> Result<Self, ParseFloatError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
Ok(f64::from_str(input)?.into()) Ok(f64::from_str(input)?.into())
} }
} }

16
lib/oxsdatatypes/src/duration.rs
Unescape View File

@ -176,7 +176,7 @@ impl TryFrom<StdDuration> for Duration {
type Error = DurationOverflowError; type Error = DurationOverflowError;
#[inline] #[inline]
fn try_from(value: StdDuration) -> Result<Self, DurationOverflowError> { fn try_from(value: StdDuration) -> Result<Self, Self::Error> {
Ok(DayTimeDuration::try_from(value)?.into()) Ok(DayTimeDuration::try_from(value)?.into())
} }
} }
@ -184,7 +184,7 @@ impl TryFrom<StdDuration> for Duration {
impl FromStr for Duration { impl FromStr for Duration {
type Err = ParseDurationError; type Err = ParseDurationError;
fn from_str(input: &str) -> Result<Self, ParseDurationError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
let parts = ensure_complete(input, duration_parts)?; let parts = ensure_complete(input, duration_parts)?;
if parts.year_month.is_none() && parts.day_time.is_none() { if parts.year_month.is_none() && parts.day_time.is_none() {
return Err(ParseDurationError::msg("Empty duration")); return Err(ParseDurationError::msg("Empty duration"));
@ -394,7 +394,7 @@ impl TryFrom<Duration> for YearMonthDuration {
type Error = DurationOverflowError; type Error = DurationOverflowError;
#[inline] #[inline]
fn try_from(value: Duration) -> Result<Self, DurationOverflowError> { fn try_from(value: Duration) -> Result<Self, Self::Error> {
if value.day_time == DayTimeDuration::default() { if value.day_time == DayTimeDuration::default() {
Ok(value.year_month) Ok(value.year_month)
} else { } else {
@ -406,7 +406,7 @@ impl TryFrom<Duration> for YearMonthDuration {
impl FromStr for YearMonthDuration { impl FromStr for YearMonthDuration {
type Err = ParseDurationError; type Err = ParseDurationError;
fn from_str(input: &str) -> Result<Self, ParseDurationError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
let parts = ensure_complete(input, duration_parts)?; let parts = ensure_complete(input, duration_parts)?;
if parts.day_time.is_some() { if parts.day_time.is_some() {
return Err(ParseDurationError::msg( return Err(ParseDurationError::msg(
@ -580,7 +580,7 @@ impl TryFrom<Duration> for DayTimeDuration {
type Error = DurationOverflowError; type Error = DurationOverflowError;
#[inline] #[inline]
fn try_from(value: Duration) -> Result<Self, DurationOverflowError> { fn try_from(value: Duration) -> Result<Self, Self::Error> {
if value.year_month == YearMonthDuration::default() { if value.year_month == YearMonthDuration::default() {
Ok(value.day_time) Ok(value.day_time)
} else { } else {
@ -593,7 +593,7 @@ impl TryFrom<StdDuration> for DayTimeDuration {
type Error = DurationOverflowError; type Error = DurationOverflowError;
#[inline] #[inline]
fn try_from(value: StdDuration) -> Result<Self, DurationOverflowError> { fn try_from(value: StdDuration) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
seconds: Decimal::new( seconds: Decimal::new(
i128::try_from(value.as_nanos()).map_err(|_| DurationOverflowError)?, i128::try_from(value.as_nanos()).map_err(|_| DurationOverflowError)?,
@ -608,7 +608,7 @@ impl TryFrom<DayTimeDuration> for StdDuration {
type Error = DurationOverflowError; type Error = DurationOverflowError;
#[inline] #[inline]
fn try_from(value: DayTimeDuration) -> Result<Self, DurationOverflowError> { fn try_from(value: DayTimeDuration) -> Result<Self, Self::Error> {
if value.seconds.is_negative() { if value.seconds.is_negative() {
return Err(DurationOverflowError); return Err(DurationOverflowError);
} }
@ -636,7 +636,7 @@ impl TryFrom<DayTimeDuration> for StdDuration {
impl FromStr for DayTimeDuration { impl FromStr for DayTimeDuration {
type Err = ParseDurationError; type Err = ParseDurationError;
fn from_str(input: &str) -> Result<Self, ParseDurationError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
let parts = ensure_complete(input, duration_parts)?; let parts = ensure_complete(input, duration_parts)?;
if parts.year_month.is_some() { if parts.year_month.is_some() {
return Err(ParseDurationError::msg( return Err(ParseDurationError::msg(

2
lib/oxsdatatypes/src/float.rs
Unescape View File

@ -179,7 +179,7 @@ impl FromStr for Float {
type Err = ParseFloatError; type Err = ParseFloatError;
#[inline] #[inline]
fn from_str(input: &str) -> Result<Self, ParseFloatError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
Ok(f32::from_str(input)?.into()) Ok(f32::from_str(input)?.into())
} }
} }

6
lib/oxsdatatypes/src/integer.rs
Unescape View File

@ -228,7 +228,7 @@ impl FromStr for Integer {
type Err = ParseIntError; type Err = ParseIntError;
#[inline] #[inline]
fn from_str(input: &str) -> Result<Self, ParseIntError> { fn from_str(input: &str) -> Result<Self, Self::Err> {
Ok(i64::from_str(input)?.into()) Ok(i64::from_str(input)?.into())
} }
} }
@ -244,7 +244,7 @@ impl TryFrom<Float> for Integer {
type Error = TooLargeForIntegerError; type Error = TooLargeForIntegerError;
#[inline] #[inline]
fn try_from(value: Float) -> Result<Self, TooLargeForIntegerError> { fn try_from(value: Float) -> Result<Self, Self::Error> {
Decimal::try_from(value) Decimal::try_from(value)
.map_err(|_| TooLargeForIntegerError)? .map_err(|_| TooLargeForIntegerError)?
.try_into() .try_into()
@ -255,7 +255,7 @@ impl TryFrom<Double> for Integer {
type Error = TooLargeForIntegerError; type Error = TooLargeForIntegerError;
#[inline] #[inline]
fn try_from(value: Double) -> Result<Self, TooLargeForIntegerError> { fn try_from(value: Double) -> Result<Self, Self::Error> {
Decimal::try_from(value) Decimal::try_from(value)
.map_err(|_| TooLargeForIntegerError)? .map_err(|_| TooLargeForIntegerError)?
.try_into() .try_into()

2
lib/oxttl/src/lexer.rs
Unescape View File

@ -56,7 +56,7 @@ impl TokenRecognizer for N3Lexer {
&mut self, &mut self,
data: &'a [u8], data: &'a [u8],
is_ending: bool, is_ending: bool,
options: &N3LexerOptions, options: &Self::Options,
) -> Option<(usize, Result<N3Token<'a>, TokenRecognizerError>)> { ) -> Option<(usize, Result<N3Token<'a>, TokenRecognizerError>)> {
match *data.first()? { match *data.first()? {
b'<' => match *data.get(1)? { b'<' => match *data.get(1)? {

2
lib/oxttl/src/n3.rs
Unescape View File

@ -450,7 +450,7 @@ impl<R: Read> FromReadN3Reader<R> {
impl<R: Read> Iterator for FromReadN3Reader<R> { impl<R: Read> Iterator for FromReadN3Reader<R> {
type Item = Result<N3Quad, ParseError>; type Item = Result<N3Quad, ParseError>;
fn next(&mut self) -> Option<Result<N3Quad, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
self.inner.next() self.inner.next()
} }
} }

2
lib/oxttl/src/nquads.rs
Unescape View File

@ -215,7 +215,7 @@ pub struct FromReadNQuadsReader<R: Read> {
impl<R: Read> Iterator for FromReadNQuadsReader<R> { impl<R: Read> Iterator for FromReadNQuadsReader<R> {
type Item = Result<Quad, ParseError>; type Item = Result<Quad, ParseError>;
fn next(&mut self) -> Option<Result<Quad, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
self.inner.next() self.inner.next()
} }
} }

2
lib/oxttl/src/ntriples.rs
Unescape View File

@ -215,7 +215,7 @@ pub struct FromReadNTriplesReader<R: Read> {
impl<R: Read> Iterator for FromReadNTriplesReader<R> { impl<R: Read> Iterator for FromReadNTriplesReader<R> {
type Item = Result<Triple, ParseError>; type Item = Result<Triple, ParseError>;
fn next(&mut self) -> Option<Result<Triple, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some(self.inner.next()?.map(Into::into)) Some(self.inner.next()?.map(Into::into))
} }
} }

2
lib/oxttl/src/trig.rs
Unescape View File

@ -300,7 +300,7 @@ impl<R: Read> FromReadTriGReader<R> {
impl<R: Read> Iterator for FromReadTriGReader<R> { impl<R: Read> Iterator for FromReadTriGReader<R> {
type Item = Result<Quad, ParseError>; type Item = Result<Quad, ParseError>;
fn next(&mut self) -> Option<Result<Quad, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
self.inner.next() self.inner.next()
} }
} }

2
lib/oxttl/src/turtle.rs
Unescape View File

@ -302,7 +302,7 @@ impl<R: Read> FromReadTurtleReader<R> {
impl<R: Read> Iterator for FromReadTurtleReader<R> { impl<R: Read> Iterator for FromReadTurtleReader<R> {
type Item = Result<Triple, ParseError>; type Item = Result<Triple, ParseError>;
fn next(&mut self) -> Option<Result<Triple, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some(self.inner.next()?.map(Into::into)) Some(self.inner.next()?.map(Into::into))
} }
} }

2
lib/sparesults/src/parser.rs
Unescape View File

@ -206,7 +206,7 @@ impl<R: Read> FromReadSolutionsReader<R> {
impl<R: Read> Iterator for FromReadSolutionsReader<R> { impl<R: Read> Iterator for FromReadSolutionsReader<R> {
type Item = Result<QuerySolution, ParseError>; type Item = Result<QuerySolution, ParseError>;
fn next(&mut self) -> Option<Result<QuerySolution, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some( Some(
match &mut self.solutions { match &mut self.solutions {
SolutionsReaderKind::Xml(reader) => reader.read_next(), SolutionsReaderKind::Xml(reader) => reader.read_next(),

14
lib/sparesults/src/solution.rs
Unescape View File

@ -130,7 +130,7 @@ impl<'a> IntoIterator for &'a QuerySolution {
type IntoIter = Iter<'a>; type IntoIter = Iter<'a>;
#[inline] #[inline]
fn into_iter(self) -> Iter<'a> { fn into_iter(self) -> Self::IntoIter {
Iter { Iter {
inner: self.variables.iter().zip(&self.values), inner: self.variables.iter().zip(&self.values),
} }
@ -142,7 +142,7 @@ impl Index<usize> for QuerySolution {
#[allow(clippy::panic)] #[allow(clippy::panic)]
#[inline] #[inline]
fn index(&self, index: usize) -> &Term { fn index(&self, index: usize) -> &Self::Output {
self.get(index) self.get(index)
.unwrap_or_else(|| panic!("The column {index} is not set in this solution")) .unwrap_or_else(|| panic!("The column {index} is not set in this solution"))
} }
@ -153,7 +153,7 @@ impl Index<&str> for QuerySolution {
#[allow(clippy::panic)] #[allow(clippy::panic)]
#[inline] #[inline]
fn index(&self, index: &str) -> &Term { fn index(&self, index: &str) -> &Self::Output {
self.get(index) self.get(index)
.unwrap_or_else(|| panic!("The variable ?{index} is not set in this solution")) .unwrap_or_else(|| panic!("The variable ?{index} is not set in this solution"))
} }
@ -164,7 +164,7 @@ impl Index<VariableRef<'_>> for QuerySolution {
#[allow(clippy::panic)] #[allow(clippy::panic)]
#[inline] #[inline]
fn index(&self, index: VariableRef<'_>) -> &Term { fn index(&self, index: VariableRef<'_>) -> &Self::Output {
self.get(index) self.get(index)
.unwrap_or_else(|| panic!("The variable {index} is not set in this solution")) .unwrap_or_else(|| panic!("The variable {index} is not set in this solution"))
} }
@ -173,7 +173,7 @@ impl Index<Variable> for QuerySolution {
type Output = Term; type Output = Term;
#[inline] #[inline]
fn index(&self, index: Variable) -> &Term { fn index(&self, index: Variable) -> &Self::Output {
self.index(index.as_ref()) self.index(index.as_ref())
} }
} }
@ -182,7 +182,7 @@ impl Index<&Variable> for QuerySolution {
type Output = Term; type Output = Term;
#[inline] #[inline]
fn index(&self, index: &Variable) -> &Term { fn index(&self, index: &Variable) -> &Self::Output {
self.index(index.as_ref()) self.index(index.as_ref())
} }
} }
@ -228,7 +228,7 @@ impl<'a> Iterator for Iter<'a> {
type Item = (&'a Variable, &'a Term); type Item = (&'a Variable, &'a Term);
#[inline] #[inline]
fn next(&mut self) -> Option<(&'a Variable, &'a Term)> { fn next(&mut self) -> Option<Self::Item> {
for (variable, value) in &mut self.inner { for (variable, value) in &mut self.inner {
if let Some(value) = value { if let Some(value) = value {
return Some((variable, value)); return Some((variable, value));

6
lib/spargebra/src/query.rs
Unescape View File

@ -275,7 +275,7 @@ impl fmt::Display for Query {
impl FromStr for Query { impl FromStr for Query {
type Err = ParseError; type Err = ParseError;
fn from_str(query: &str) -> Result<Self, ParseError> { fn from_str(query: &str) -> Result<Self, Self::Err> {
Self::parse(query, None) Self::parse(query, None)
} }
} }
@ -283,7 +283,7 @@ impl FromStr for Query {
impl<'a> TryFrom<&'a str> for Query { impl<'a> TryFrom<&'a str> for Query {
type Error = ParseError; type Error = ParseError;
fn try_from(query: &str) -> Result<Self, ParseError> { fn try_from(query: &str) -> Result<Self, Self::Error> {
Self::from_str(query) Self::from_str(query)
} }
} }
@ -291,7 +291,7 @@ impl<'a> TryFrom<&'a str> for Query {
impl<'a> TryFrom<&'a String> for Query { impl<'a> TryFrom<&'a String> for Query {
type Error = ParseError; type Error = ParseError;
fn try_from(query: &String) -> Result<Self, ParseError> { fn try_from(query: &String) -> Result<Self, Self::Error> {
Self::from_str(query) Self::from_str(query)
} }
} }

26
lib/spargebra/src/term.rs
Unescape View File

@ -48,7 +48,7 @@ impl TryFrom<Subject> for GroundSubject {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(subject: Subject) -> Result<Self, ()> { fn try_from(subject: Subject) -> Result<Self, Self::Error> {
match subject { match subject {
Subject::NamedNode(t) => Ok(t.into()), Subject::NamedNode(t) => Ok(t.into()),
Subject::BlankNode(_) => Err(()), Subject::BlankNode(_) => Err(()),
@ -62,7 +62,7 @@ impl TryFrom<GroundTerm> for GroundSubject {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(term: GroundTerm) -> Result<Self, ()> { fn try_from(term: GroundTerm) -> Result<Self, Self::Error> {
match term { match term {
GroundTerm::NamedNode(t) => Ok(t.into()), GroundTerm::NamedNode(t) => Ok(t.into()),
GroundTerm::Literal(_) => Err(()), GroundTerm::Literal(_) => Err(()),
@ -125,7 +125,7 @@ impl TryFrom<Term> for GroundTerm {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(term: Term) -> Result<Self, ()> { fn try_from(term: Term) -> Result<Self, Self::Error> {
match term { match term {
Term::NamedNode(t) => Ok(t.into()), Term::NamedNode(t) => Ok(t.into()),
Term::BlankNode(_) => Err(()), Term::BlankNode(_) => Err(()),
@ -171,7 +171,7 @@ impl TryFrom<Triple> for GroundTriple {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(triple: Triple) -> Result<Self, ()> { fn try_from(triple: Triple) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
subject: triple.subject.try_into()?, subject: triple.subject.try_into()?,
predicate: triple.predicate, predicate: triple.predicate,
@ -221,7 +221,7 @@ impl TryFrom<GraphNamePattern> for GraphName {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(pattern: GraphNamePattern) -> Result<Self, ()> { fn try_from(pattern: GraphNamePattern) -> Result<Self, Self::Error> {
match pattern { match pattern {
GraphNamePattern::NamedNode(t) => Ok(t.into()), GraphNamePattern::NamedNode(t) => Ok(t.into()),
GraphNamePattern::DefaultGraph => Ok(Self::DefaultGraph), GraphNamePattern::DefaultGraph => Ok(Self::DefaultGraph),
@ -295,7 +295,7 @@ impl TryFrom<QuadPattern> for Quad {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(quad: QuadPattern) -> Result<Self, ()> { fn try_from(quad: QuadPattern) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
subject: quad.subject.try_into()?, subject: quad.subject.try_into()?,
predicate: quad.predicate.try_into()?, predicate: quad.predicate.try_into()?,
@ -370,7 +370,7 @@ impl TryFrom<Quad> for GroundQuad {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(quad: Quad) -> Result<Self, ()> { fn try_from(quad: Quad) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
subject: quad.subject.try_into()?, subject: quad.subject.try_into()?,
predicate: quad.predicate, predicate: quad.predicate,
@ -425,7 +425,7 @@ impl TryFrom<NamedNodePattern> for NamedNode {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(pattern: NamedNodePattern) -> Result<Self, ()> { fn try_from(pattern: NamedNodePattern) -> Result<Self, Self::Error> {
match pattern { match pattern {
NamedNodePattern::NamedNode(t) => Ok(t), NamedNodePattern::NamedNode(t) => Ok(t),
NamedNodePattern::Variable(_) => Err(()), NamedNodePattern::Variable(_) => Err(()),
@ -559,7 +559,7 @@ impl TryFrom<TermPattern> for Subject {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(term: TermPattern) -> Result<Self, ()> { fn try_from(term: TermPattern) -> Result<Self, Self::Error> {
match term { match term {
TermPattern::NamedNode(t) => Ok(t.into()), TermPattern::NamedNode(t) => Ok(t.into()),
TermPattern::BlankNode(t) => Ok(t.into()), TermPattern::BlankNode(t) => Ok(t.into()),
@ -574,7 +574,7 @@ impl TryFrom<TermPattern> for Term {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(pattern: TermPattern) -> Result<Self, ()> { fn try_from(pattern: TermPattern) -> Result<Self, Self::Error> {
match pattern { match pattern {
TermPattern::NamedNode(t) => Ok(t.into()), TermPattern::NamedNode(t) => Ok(t.into()),
TermPattern::BlankNode(t) => Ok(t.into()), TermPattern::BlankNode(t) => Ok(t.into()),
@ -686,7 +686,7 @@ impl TryFrom<TermPattern> for GroundTermPattern {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(pattern: TermPattern) -> Result<Self, ()> { fn try_from(pattern: TermPattern) -> Result<Self, Self::Error> {
Ok(match pattern { Ok(match pattern {
TermPattern::NamedNode(named_node) => named_node.into(), TermPattern::NamedNode(named_node) => named_node.into(),
TermPattern::BlankNode(_) => return Err(()), TermPattern::BlankNode(_) => return Err(()),
@ -828,7 +828,7 @@ impl TryFrom<TriplePattern> for Triple {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(triple: TriplePattern) -> Result<Self, ()> { fn try_from(triple: TriplePattern) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
subject: triple.subject.try_into()?, subject: triple.subject.try_into()?,
predicate: triple.predicate.try_into()?, predicate: triple.predicate.try_into()?,
@ -1000,7 +1000,7 @@ impl TryFrom<QuadPattern> for GroundQuadPattern {
type Error = (); type Error = ();
#[inline] #[inline]
fn try_from(pattern: QuadPattern) -> Result<Self, ()> { fn try_from(pattern: QuadPattern) -> Result<Self, Self::Error> {
Ok(Self { Ok(Self {
subject: pattern.subject.try_into()?, subject: pattern.subject.try_into()?,
predicate: pattern.predicate, predicate: pattern.predicate,

6
lib/spargebra/src/update.rs
Unescape View File

@ -70,7 +70,7 @@ impl fmt::Display for Update {
impl FromStr for Update { impl FromStr for Update {
type Err = ParseError; type Err = ParseError;
fn from_str(update: &str) -> Result<Self, ParseError> { fn from_str(update: &str) -> Result<Self, Self::Err> {
Self::parse(update, None) Self::parse(update, None)
} }
} }
@ -78,7 +78,7 @@ impl FromStr for Update {
impl<'a> TryFrom<&'a str> for Update { impl<'a> TryFrom<&'a str> for Update {
type Error = ParseError; type Error = ParseError;
fn try_from(update: &str) -> Result<Self, ParseError> { fn try_from(update: &str) -> Result<Self, Self::Error> {
Self::from_str(update) Self::from_str(update)
} }
} }
@ -86,7 +86,7 @@ impl<'a> TryFrom<&'a str> for Update {
impl<'a> TryFrom<&'a String> for Update { impl<'a> TryFrom<&'a String> for Update {
type Error = ParseError; type Error = ParseError;
fn try_from(update: &String) -> Result<Self, ParseError> { fn try_from(update: &String) -> Result<Self, Self::Error> {
Self::from_str(update) Self::from_str(update)
} }
} }

4
lib/src/io/format.rs
Unescape View File

@ -258,7 +258,7 @@ impl TryFrom<DatasetFormat> for GraphFormat {
/// Attempts to find a graph format that is a subset of this [`DatasetFormat`]. /// Attempts to find a graph format that is a subset of this [`DatasetFormat`].
#[inline] #[inline]
fn try_from(value: DatasetFormat) -> Result<Self, ()> { fn try_from(value: DatasetFormat) -> Result<Self, Self::Error> {
match value { match value {
DatasetFormat::NQuads => Ok(Self::NTriples), DatasetFormat::NQuads => Ok(Self::NTriples),
DatasetFormat::TriG => Ok(Self::Turtle), DatasetFormat::TriG => Ok(Self::Turtle),
@ -271,7 +271,7 @@ impl TryFrom<GraphFormat> for DatasetFormat {
/// Attempts to find a dataset format that is a superset of this [`GraphFormat`]. /// Attempts to find a dataset format that is a superset of this [`GraphFormat`].
#[inline] #[inline]
fn try_from(value: GraphFormat) -> Result<Self, ()> { fn try_from(value: GraphFormat) -> Result<Self, Self::Error> {
match value { match value {
GraphFormat::NTriples => Ok(Self::NQuads), GraphFormat::NTriples => Ok(Self::NQuads),
GraphFormat::Turtle => Ok(Self::TriG), GraphFormat::Turtle => Ok(Self::TriG),

4
lib/src/io/read.rs
Unescape View File

@ -95,7 +95,7 @@ pub struct TripleReader<R: Read> {
impl<R: Read> Iterator for TripleReader<R> { impl<R: Read> Iterator for TripleReader<R> {
type Item = Result<Triple, ParseError>; type Item = Result<Triple, ParseError>;
fn next(&mut self) -> Option<Result<Triple, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some(self.parser.next()?.map(Into::into).map_err(Into::into)) Some(self.parser.next()?.map(Into::into).map_err(Into::into))
} }
} }
@ -184,7 +184,7 @@ pub struct QuadReader<R: Read> {
impl<R: Read> Iterator for QuadReader<R> { impl<R: Read> Iterator for QuadReader<R> {
type Item = Result<Quad, ParseError>; type Item = Result<Quad, ParseError>;
fn next(&mut self) -> Option<Result<Quad, ParseError>> { fn next(&mut self) -> Option<Self::Item> {
Some(self.parser.next()?.map_err(Into::into)) Some(self.parser.next()?.map_err(Into::into))
} }
} }

12
lib/src/sparql/algebra.rs
Unescape View File

@ -65,7 +65,7 @@ impl fmt::Display for Query {
impl FromStr for Query { impl FromStr for Query {
type Err = spargebra::ParseError; type Err = spargebra::ParseError;
fn from_str(query: &str) -> Result<Self, spargebra::ParseError> { fn from_str(query: &str) -> Result<Self, Self::Err> {
Self::parse(query, None) Self::parse(query, None)
} }
} }
@ -73,7 +73,7 @@ impl FromStr for Query {
impl TryFrom<&str> for Query { impl TryFrom<&str> for Query {
type Error = spargebra::ParseError; type Error = spargebra::ParseError;
fn try_from(query: &str) -> Result<Self, spargebra::ParseError> { fn try_from(query: &str) -> Result<Self, Self::Error> {
Self::from_str(query) Self::from_str(query)
} }
} }
@ -81,7 +81,7 @@ impl TryFrom<&str> for Query {
impl TryFrom<&String> for Query { impl TryFrom<&String> for Query {
type Error = spargebra::ParseError; type Error = spargebra::ParseError;
fn try_from(query: &String) -> Result<Self, spargebra::ParseError> { fn try_from(query: &String) -> Result<Self, Self::Error> {
Self::from_str(query) Self::from_str(query)
} }
} }
@ -158,7 +158,7 @@ impl fmt::Display for Update {
impl FromStr for Update { impl FromStr for Update {
type Err = spargebra::ParseError; type Err = spargebra::ParseError;
fn from_str(update: &str) -> Result<Self, spargebra::ParseError> { fn from_str(update: &str) -> Result<Self, Self::Err> {
Self::parse(update, None) Self::parse(update, None)
} }
} }
@ -166,7 +166,7 @@ impl FromStr for Update {
impl TryFrom<&str> for Update { impl TryFrom<&str> for Update {
type Error = spargebra::ParseError; type Error = spargebra::ParseError;
fn try_from(update: &str) -> Result<Self, spargebra::ParseError> { fn try_from(update: &str) -> Result<Self, Self::Error> {
Self::from_str(update) Self::from_str(update)
} }
} }
@ -174,7 +174,7 @@ impl TryFrom<&str> for Update {
impl TryFrom<&String> for Update { impl TryFrom<&String> for Update {
type Error = spargebra::ParseError; type Error = spargebra::ParseError;
fn try_from(update: &String) -> Result<Self, spargebra::ParseError> { fn try_from(update: &String) -> Result<Self, Self::Error> {
Self::from_str(update) Self::from_str(update)
} }
} }

22
lib/src/sparql/eval.rs
Unescape View File

@ -4732,7 +4732,7 @@ struct CartesianProductJoinIterator {
impl Iterator for CartesianProductJoinIterator { impl Iterator for CartesianProductJoinIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(result) = self.buffered_results.pop() { if let Some(result) = self.buffered_results.pop() {
return Some(result); return Some(result);
@ -4767,7 +4767,7 @@ struct HashJoinIterator {
impl Iterator for HashJoinIterator { impl Iterator for HashJoinIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(result) = self.buffered_results.pop() { if let Some(result) = self.buffered_results.pop() {
return Some(result); return Some(result);
@ -4806,7 +4806,7 @@ struct HashLeftJoinIterator {
impl Iterator for HashLeftJoinIterator { impl Iterator for HashLeftJoinIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(result) = self.buffered_results.pop() { if let Some(result) = self.buffered_results.pop() {
return Some(result); return Some(result);
@ -4854,7 +4854,7 @@ struct ForLoopLeftJoinIterator {
impl Iterator for ForLoopLeftJoinIterator { impl Iterator for ForLoopLeftJoinIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
if let Some(tuple) = self.current_right.next() { if let Some(tuple) = self.current_right.next() {
return Some(tuple); return Some(tuple);
} }
@ -4881,7 +4881,7 @@ struct UnionIterator {
impl Iterator for UnionIterator { impl Iterator for UnionIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(tuple) = self.current_iterator.next() { if let Some(tuple) = self.current_iterator.next() {
return Some(tuple); return Some(tuple);
@ -4903,7 +4903,7 @@ struct ConsecutiveDeduplication {
impl Iterator for ConsecutiveDeduplication { impl Iterator for ConsecutiveDeduplication {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
// Basic idea. We buffer the previous result and we only emit it when we kow the next one or it's the end // Basic idea. We buffer the previous result and we only emit it when we kow the next one or it's the end
loop { loop {
if let Some(next) = self.inner.next() { if let Some(next) = self.inner.next() {
@ -4944,7 +4944,7 @@ struct ConstructIterator {
impl Iterator for ConstructIterator { impl Iterator for ConstructIterator {
type Item = Result<Triple, EvaluationError>; type Item = Result<Triple, EvaluationError>;
fn next(&mut self) -> Option<Result<Triple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(result) = self.buffered_results.pop() { if let Some(result) = self.buffered_results.pop() {
return Some(result); return Some(result);
@ -5046,7 +5046,7 @@ struct DescribeIterator {
impl Iterator for DescribeIterator { impl Iterator for DescribeIterator {
type Item = Result<Triple, EvaluationError>; type Item = Result<Triple, EvaluationError>;
fn next(&mut self) -> Option<Result<Triple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(quad) = self.quads.next() { if let Some(quad) = self.quads.next() {
return Some(match quad { return Some(match quad {
@ -5097,7 +5097,7 @@ impl<T1, T2, I1: Iterator<Item = T1>, I2: Iterator<Item = T2>> Iterator
{ {
type Item = (Option<T1>, Option<T2>); type Item = (Option<T1>, Option<T2>);
fn next(&mut self) -> Option<(Option<T1>, Option<T2>)> { fn next(&mut self) -> Option<Self::Item> {
match (self.a.next(), self.b.next()) { match (self.a.next(), self.b.next()) {
(None, None) => None, (None, None) => None,
r => Some(r), r => Some(r),
@ -5220,7 +5220,7 @@ impl<
{ {
type Item = Result<O, EvaluationError>; type Item = Result<O, EvaluationError>;
fn next(&mut self) -> Option<Result<O, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(current) = &mut self.current { if let Some(current) = &mut self.current {
if let Some(next) = current.next() { if let Some(next) = current.next() {
@ -5629,7 +5629,7 @@ struct StatsIterator {
impl Iterator for StatsIterator { impl Iterator for StatsIterator {
type Item = Result<EncodedTuple, EvaluationError>; type Item = Result<EncodedTuple, EvaluationError>;
fn next(&mut self) -> Option<Result<EncodedTuple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
let start = Timer::now(); let start = Timer::now();
let result = self.inner.next(); let result = self.inner.next();
self.stats.exec_duration.set( self.stats.exec_duration.set(

4
lib/src/sparql/model.rs
Unescape View File

@ -221,7 +221,7 @@ impl Iterator for QuerySolutionIter {
type Item = Result<QuerySolution, EvaluationError>; type Item = Result<QuerySolution, EvaluationError>;
#[inline] #[inline]
fn next(&mut self) -> Option<Result<QuerySolution, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
self.iter.next() self.iter.next()
} }
@ -253,7 +253,7 @@ impl Iterator for QueryTripleIter {
type Item = Result<Triple, EvaluationError>; type Item = Result<Triple, EvaluationError>;
#[inline] #[inline]
fn next(&mut self) -> Option<Result<Triple, EvaluationError>> { fn next(&mut self) -> Option<Self::Item> {
self.iter.next() self.iter.next()
} }

16
lib/src/sparql/service.rs
Unescape View File

@ -24,7 +24,7 @@ use std::time::Duration;
/// impl ServiceHandler for TestServiceHandler { /// impl ServiceHandler for TestServiceHandler {
/// type Error = EvaluationError; /// type Error = EvaluationError;
/// ///
/// fn handle(&self,service_name: NamedNode, query: Query) -> Result<QueryResults,EvaluationError> { /// fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error> {
/// if service_name == "http://example.com/service" { /// if service_name == "http://example.com/service" {
/// self.store.query(query) /// self.store.query(query)
/// } else { /// } else {
@ -61,7 +61,7 @@ pub struct EmptyServiceHandler;
impl ServiceHandler for EmptyServiceHandler { impl ServiceHandler for EmptyServiceHandler {
type Error = EvaluationError; type Error = EvaluationError;
fn handle(&self, name: NamedNode, _: Query) -> Result<QueryResults, EvaluationError> { fn handle(&self, name: NamedNode, _: Query) -> Result<QueryResults, Self::Error> {
Err(EvaluationError::UnsupportedService(name)) Err(EvaluationError::UnsupportedService(name))
} }
} }
@ -79,11 +79,7 @@ impl<S: ServiceHandler> ErrorConversionServiceHandler<S> {
impl<S: ServiceHandler> ServiceHandler for ErrorConversionServiceHandler<S> { impl<S: ServiceHandler> ServiceHandler for ErrorConversionServiceHandler<S> {
type Error = EvaluationError; type Error = EvaluationError;
fn handle( fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error> {
&self,
service_name: NamedNode,
query: Query,
) -> Result<QueryResults, EvaluationError> {
self.handler self.handler
.handle(service_name, query) .handle(service_name, query)
.map_err(|e| EvaluationError::Service(Box::new(e))) .map_err(|e| EvaluationError::Service(Box::new(e)))
@ -105,11 +101,7 @@ impl SimpleServiceHandler {
impl ServiceHandler for SimpleServiceHandler { impl ServiceHandler for SimpleServiceHandler {
type Error = EvaluationError; type Error = EvaluationError;
fn handle( fn handle(&self, service_name: NamedNode, query: Query) -> Result<QueryResults, Self::Error> {
&self,
service_name: NamedNode,
query: Query,
) -> Result<QueryResults, EvaluationError> {
let (content_type, body) = self let (content_type, body) = self
.client .client
.post( .post(

4
lib/src/storage/backend/rocksdb.rs
Unescape View File

@ -1157,7 +1157,7 @@ impl Drop for PinnableSlice {
impl Deref for PinnableSlice { impl Deref for PinnableSlice {
type Target = [u8]; type Target = [u8];
fn deref(&self) -> &[u8] { fn deref(&self) -> &Self::Target {
unsafe { unsafe {
let mut len = 0; let mut len = 0;
let val = rocksdb_pinnableslice_value(self.0, &mut len); let val = rocksdb_pinnableslice_value(self.0, &mut len);
@ -1200,7 +1200,7 @@ impl Drop for Buffer {
impl Deref for Buffer { impl Deref for Buffer {
type Target = [u8]; type Target = [u8];
fn deref(&self) -> &[u8] { fn deref(&self) -> &Self::Target {
unsafe { slice::from_raw_parts(self.base, self.len) } unsafe { slice::from_raw_parts(self.base, self.len) }
} }
} }

6
lib/src/storage/mod.rs
Unescape View File

@ -814,7 +814,7 @@ impl ChainedDecodingQuadIterator {
impl Iterator for ChainedDecodingQuadIterator { impl Iterator for ChainedDecodingQuadIterator {
type Item = Result<EncodedQuad, StorageError>; type Item = Result<EncodedQuad, StorageError>;
fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> { fn next(&mut self) -> Option<Self::Item> {
if let Some(result) = self.first.next() { if let Some(result) = self.first.next() {
Some(result) Some(result)
} else if let Some(second) = self.second.as_mut() { } else if let Some(second) = self.second.as_mut() {
@ -833,7 +833,7 @@ pub struct DecodingQuadIterator {
impl Iterator for DecodingQuadIterator { impl Iterator for DecodingQuadIterator {
type Item = Result<EncodedQuad, StorageError>; type Item = Result<EncodedQuad, StorageError>;
fn next(&mut self) -> Option<Result<EncodedQuad, StorageError>> { fn next(&mut self) -> Option<Self::Item> {
if let Err(e) = self.iter.status() { if let Err(e) = self.iter.status() {
return Some(Err(e)); return Some(Err(e));
} }
@ -850,7 +850,7 @@ pub struct DecodingGraphIterator {
impl Iterator for DecodingGraphIterator { impl Iterator for DecodingGraphIterator {
type Item = Result<EncodedTerm, StorageError>; type Item = Result<EncodedTerm, StorageError>;
fn next(&mut self) -> Option<Result<EncodedTerm, StorageError>> { fn next(&mut self) -> Option<Self::Item> {
if let Err(e) = self.iter.status() { if let Err(e) = self.iter.status() {
return Some(Err(e)); return Some(Err(e));
} }

6
lib/src/storage/small_string.rs
Unescape View File

@ -65,7 +65,7 @@ impl Deref for SmallString {
type Target = str; type Target = str;
#[inline] #[inline]
fn deref(&self) -> &str { fn deref(&self) -> &Self::Target {
self.as_str() self.as_str()
} }
} }
@ -146,7 +146,7 @@ impl FromStr for SmallString {
type Err = BadSmallStringError; type Err = BadSmallStringError;
#[inline] #[inline]
fn from_str(value: &str) -> Result<Self, BadSmallStringError> { fn from_str(value: &str) -> Result<Self, Self::Err> {
if value.len() <= 15 { if value.len() <= 15 {
let mut inner = [0; 16]; let mut inner = [0; 16];
inner[..value.len()].copy_from_slice(value.as_bytes()); inner[..value.len()].copy_from_slice(value.as_bytes());
@ -165,7 +165,7 @@ impl<'a> TryFrom<&'a str> for SmallString {
type Error = BadSmallStringError; type Error = BadSmallStringError;
#[inline] #[inline]
fn try_from(value: &'a str) -> Result<Self, BadSmallStringError> { fn try_from(value: &'a str) -> Result<Self, Self::Error> {
Self::from_str(value) Self::from_str(value)
} }
} }

4
lib/src/store.rs
Unescape View File

@ -1471,7 +1471,7 @@ pub struct QuadIter {
impl Iterator for QuadIter { impl Iterator for QuadIter {
type Item = Result<Quad, StorageError>; type Item = Result<Quad, StorageError>;
fn next(&mut self) -> Option<Result<Quad, StorageError>> { fn next(&mut self) -> Option<Self::Item> {
Some(match self.iter.next()? { Some(match self.iter.next()? {
Ok(quad) => self.reader.decode_quad(&quad), Ok(quad) => self.reader.decode_quad(&quad),
Err(error) => Err(error), Err(error) => Err(error),
@ -1488,7 +1488,7 @@ pub struct GraphNameIter {
impl Iterator for GraphNameIter { impl Iterator for GraphNameIter {
type Item = Result<NamedOrBlankNode, StorageError>; type Item = Result<NamedOrBlankNode, StorageError>;
fn next(&mut self) -> Option<Result<NamedOrBlankNode, StorageError>> { fn next(&mut self) -> Option<Self::Item> {
Some( Some(
self.iter self.iter
.next()? .next()?

4
testsuite/src/manifest.rs
Unescape View File

@ -58,7 +58,7 @@ pub struct TestManifest {
impl Iterator for TestManifest { impl Iterator for TestManifest {
type Item = Result<Test>; type Item = Result<Test>;
fn next(&mut self) -> Option<Result<Test>> { fn next(&mut self) -> Option<Self::Item> {
loop { loop {
if let Some(next) = self.next_test().transpose() { if let Some(next) = self.next_test().transpose() {
return Some(next); return Some(next);
@ -355,7 +355,7 @@ impl<'a> RdfListIterator<'a> {
impl<'a> Iterator for RdfListIterator<'a> { impl<'a> Iterator for RdfListIterator<'a> {
type Item = Term; type Item = Term;
fn next(&mut self) -> Option<Term> { fn next(&mut self) -> Option<Self::Item> {
match self.current_node { match self.current_node {
Some(current) => { Some(current) => {
let result = self let result = self

2
testsuite/src/sparql_evaluator.rs
Unescape View File

@ -727,7 +727,7 @@ impl Drop for StoreRef {
impl Deref for StoreRef { impl Deref for StoreRef {
type Target = Store; type Target = Store;
fn deref(&self) -> &Store { fn deref(&self) -> &Self::Target {
&self.store &self.store
} }
} }

Write Preview
Loading…
Cancel
Save