lucenenet-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (LUCENENET-469) Convert Java Iterator classes to implement IEnumerable<T>
Date Mon, 14 Aug 2017 22:48:00 GMT

    [ https://issues.apache.org/jira/browse/LUCENENET-469?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=16126559#comment-16126559
] 

ASF GitHub Bot commented on LUCENENET-469:
------------------------------------------

GitHub user AndyPook opened a pull request:

    https://github.com/apache/lucenenet/pull/212

    LUCENENET-469 - enumerables

    See https://issues.apache.org/jira/projects/LUCENENET/issues/LUCENENET-469 for background.
    
    This is an early stage proposal for implementing IEnumerable<T> on various "Enum"
types. To enable `foreach` and linq style operators.
    
    This prototype provides `EnumEnumerator<T>` as a helper. It can be used in various
ways to make the implementation of `IEnumerable<T>` more straightforward.
    
    I have modified `IBytesRefIterator` and `TermsEnum` to add `IEnumerable<BytesRef>`
and therefore to all of it's descendants.
    
    The test (such as it is) demonstrates retrieving a `TermsEnum` from a reader. Then using
`foreach` and a simple `.Count()` linq operator.
    
    If this approach is acceptable it ought to be adaptable to other Enum types

You can merge this pull request into a Git repository by running:

    $ git pull https://github.com/AndyPook/lucenenet LUCENENET-469

Alternatively you can review and apply these changes as the patch at:

    https://github.com/apache/lucenenet/pull/212.patch

To close this pull request, make a commit to your master/trunk branch
with (at least) the following in the commit message:

    This closes #212
    
----
commit 008df498bcba7e9940ca97efc83d656ddb03b2c3
Author: Andy Pook <andy.pook@gmail.com>
Date:   2017-08-14T21:32:45Z

    simple editorconfig
    
    ensures spaces for indent

commit 59646be0cf8fbc7e8ad64f395f451a11aca57fc6
Author: Andy Pook <andy.pook@gmail.com>
Date:   2017-08-14T21:34:48Z

    add EnumEnumerator helper

commit 526ddaf8c837f82cd141324e922372155914701b
Author: Andy Pook <andy.pook@gmail.com>
Date:   2017-08-14T21:35:32Z

    add IEnumerable to TermsEnum/IBytesRefArray

commit 456df8e8347ef67055b712722b50cc3b1bbf26cc
Author: Andy Pook <andy.pook@gmail.com>
Date:   2017-08-14T21:36:54Z

    add header, fix usings

commit 1a1c25da7cbcd112d12d6c418c669786cdf4088c
Author: Andy Pook <andy.pook@gmail.com>
Date:   2017-08-14T22:25:15Z

    add example test

----


> Convert Java Iterator classes to implement IEnumerable<T>
> ---------------------------------------------------------
>
>                 Key: LUCENENET-469
>                 URL: https://issues.apache.org/jira/browse/LUCENENET-469
>             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
4.8.0
>         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
(v6.4.14#64029)

Mime
View raw message