lucenenet-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Shad Storhaug (JIRA)" <>
Subject [jira] [Commented] (LUCENENET-469) Convert Java Iterator classes to implement IEnumerable<T>
Date Wed, 09 Aug 2017 17:20:01 GMT


Shad Storhaug commented on LUCENENET-469:

Ahh...I think I now know where we are getting our wires crossed.

You have become a victim of the Java developers' incessant need to abbreviate everything (which
annoys the crap out of me, but unfortunately fixing it is a losing battle). 

Essentially, {{TermsEnum}} == {{IEnumerator<BytesRef>}}, {{TermsEnum}} != {{IEnumerable<BytesRef>}}.
"Enum" could be interpreted as either one, hence the misunderstanding (hell, come to think
of it, it could even be misinterpreted as an enumeration).

So, rather than loading up the {{IEnermerable<BytesRef>}} with all kinds of useful stuff
like LINQ does, our Lucene friends have loaded up a {{IEnumerator<T>}} (or not - they
didn't actually implement Java's analogue to this) with stuff that most {{IEnumerator}} s
don't do. Which of course is leaving us scratching our heads.

So, when disposing {{TermsEnum}}, we are doing the standard {{IEnumerator<T>.Dispose()}}
stuff that the foreach loop does not some funky other relationship.

> Convert Java Iterator classes to implement IEnumerable<T>
> ---------------------------------------------------------
>                 Key: LUCENENET-469
>                 URL:
>             Project: Lucene.Net
>          Issue Type: Sub-task
>          Components: Lucene.Net Contrib, Lucene.Net Core
>    Affects Versions: Lucene.Net 2.9.4, Lucene.Net 2.9.4g, Lucene.Net 3.0.3, Lucene.Net
>         Environment: all
>            Reporter: Christopher Currens
>             Fix For: Lucene.Net 4.8.0
> The Iterator pattern in Java is equivalent to IEnumerable in .NET.  Classes that were
directly ported in Java using the Iterator pattern, cannot be used with Linq or foreach blocks
in .NET.
> {{Next()}} would be equivalent to .NET's {{MoveNext()}}, and in the below case, {{Term()}}
would be as .NET's {{Current}} property.  In cases as below, it will require {{TermEnum}}
to become an abstract class with {{Term}} and {{DocFreq}} properties, which would be returned
from another class or method that implemented {{IEnumerable<TermEnum>}}.
> {noformat} 
> 	public abstract class TermEnum : IDisposable
> 	{
> 		public abstract bool Next();
> 		public abstract Term Term();
> 		public abstract int DocFreq();
> 		public abstract void  Close();
> 	        public abstract void Dispose();
> 	}
> {noformat} 
> would instead look something like:
> {noformat} 
> 	public class TermFreq
> 	{
> 		public abstract Term { get; }
> 		public abstract int { get; }
> 	}
>         public abstract class TermEnum : IEnumerable<TermFreq>, IDisposable
>         {
>                 // ...
>         }
> {noformat}
> Keep in mind that it is important that if the class being converted implements {{IDisposable}},
the class that is enumerating the terms (in this case {{TermEnum}}) should inherit from both
{{IEnumerable<T>}} *and* {{IDisposable}}.  This won't be any change to the user, as
the compiler automatically calls {{IDisposable}} when used in a {{foreach}} loop.

This message was sent by Atlassian JIRA

View raw message