Nabble - GlazedLists - User

BasicEventList's ListEvent has no information

2009-11-03T09:37:19Z

I want to use glazedlists-1.8.0_java15 in my project and I wrote a little
unit test beforehand to play with the API and get to know how it works. In
the test, I'm using a BasicEventList and I register a mock listener. When I
add one element to the list, the listener is called but the resulting
ListEvent has no info. The test is failing in the first assert because
ListEvent.next() method is returning false. Could somebody tell me what I'm
doing wrong? Here is the test code:

package checklist;

import ca.odell.glazedlists.BasicEventList;
import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.event.ListEvent;
import ca.odell.glazedlists.event.ListEventListener;
import org.junit.Test;
import static org.junit.Assert.*;

public class BasicEventListTest {

@Test
public void addElement() {
EventList<String> eventList = new BasicEventList<String>();
MockListEventListener<String> listener = new
MockListEventListener<String>();
eventList.addListEventListener(listener);

eventList.add("hello");
assertEquals(1, listener.callCount);
assertTrue("true expected", listener.event.next());
assertEquals(ListEvent.INSERT, listener.event.getType());
assertEquals(0, listener.event.getIndex());
}

private static class MockListEventListener<E> implements
ListEventListener<E> {
int callCount;
ListEvent<E> event;

public void listChanged(ListEvent<E> listChanges) {
callCount++;
event = listChanges;
}
}
}

Many thanks,
--
View this message in context: http://old.nabble.com/BasicEventList%27s-ListEvent-has-no-information-tp26160593p26160593.html
Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

BasicEventList's ListEvent has no information

2009-11-03T09:36:30Z

I want to use glazedlists-1.8.0_java15 in my project and I wrote a little
unit test beforehand to play with the API and get to know how it works. In
the test, I'm using a BasicEventList and I register a mock listener. When I
add one element to the list, the listener is called but the resulting
ListEvent has no info. The test is failing in the first assert because
ListEvent.next() method is returning false. Could somebody tell me what I'm
doing wrong? Here is the test code:

package checklist;

import ca.odell.glazedlists.BasicEventList;
import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.event.ListEvent;
import ca.odell.glazedlists.event.ListEventListener;
import org.junit.Test;
import static org.junit.Assert.*;

public class BasicEventListTest {

@Test
public void addElement() {
EventList<String> eventList = new BasicEventList<String>();
MockListEventListener<String> listener = new
MockListEventListener<String>();
eventList.addListEventListener(listener);

eventList.add("hello");
assertEquals(1, listener.callCount);
assertTrue("true expected", listener.event.next());
assertEquals(ListEvent.INSERT, listener.event.getType());
assertEquals(0, listener.event.getIndex());
}

private static class MockListEventListener<E> implements
ListEventListener<E> {
int callCount;
ListEvent<E> event;

public void listChanged(ListEvent<E> listChanges) {
callCount++;
event = listChanges;
}
}
}

Many thanks,
--
View this message in context: http://old.nabble.com/BasicEventList%27s-ListEvent-has-no-information-tp26160591p26160591.html
Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-03T07:44:07Z

Hi,
Thanks a lot for your valuable help.
I'm really happy to find this source code because it's useful for my work.
All my best regards and good luck.
God bless.

Ok, here's a running example.

http://github.com/fab1an/gl-addons/blob/master/src/at/busta/glazedlists/test/swt/EventTableViewerDemo.java

you can checkout the whole repo or just this file to build it.

It shows:
* population of Table via a background thread
* locking which is needed in this case
* "filtering via Buttons"
* filtering by a Text-input
* sorting of the table
* selection

HTH
fabian

Hi,
Thank you for the replay, but the example is still incomplete (for me as a beginner in the GlazedList API).
All that I need is a clear snippet where an SWT table is created and populated and then the sort and filter feature is added.
Thanks in advance and good luck.

fab|an wrote:

Hi,

here's something I quickly copy'n'pasted together: http://gist.github.com/224365

HTH
fabian

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-03T07:41:49Z

fab|an wrote:

Hi,

here's something I quickly copy'n'pasted together: http://gist.github.com/224365

HTH
fabian

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-03T06:13:37Z

Ok, here's a running example.

http://github.com/fab1an/gl-addons/blob/master/src/at/busta/glazedlists/test/swt/EventTableViewerDemo.java

you can checkout the whole repo or just this file to build it.

It shows:
* population of Table via a background thread
* locking which is needed in this case
* "filtering via Buttons"
* filtering by a Text-input
* sorting of the table
* selection

HTH
fabian

Hi,
Thank you for the replay, but the example is still incomplete (for me as a beginner in the GlazedList API).
All that I need is a clear snippet where an SWT table is created and populated and then the sort and filter feature is added.
Thanks in advance and good luck.

fab|an wrote:

Hi,

here's something I quickly copy'n'pasted together: http://gist.github.com/224365

HTH
fabian

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-03T00:13:37Z

Hi,
Thank you for the replay, but the example is still incomplete (for me as a beginner in the GlazedList API).
All that I need is a clear snippet where an SWT table is created and populated and then the sort and filter feature is added.
Thanks in advance and good luck.

Hi,

here's something I quickly copy'n'pasted together: http://gist.github.com/224365

HTH
fabian

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-03T00:08:03Z

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Re: Request for an SWT Glazedlists "gentil" tutorial

2009-11-02T11:21:04Z

Hi,

here's something I quickly copy'n'pasted together: http://gist.github.com/224365

HTH
fabian

Oceanys wrote:

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

Request for an SWT Glazedlists "gentil" tutorial

2009-11-02T10:54:33Z

Hi, I'm new to the good GlazedLists API and I'm using SWT tables.

I was happy when I found the GlazedLists API. I have a problem with SWT GlazedLists integration because the majority of the available tutorials are written for Swing or for other SWT widgets (I mean the pixel example in the link
http://hexapixel.com/2009/01/02/glazed-lists-swt-tables-true).

Is anyone have a simple source code or snippet to start with a simple SWT table and Glazed lists in order to show how we can sort and filter it.
Thanks in advance and cordially.

GoogleWave invitation

2009-10-30T11:19:27Z

Hi,

sorry if you consider this mail spam, but has anyone access to GW yet? I'm interested but didn't get an invitation.

fabian

re[3]: SequenceList

2009-10-18T20:46:43Z

The use case here is fairly common (we do something similar frequently) - but I think the suggested solution is sufficient for the bulk of cases. It would be *much* more useful to have access to the deleted element in delete events (this would allow effective caching of computed values).

- K

----------------------- Original Message -----------------------

From: cocoa cocoa@...

To: users@...

Cc:

Date: Mon, 12 Oct 2009 13:47:10 -0700 (PDT)

Subject: Re: re: SequenceList

> The SequenceList problem you mention is a legit bug in my opinion. Would
> you mind filing a bug in our bugtracker?
>

I've filed a bug, see
https://glazedlists.dev.java.net/issues/show_bug.cgi?id=482
https://glazedlists.dev.java.net/issues/show_bug.cgi?id=482 . A bug
attachment contains a failing unit test.

> As for the approach to your problem (inserting sequence placeholders into
> a list), that's something that isn't trivial to do with our existing
> transformations. If I was in your shoes, I'd consider extending
> TransformedList and implementing that transformation myself from the
> ground up. It actually shouldn't be that hard to implement, overall.
>

Implementing my own TransformedList seems daunting :S. I've had a quick look
at some TransformedList implementations. The current solution with the
CompositeList seems to work so far. As long as it works I abstain from
implementing any TransformedList ;). Unless somebody is willing to help me
get up to speed with all those internal details of glazed lists.

> We probably could dream up some type of transformation in the core that,
> given two adjacent items in the source EventList, delegated to a Sequencer
> type of object that filled in the gaps... I'm unsure of how useful that is
> to our general audience.
>

My use case is to generate a report that shows the total time (or distance)
of activities grouped by a time period (e.g. week, month, ...). Obviously,
it is possible that some period does not contain any activity. So, the
bucket is missing in the GroupingList, which is not acceptable. The missing
bucket is important information by itself (i.e. the user did not perform any
sport activity).
--
View this message in context: http://www.nabble.com/SequenceList-tp25838609p25862874.html
Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

--------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@... For additional commands, e-mail: users-help@...

TreeList help

2009-10-13T02:49:13Z

Hi to all,

I'm using TreeList with JTree.

Its seems like there is no support for ExpansionModel in JTree.

my questions are

1) Am i right?

2) What UI componet has a support for this feature? (maybe TreeTable)

thanks,

Gal.

Re: re: SequenceList

2009-10-12T13:47:08Z

The SequenceList problem you mention is a legit bug in my opinion. Would you mind filing a bug in our bugtracker?

I've filed a bug, see https://glazedlists.dev.java.net/issues/show_bug.cgi?id=482. A bug attachment contains a failing unit test.

As for the approach to your problem (inserting sequence placeholders into a list), that's something that isn't trivial to do with our existing transformations. If I was in your shoes, I'd consider extending TransformedList and implementing that transformation myself from the ground up. It actually shouldn't be that hard to implement, overall.

Implementing my own TransformedList seems daunting :S. I've had a quick look at some TransformedList implementations. The current solution with the CompositeList seems to work so far. As long as it works I abstain from implementing any TransformedList ;). Unless somebody is willing to help me get up to speed with all those internal details of glazed lists.

We probably could dream up some type of transformation in the core that, given two adjacent items in the source EventList, delegated to a Sequencer type of object that filled in the gaps... I'm unsure of how useful that is to our general audience.

My use case is to generate a report that shows the total time (or distance) of activities grouped by a time period (e.g. week, month, ...). Obviously, it is possible that some period does not contain any activity. So, the bucket is missing in the GroupingList, which is not acceptable. The missing bucket is important information by itself (i.e. the user did not perform any sport activity).

Re: re: SequenceList

2009-10-12T09:29:28Z

Simon,

The SequenceList problem you mention is a legit bug in my opinion. Would you mind filing a bug in our bugtracker?

As for the approach to your problem (inserting sequence placeholders into a list), that's something that isn't trivial to do with our existing transformations. If I was in your shoes, I'd consider extending TransformedList and implementing that transformation myself from the ground up. It actually shouldn't be that hard to implement, overall.

We probably could dream up some type of transformation in the core that, given two adjacent items in the source EventList, delegated to a Sequencer type of object that filled in the gaps... I'm unsure of how useful that is to our general audience.

Good Luck,

James

On Sun, Oct 11, 2009 at 3:02 PM, cocoa <cocoa@...> wrote:

I soon saw that my initial approach does not work. The map, as you mentioned,
is not updated so the approach is broken. Next I've tried the proposed
approach using a CompositeList.

The first list is a SequenceList that produces PlaceholderActivity objects
with a Sequencer. However, I've run into an issue with the SequenceList. It
adds the source Activity objects to the SequenceList (not the placeholder
activity objects). This results in incorrect duration totals (i.e. the first
one is twice as large as it should be). So I've added a
FunctionList<Activity, PlaceholderActivity> to the source list. That way, I
get the expected sequence lists consisting only of PlaceholderActivity.

The CompositeList stuff works as advertised. I get the missing buckets with
a 0 total duration.

Simon

PS: I'm not groking why the first value of the SequenceList is duplicated.
It does not hurt in my case, because placeholder activities are not used for
the calculations. Below is a simple snipped that shows what I mean:

EventList<Integer> src = new BasicEventList<Integer>();
src.add(1);
src.add(3);

SequenceList<Integer> integers = new SequenceList<Integer>(src, new
Sequencer<Integer>() {
public Integer next(Integer value) {
return value + 1;
}
public Integer previous(Integer value) {
return value - 1;
}
});

for (Integer value : integers) {
System.out.println(value);
}

Output is :
1
1
2
3

--
View this message in context: http://www.nabble.com/SequenceList-tp25838609p25848064.html

Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Re: re: SequenceList

2009-10-11T15:01:59Z

I soon saw that my initial approach does not work. The map, as you mentioned, is not updated so the approach is broken. Next I've tried the proposed approach using a CompositeList.

The first list is a SequenceList that produces PlaceholderActivity objects with a Sequencer. However, I've run into an issue with the SequenceList. It adds the source Activity objects to the SequenceList (not the placeholder activity objects). This results in incorrect duration totals (i.e. the first one is twice as large as it should be). So I've added a FunctionList<Activity, PlaceholderActivity> to the source list. That way, I get the expected sequence lists consisting only of PlaceholderActivity.

The CompositeList stuff works as advertised. I get the missing buckets with a 0 total duration.

Simon

PS: I'm not groking why the first value of the SequenceList is duplicated. It does not hurt in my case, because placeholder activities are not used for the calculations. Below is a simple snipped that shows what I mean:

EventList<Integer> src = new BasicEventList<Integer>();
src.add(1);
src.add(3);

SequenceList<Integer> integers = new SequenceList<Integer>(src, new Sequencer<Integer>() {
public Integer next(Integer value) {
return value + 1;
}
public Integer previous(Integer value) {
return value - 1;
}
});

for (Integer value : integers) {
System.out.println(value);
}

Output is :
1
1
2
3

re: SequenceList

2009-10-10T21:08:50Z

I think you may run into some problems with this approach - the map is not a live map. Be sure to test the following scenario:

1. Initial condition is a setup that is missing data in week3

2. Add an element for week 3 - did the summary get re-constructed?

Repeat, but instead of adding an element for week 3, change an existing element so that it now resides in week 3. Same test.

There is a lot of nastiness with event publication and dependant listeners that you have to deal with when you introduce a map that is driving another list's behavior. It *can* be done, but the opportunity for error and odd little corner cases (that are really hard to debug) is very high.

Another approach to this problem that doesn't use maps would be to construct a list of dummy PlaceHolderActivity objects - these will not get added to your totals if they appear in a list that a summary operates against. Create one PlaceHolderActivity for each bucket you want to appear in the output (so if you are doing 52 weeks, you'd have 52). Now, composite this list with the source list using CompositeList, then pipe it into your grouping list.

Also, it will simplify things if you make the EventList<PlaceHolderActivity> be a SequenceList built from the source list. Cool, eh?

placeHolders = new SequenceList<Activity>(source, sequencer); // sequencer returns a sub-class of Activity - PlaceHolderActivity

composite = new CompositeList<Activity>(source.getPubliser(), source.getReadWriteLock());

composite.addMemberList(source);

composite.addMemberList(placeHolders);

grouped = new GroupingList<Activity>(composite);

// then comes a function list whose function calculates the summaries
FunctionList<List<Activity>, SummaryRecord> summaries = ...; // function ignores list entries that are PlaceHolderActivities

summaries now contains the list that you want, including the 'missing' buckets, and you don't have the messy event publisher stuff from the map to deal with.

- K

----------------------- Original Message -----------------------

From: cocoa cocoa@...

To: users@...

Cc:

Date: Sat, 10 Oct 2009 15:51:53 -0700 (PDT)

Subject: SequenceList

In my application a list of sport activities can be tracked and analyzed. I
want to provide a summary view that shows the total time or distance of all
activities within a certain time period (e.g. week) over some time (e.g. the
last year). Below is the basic list setup I use.

// list of activities
EventList<Activity> source = ...;

// observe property change events
EventList<Activity> observed = new ObservableElementList(source, ...);

// group the activities by time period, e.g. per week
GroupingList<Activity> grouped = new
GroupingList<Activity>(observedElementList, ...);

// then comes a function list whose function calculates the summaries
FunctionList<List<Activity>, SummaryRecord> summaries = ...;

As GroupingList does not return any empty groups, it happens that the
summaries contains gaps, i.e. time periods for which no group exists. Then I
stumbled upon the SequenceList, which I thought might be of some help. First
I had some problems with the sequencer implementation (the summaries after
the first element where lost). But here is with what I came up with.

// first create a map that maps a time period to the list of summaries
DisposableMap<Week, List<SummaryRecord>> map =
GlazedLists.syncEventListToMultiMap(summaries, keyMaker());

// then pass this map to the sequencer implementation
SequenceList<SummaryRecord> sequence = new
SequenceList<SummaryRecord>(summaries, new RecordSequencer(map));

The sequencer uses the map to implement next and previous so that if there
is already a SummaryRecord for a time period then that SummaryRecord is
returned (otherwise, an empty SummaryRecord). See the implementation of
next().

public Record next(SummaryRecord value) {
 Week week = value.week.next();
 List<SummaryRecord> existing = map.get(week);
 return existing != null ? existing.get(0) : new SummaryRecord(week, 0);
}

So far, this seems to work. I am just wondering whether there is a simpler
way to achieve the same thing. I'm sure others have done this kind of
reporting over a data set. There is also precious few documentation for
SequenceList, so I'm not sure that this is a supported way of using it
(especially the Sequencer implementation).

Any suggestions?
Simon

PS: SequenceList seems to have a bug if the earliest source value is a
sequence value. In that case, the earliest sequence value is duplicated in
the result list (can easily be shown with month sequencer).

PS: glazedlists is amazing :clap:
--
View this message in context: http://www.nabble.com/SequenceList-tp25838609p25838609.html
Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

--------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@... For additional commands, e-mail: users-help@...

SequenceList

2009-10-10T15:51:50Z

In my application a list of sport activities can be tracked and analyzed. I want to provide a summary view that shows the total time or distance of all activities within a certain time period (e.g. week) over some time (e.g. the last year). Below is the basic list setup I use.

// list of activities
EventList<Activity> source = ...;

// observe property change events
EventList<Activity> observed = new ObservableElementList(source, ...);

// group the activities by time period, e.g. per week
GroupingList<Activity> grouped = new GroupingList<Activity>(observedElementList, ...);

// then comes a function list whose function calculates the summaries
FunctionList<List<Activity>, SummaryRecord> summaries = ...;

As GroupingList does not return any empty groups, it happens that the summaries contains gaps, i.e. time periods for which no group exists. Then I stumbled upon the SequenceList, which I thought might be of some help. First I had some problems with the sequencer implementation (the summaries after the first element where lost). But here is with what I came up with.

// first create a map that maps a time period to the list of summaries
DisposableMap<Week, List<SummaryRecord>> map = GlazedLists.syncEventListToMultiMap(summaries, keyMaker());

// then pass this map to the sequencer implementation
SequenceList<SummaryRecord> sequence = new SequenceList<SummaryRecord>(summaries, new RecordSequencer(map));

The sequencer uses the map to implement next and previous so that if there is already a SummaryRecord for a time period then that SummaryRecord is returned (otherwise, an empty SummaryRecord). See the implementation of next().

public Record next(SummaryRecord value) {
Week week = value.week.next();
List<SummaryRecord> existing = map.get(week);
return existing != null ? existing.get(0) : new SummaryRecord(week, 0);
}

So far, this seems to work. I am just wondering whether there is a simpler way to achieve the same thing. I'm sure others have done this kind of reporting over a data set. There is also precious few documentation for SequenceList, so I'm not sure that this is a supported way of using it (especially the Sequencer implementation).

Any suggestions?
Simon

PS: SequenceList seems to have a bug if the earliest source value is a sequence value. In that case, the earliest sequence value is duplicated in the result list (can easily be shown with month sequencer).

PS: glazedlists is amazing

Re: gl-addons

2009-10-06T10:29:01Z

Forgot, the link: http://github.com/fab1an/gl-addons

fab|an wrote:

I have a nice little repository with stuff i wrote for glazedlists.
May it be of use for anyone.

EventTreeViewer
SWT Viewer for TreeList. Works for me, but lacks VIRTUAL support.
I need comments on http://www.nabble.com/2-TreeList-bugs--td24557579.html though...

Set/ClassSetMatcherEditor
MatcherEditor which tests an (function-)extracted enum property against a set of provided enums. I found that I could generalize much filter-scenarios this way.

Bug in ThresholdMatcherEditor

2009-10-05T14:44:18Z

Hi all

ThresholdMatcherEditor extends from AbstractMatcherEditor.
Both the classes have a variable named 'currentMatcher'.

ThresholdMatcherEditor sets its private variable 'currentMatcher' which is not propagated to super.
Also it does not override the getMatcher() method, hence the variable from AbstractMatcherEditor gets picked up. This is incorrect.

Small but caused my CompositeMatcher to behave erratically.

Baljeet

gl-addons

2009-10-05T12:35:20Z

I have a nice little repository with stuff i wrote for glazedlists.
May it be of use for anyone.

EventTreeViewer
SWT Viewer for TreeList. Works for me, but lacks VIRTUAL support.
I need comments on http://www.nabble.com/2-TreeList-bugs--td24557579.html though...

Set/ClassSetMatcherEditor
MatcherEditor which tests an (function-)extracted enum property against a set of provided enums. I found that I could generalize much filter-scenarios this way.

Re: Updates off the Swing EDT

2009-09-28T09:37:29Z

Richard,

   Your 3 points are all spot-on. If you can achieve immutability with your elements, I think that produces the sexiest result, but of course you'll need to consider code already written.

   One note of caution: ThreadSafeList is fine for single-method interactions with an EventList, but keep in mind that you must still manually lock and unlock the list for larger units of atomicity. For example:

Object firstElement = null;
if (!myEventList.isEmpty())
   firstElement = myEventList.get(0);

isn't concurrently correct, even if myEventList is a ThreadSafeList, since the lock of the list pipeline is unlocked between the calls to isEmpty() and get(). So, this should really be written as:

Object firstElement = null;
myEventList.getReadWriteLock().lock();
try {
if (!myEventList.isEmpty())
   firstElement = myEventList.get(0);
} finally {
myEventList.getReadWriteLock().unlock();
}

Keep on Glazin' in the free world,

James

On Mon, Sep 28, 2009 at 7:30 AM, Richard <numberoneskier@...> wrote:

Hi Gerrit,

thanks for your response, it does help because it made me aware of FunctionList
and confirmed my suspicion that 'something else' needs to be done.

Cloning is OK for most of my use cases, but i've got one case where i've got in
the order of 10-15 thousand items in the list and the user has multiple
views over those items... not sure if i want to clone all that multiple times!
Luckily in this case i control the entire code so i might make things immutable
so updates are really forced to be replacements which should make the race
conditions go away.

Anyway, putting aside specific cases, i'd like to confirm my general
understanding of the situation:

(1) if you have a mutable list (insertions/deletions) then wrapping it in
ThreadSafeList and using EventTableModel is enough to satisfy Swings EDT rules
even if the mutations to the list are happening OFF the EDT.

(2) if you have mutable items in the list and the items are being mutated ON
the EDT then you can contain them in an ObservableElementList, wrap that in a
ThreadSafeList and use EventTableModel, you will be safe (allows the list to be
changed off EDT, but items must be changed on EDT).

(3) if you have mutable items in the list and the items are being mutated OFF
the EDT then this will cause race conditions in JTable painting unless you do
'something else', such as cloning, or... actually i can't think of anything
else!?!

Would that be a fair synopsis?

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Re: Updates off the Swing EDT

2009-09-28T07:30:01Z

Hi Gerrit,

thanks for your response, it does help because it made me aware of FunctionList
and confirmed my suspicion that 'something else' needs to be done.

Cloning is OK for most of my use cases, but i've got one case where i've got in
the order of 10-15 thousand items in the list and the user has multiple
views over those items... not sure if i want to clone all that multiple times!
Luckily in this case i control the entire code so i might make things immutable
so updates are really forced to be replacements which should make the race
conditions go away.

Anyway, putting aside specific cases, i'd like to confirm my general
understanding of the situation:

(1) if you have a mutable list (insertions/deletions) then wrapping it in
ThreadSafeList and using EventTableModel is enough to satisfy Swings EDT rules
even if the mutations to the list are happening OFF the EDT.

(2) if you have mutable items in the list and the items are being mutated ON
the EDT then you can contain them in an ObservableElementList, wrap that in a
ThreadSafeList and use EventTableModel, you will be safe (allows the list to be
changed off EDT, but items must be changed on EDT).

(3) if you have mutable items in the list and the items are being mutated OFF
the EDT then this will cause race conditions in JTable painting unless you do
'something else', such as cloning, or... actually i can't think of anything
else!?!

Would that be a fair synopsis?

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Re: Updates off the Swing EDT

2009-09-27T01:21:08Z

Hello Richard,

First of all I think the logical easy approach would be to "cache" your
Things in a consistent state in the event list chain close to the gui.
you could use a FunctionList for that which use a "cloning" function,
hence when an update to list is performed the functionlist clones the
"update" and your GUI will be consistent. If you want automatic updates
to the list happening when your Things change then you can insert an
ObservableElementList before the FunctionList, supposing that your
Things send property change events using the PropertyChangelistener, you
can use the BeanConnector to link the changes of properties within the
observable element list, or if the use the java.util.Observable pattern
there is also a connector for that, if neither is the case you have to
come up with a connector of your own...

Hope this helps,

Gerrit

Richard wrote:

> Hi,
>
> first-up:
> i've just discovered glazed lists and am wetting my pets at the excellent
> prospect of replacing lots of my hand-crafted junk code with this stuff.
> Thank you and congrats on a great project. Awesome work!
>
> question:
> I've got a list of Thing's that can be updated OFF the swing EDT.
> i can see how the combination of ThreadSafeList and SwingThreadProxyEventList
> means that updates to the list (insertions, removals) get applied to the
> EventTableModel in such a way as to keep swing happy (glazed lists makes
> changes happen ON the EDT).
>
> Unfortunately, the Thing's themselves can be updated OFF the EDT, and i worry
> about inconsistencies in table painting. For example, while painting the cells
> in a row the underlying Thing might have a field value change which could cause
> inconsistency in the visual appearance of the row, or worse.
>
> Does GlazedLists help me out in this scenario, or do i have to do something
> extra?
>
> Trying to get the hang of it, and liking it so far!
> Thanks...
> - Richard.
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: users-unsubscribe@...
> For additional commands, e-mail: users-help@...
>
>

--
-------------------- Marble Consulting ----------------------
Gerrit Cap http://www.marble.be/
OO Solutions Engineer mailto:Gerrit.Cap@...
Marble Consulting gsm : +32 475 72.94.36
Vinkenbosstraat 13 tel : +32 16 89.50.55
B-3001 Heverlee fax : +32 16 89.50.58

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Updates off the Swing EDT

2009-09-26T23:14:47Z

Hi,

first-up:
i've just discovered glazed lists and am wetting my pets at the excellent
prospect of replacing lots of my hand-crafted junk code with this stuff.
Thank you and congrats on a great project. Awesome work!

question:
I've got a list of Thing's that can be updated OFF the swing EDT.
i can see how the combination of ThreadSafeList and SwingThreadProxyEventList
means that updates to the list (insertions, removals) get applied to the
EventTableModel in such a way as to keep swing happy (glazed lists makes
changes happen ON the EDT).

Unfortunately, the Thing's themselves can be updated OFF the EDT, and i worry
about inconsistencies in table painting. For example, while painting the cells
in a row the underlying Thing might have a field value change which could cause
inconsistency in the visual appearance of the row, or worse.

Does GlazedLists help me out in this scenario, or do i have to do something
extra?

Trying to get the hang of it, and liking it so far!
Thanks...
- Richard.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

JTable within JScrollPane not refreshing

2009-09-25T11:22:10Z

I am using a SortedList and FilteredList to display my EventList in a JTable contained within a JScrollPane.

The problem I am having is that when I filter out rows when the scroll bar is not shown, only the first row is removed. If I try selecting one of the rows, it acts like it's not there. If I minimize the frame and restore it, the rows disappear.

The first image here is what is in the list. Note: I am only showing the Info log messages because there are only 7 of those and the vertical scrollbar is not shown.

Then, when I filter out the Info log messages, I'd expect nothing to show. Instead, I get this:

Finally, if I minimize and restore the window, the JScrollPane/JTable refresh and the rows disappear as expected.

Any ideas what is causing this?

Thanks.

Re: re[2]: How to sort rows by a column through code?

2009-09-23T13:02:54Z

Hi,

there are basically two ways to integrate Glazed Lists sorting with JXTable
as outlined here;
http://sites.google.com/site/glazedlists/documentation/swingx

1.) using EventListJXTableSorting

with this approach, you could set your initial comparator on the SortedList.
But this doesn't work because of bug
https://glazedlists.dev.java.net/issues/show_bug.cgi?id=479
You could try the latest build, which has an additional install-method
EventListJXTableSorting#install(JXTable, SortedList, Comparator)
which allows to pass in the initial comparator to use.

2.) using TableComparatorChooser

with this approach, you have the option to set the comparator via
AbstractTableComparatorChooser.appendComparator(...)

If you use multi-column sort, you may have to call
AbstractTableComparatorChooser.clearComparator() first,
to clear other comparators.

Hope this helps,
Holger

>
> Thanks for the help but I had gone through the GL tutorial long before I
> posted the thread.
> It hadn't helped me a bit.
>
> Now, I believe I have kind of found a solution for now by providing a
> comparator which uses values in 1st column. And by commenting out the
> following line :
> //ca.odell.glazedlists.swing.EventListJXTableSorting.install(jXTable1,sortedList);
>
> I am just hoping this won't break something else.
> If at all there are any developments in this regard I expect someone will
> write a line or two about it here.
>
> Thanks.
>
> Kevin Day wrote:
> >
> >
> >
> >
> >
> >
> >
> > This should get you started:
> >
> > http://sites.google.com/site/glazedlists/documentation/tutorial
> >
> >
> > Be sure to understand that the sorting GL occurs in the list pipeline
> > itself - not in the table model.
> >
> > There are some specifics about using GL with JXTable (I don't have them
> > handy, but you might want to search the GL site or listserv archives for
> > 'JXTable' and see what you find).
> >
> > - K
> >
> >
> > ----------------------- Original Message -----------------------
> >
> > From: kaprasi <kaprasannagt@...>
> > To: users@...
> > Cc:
> > Date: Thu, 17 Sep 2009 03:28:34 -0700 (PDT)
> > Subject: Re: How to sort rows by a column through code?
> >
> > Any replies please... All I want to do is sort the jxtable by a particular
> > column through code before user gets to see the table. Anticipating some
> > response. Thanks. -- View this message in context:
> > http://www.nabble.com/How-to-sort-rows-by-a-column-through-code--tp25454154p25488718.html
> > Sent from the GlazedLists - User mailing list archive at Nabble.com.
> > --------------------------------------------------------------------- To
> > unsubscribe, e-mail: users-unsubscribe@... For
> > additional commands, e-mail: users-help@...
> >
> >
> > ---------------------------------------------------------------------
> > To unsubscribe, e-mail: users-unsubscribe@...
> > For additional commands, e-mail: users-help@...
> >
> >
> >
>
> --
> View this message in context: http://www.nabble.com/How-to-sort-rows-by-a-column-through-code--tp25454154p25505743.html
> Sent from the GlazedLists - User mailing list archive at Nabble.com.
>
>
> ---------------------------------------------------------------------
> To unsubscribe, e-mail: users-unsubscribe@...
> For additional commands, e-mail: users-help@...
>
>

________________________________________________________________
Neu: WEB.DE Doppel-FLAT mit Internet-Flatrate + Telefon-Flatrate
für nur 19,99 Euro/mtl.!* http://produkte.web.de/go/02/

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Misleading GroupingList documentation

2009-09-23T05:51:32Z

Hi,

I was tricked by GroupingList documentation.
Maybe it could be improved.

It only says that "elements for which the Comparator returns 0 are
guaranteed to be contained within the same group within this
GroupingList".

My comparator implementation returned 0 for similar elements and 1 otherwise.
But in fact I think there must be a proper ordering of all elements,
because if there is an element in between two similar elements, those
two elements are not grouped.

Danilo

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

Re: re[2]: How to sort rows by a column through code?

2009-09-18T02:31:04Z

Thanks for the help but I had gone through the GL tutorial long before I posted the thread.
It hadn't helped me a bit.

Now, I believe I have kind of found a solution for now by providing a comparator which uses values in 1st column. And by commenting out the following line :
//ca.odell.glazedlists.swing.EventListJXTableSorting.install(jXTable1,sortedList);

I am just hoping this won't break something else.
If at all there are any developments in this regard I expect someone will write a line or two about it here.

Thanks.

Kevin Day wrote:

This should get you started:

http://sites.google.com/site/glazedlists/documentation/tutorial

Be sure to understand that the sorting GL occurs in the list pipeline itself - not in the table model.

There are some specifics about using GL with JXTable (I don't have them handy, but you might want to search the GL site or listserv archives for 'JXTable' and see what you find).

- K

----------------------- Original Message -----------------------

From: kaprasi <kaprasannagt@gmail.com>
To: users@glazedlists.dev.java.net
Cc:
Date: Thu, 17 Sep 2009 03:28:34 -0700 (PDT)
Subject: Re: How to sort rows by a column through code?

Any replies please... All I want to do is sort the jxtable by a particular column through code before user gets to see the table. Anticipating some response. Thanks. -- View this message in context: http://www.nabble.com/How-to-sort-rows-by-a-column-through-code--tp25454154p25488718.html Sent from the GlazedLists - User mailing list archive at Nabble.com. --------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@glazedlists.dev.java.net For additional commands, e-mail: users-help@glazedlists.dev.java.net

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@glazedlists.dev.java.net
For additional commands, e-mail: users-help@glazedlists.dev.java.net

re[2]: How to sort rows by a column through code?

2009-09-17T08:56:18Z

This should get you started:

http://sites.google.com/site/glazedlists/documentation/tutorial

Be sure to understand that the sorting GL occurs in the list pipeline itself - not in the table model.

There are some specifics about using GL with JXTable (I don't have them handy, but you might want to search the GL site or listserv archives for 'JXTable' and see what you find).

- K

----------------------- Original Message -----------------------

From: kaprasi kaprasannagt@...

To: users@...

Cc:

Date: Thu, 17 Sep 2009 03:28:34 -0700 (PDT)

Subject: Re: How to sort rows by a column through code?

Any replies please...
All I want to do is sort the jxtable by a particular column through code
before user gets to see the table.

Anticipating some response.
Thanks.
--
View this message in context: http://www.nabble.com/How-to-sort-rows-by-a-column-through-code--tp25454154p25488718.html
Sent from the GlazedLists - User mailing list archive at Nabble.com.

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...

--------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@... For additional commands, e-mail: users-help@...

Re: How to sort rows by a column through code?

2009-09-17T03:28:33Z

Any replies please...
All I want to do is sort the jxtable by a particular column through code before user gets to see the table.

Anticipating some response.
Thanks.

Re: re[4]: WeakReferenceProxy

2009-09-16T01:30:31Z

On Sun, Sep 13, 2009 at 21:23, Kevin Day <kevin@...> wrote:

I was especially inerested in this diagram:

BL . P -w> SL . P -w> FL . P -w> WL . P -w> Calc

<s-+ <s-+ <s-+ <s-+

| | | |

Publisher ------+----------+----------/

which implies that the downstream list doesn't technically have to hold a reference to it's source at all... This would further imply that it would be possible to create an EventList implementation that would implement the proxy behavior (instead of the *listener* being the weak reference, the list itself would behave as a weak reference to it's source). I think that this is similar to what you are currently doing with your shim lists, right? Are there advantages to this approach, vs having the downstream list hold a hard reference to the source, and only using weak references for the listeners? It would seem that there would be some modest performance advantages to holding the hard reference - as long as there is no need to detect the need to call dispose()...

I found this hard to read - what do you mean by the first and second period?

I've made two rounds of shims, where the first use finalize(), while the second use WeakReference

I will drop the first type, instead focusing on the latter. This because finalizer is very bad for GC - the References with ReferenceQueue gives pretty much the same behaviour, is more flexible, and doesn't force the GC to make two rounds for any object "implementing" it.

NB: Note that if you "loose" a Reference, that is, that the WeakReference itself isn't any longer referenced, it will not upon garbage collection be enqueued to the ReferenceQueue as one might expect. So, only when you actually get a "tearing" of the referent, that is, the referent is nulled WHILE the Reference itself still is referenced, will you get notified through the ReferenceQueue. If the Reference is not referenced anymore, and is GC'ed while the referent isn't, or both the Reference and the referent is taken out on the same GC cycle, no one will notice! This isn't necessarily that obvious when you work with them, so watch out - or you'll loose the entire point. Object.finalize() does NOT behave as such, as any object implementing finalize() will itself be notified about impending garbage collection.

What I do now, is that I just have a flag indicating whether dispose has been invoked, and if not, upon handling through the ReferenceQueue, I dispose it, and log a hefty warning along with the "Instantiation Stacktrace" which is stored on construction (typically if log.isDebugEnabled()). It is thus meant to catch errors, not as a fixer.

Currently, I believe the dispose() should be recursive. (I have re-implemented several EventLists to let dispose be recursive, as they as mentioned earlier are final and/or have private internals where I needed to override dispose functionality)

If one at some level doesn't want such recursion, one could wrap this with a DisposeDontRecurseList.

I also think that it should be possible to register any WeakReferenceProxy with a ReferenceQueue. As I haven't thought of any better solutions, a suggestion is that GlazedLists has a static method whereby such a ReferenceQueue could be set statically. It could be held weakly.

PS: Nice to know that I am not totally alone with these problems, Kevin! :-)

Kind regards,

Endre.

How to sort rows by a column through code?

2009-09-15T06:34:32Z

Hi all,

I am supposed to add some more to the existing code that makes use of GL and JXTable.
I must say they are like, made for each other.

When user double clicks on a column-header the rows in the table get sorted in ascending / descending order. And when user (single) clicks on a column header the rows of that column are sorted.
Everything works just great.

Now, all I need to do is sort the rows in the table by first column (as the primary sort) and then by the second column (as the secondary sort) through code before user gets to see the table. (Default sorting to serve the user better..)

So I believe I have to use some sort keys or something like this :
http://java.sun.com/docs/books/tutorial/uiswing/components/table.html#sorting ?
I also searched nabble for some solutions and stumbled upon the following thread :
http://www.nabble.com/EventListJXTableSorting-td11801610.html#a23574421

I was hoping this would be straight forward and easy.. But haven't found a solution yet..
I'd really appreciate if someone could provide me with some hints / solution or point me to the right direction.

Thanks.

Re: Odd behavior with CollectionList

2009-09-14T15:11:08Z

Also check out: http://www.nabble.com/List-Pipelines%2C-Concurrent-Events%2C-listChanged...-and-ObservableList-td24421891.html . We had a similar kind of issue (although changing the list type wasn't an option, so I didn't try it). Maybe all problems come from the same cause?

Sam

2009/9/14 Endre Stølsvik <java@...>

Check out this message. You /might/ be having a similar problem. I don't know the reason for the difference I mention.
http://www.nabble.com/forum/ViewPost.jtp?post=23227027&framed=y

Endre.

On Fri, Sep 11, 2009 at 17:26, Jeremy Ford <caius1@...> wrote:

I am seeing an issue when using CollectionList. I have a very complicated hierarchy of EventLists. I am attempting to insert in the middle a CollectionList which translates a pojo A into one or more A pojos based on certain criteria. After adding the CollectionList, it seems like I no longer receive list events in listeners that are attached farther down the list hierarchy. As a debug measure, I have removed the CollectionList and I have also replaced it with a FilterList and FunctionList. Everything seems to work correctly when inserting the other list types in my hierarchy.

Due to the complicated nature of the hierarchy, I do not have a test case that will replicate the issue. I was hoping that maybe someone else has either seen this issue or knows of something that I may be doing wrong.

Thanks,
Jeremy ford

With Windows Live, you can organize, edit, and share your photos. Click here.

Re: Odd behavior with CollectionList

2009-09-14T10:45:43Z

Check out this message. You /might/ be having a similar problem. I don't know the reason for the difference I mention.

http://www.nabble.com/forum/ViewPost.jtp?post=23227027&framed=y

Endre.

On Fri, Sep 11, 2009 at 17:26, Jeremy Ford <caius1@...> wrote:

I am seeing an issue when using CollectionList. I have a very complicated hierarchy of EventLists. I am attempting to insert in the middle a CollectionList which translates a pojo A into one or more A pojos based on certain criteria. After adding the CollectionList, it seems like I no longer receive list events in listeners that are attached farther down the list hierarchy. As a debug measure, I have removed the CollectionList and I have also replaced it with a FilterList and FunctionList. Everything seems to work correctly when inserting the other list types in my hierarchy.

Due to the complicated nature of the hierarchy, I do not have a test case that will replicate the issue. I was hoping that maybe someone else has either seen this issue or knows of something that I may be doing wrong.

Thanks,
Jeremy ford

With Windows Live, you can organize, edit, and share your photos. Click here.

re[4]: WeakReferenceProxy

2009-09-13T12:23:10Z

Endre -

This is a very good explanation of what is going on - thanks for putting it together (especially the ASCII art!).

I was especially inerested in this diagram:

BL . P -w> SL . P -w> FL . P -w> WL . P -w> Calc

<s-+ <s-+ <s-+ <s-+

| | | |

Publisher ------+----------+----------/

which implies that the downstream list doesn't technically have to hold a reference to it's source at all... This would further imply that it would be possible to create an EventList implementation that would implement the proxy behavior (instead of the *listener* being the weak reference, the list itself would behave as a weak reference to it's source). I think that this is similar to what you are currently doing with your shim lists, right? Are there advantages to this approach, vs having the downstream list hold a hard reference to the source, and only using weak references for the listeners? It would seem that there would be some modest performance advantages to holding the hard reference - as long as there is no need to detect the need to call dispose()...

To answer your question about how we handle this now, it's a hassle. This is one reason that I'm so interested in the discussion. For simple applications where down stream event list pipelines don't come and go on a regular basis, the current implementation is ok - but as apps increase in complexity (and our app is well into that territory), this becomes a big administrative problem.

So, is this all really as simple as just using weak reference proxy listeners in each list implementation? How important is dispose() then (even as an internal implementation detail)? I could certainly see the argument that it should be removed from the EventList interface. Can this be pushed further and just say that all entries registered with the publisher are treated as weak reference proxies (i.e. this would be an internal detail of the publisher, or any other GL class that holds listeners)?

I keep coming back to saying that we have to look at what is actually going on in dispose() on some of these lists to get a feel for what the implications here would be. For example, FilterList uses dispose() to releast listeners from matcher editors, and remove references to the matchereditor and matcher (in addition to removing the listener from the publisher). If the FilterList was registered as a weak reference to the MatcherEditor, would things stop working? You would think that, in the general case, users would have to hold a reference to the MatcherEditor to make it do anything useful, so maybe this is OK?

CollectionList is another list that has fairly complex dispose() behavior (clearing related listeners, etc...).

It would really help if we could get some more counter examples showing why this sort of thing *wouldn't* work. The Calculation-with-reference-not-held is one case, but one that I personally could live with.

Are there other solid use cases that anyone else can suggest?

- K

----------------------- Original Message -----------------------

From: Endre StÃ¸lsvik

To: users@...

Cc:

Date: Wed, 9 Sep 2009 03:46:18 +0200

Subject: Re: re[2]: WeakReferenceProxy

Some thoughts:

If a list in the library itself doesn't hold references that would prevent GC from collecting where it shouldn't, it seems like it should be easy to add those references to the specific list implementations. I know that this is not trivial - there are often lots of crazy intermediate lists generated in some of the more complex systems - but is this really as hard as we think? Perhaps it would be easier with the ability to obtain deleted element references?

Which EventList implementation would this be?

As GL stands now, only BasicEventList, DebugEventList and PersistentEventList directly implement EventList. All of these I believe are meant as "roots" (I don't know PersistentEL, though). The rest actually inherits from TransformedList - which has the source field.

However, this might be a moot point - read on!

A bigger issue is GL users who have code constructed around this behavior. To give a concrete example of where problems could occur, consider a Calculation object that accepts a FilteredList as it's source. If the calculation does not hold a hard reference to it's source (which it very well might not do), and the user does not hold a reference of the FilteredList (it is an intermediate object, after all), then the calculation would just silently stop receiving events. Not good (these sorts of things are just as hard to track down and fix as the possibility for a resource leak we have now!).

This argument was pretty good - an extra requirement has apparently been introduced by having WeakReferenceProxies all over: Any listener must hold a reference to its source.

However, magically, I believe it is not (that big of) a problem anyway - and the savior here is the publisher.

Lets make a longer chain, so that there are more middle nodes.

BL -s-> SL -s> FL -s> WL -s> Calc

Introduce proxies

BL -s> P -w> SL -s> P -w> FL -s> P -w> WL -s> P -w> Calc

<s--------- <s--------- <s---------

<s-- <s-- <s--

The Calc doesn't hold a strong reference backwards. At this point, your argument holds: The WhateverList (WL) has no strong reference to it, nor does anything else up to BasicList (BL - which is held by the static), even though Calc is strongly held by the thread in question. The entire structure would thus be torn down, leaving you with the BasicList and Calc without any connection in between.

However, if we now make it more realistic

BL . P -w> SL . P -w> FL . P -w> WL . P -w> Calc

<s-+----- <s-+----- <s-+----- |

<s-+ <s-+ <s-+ <s-+

| | | |

Publisher ------+----------+----------/

What we see, is that even though Calc doesn't have a strong reference backwards, the publisher, which the BasicList references (and all intermediate lists share, but that is not the point), holds a strong reference to each of the proxies, which hold a strong reference back to the list it proxies. As long as the Calc object is strongly referenced from somewhere, the WeakReferenceProxy's referent will not be nulled. The whole structure thus stands.

When the Calc object goes out of scope (isn't referenced anymore), it will be GC'ed, and the referent cleared. The publisher will notice this on the next fired event, and drop that proxy out of the system (deregister it (from the publisher), and actually nulls the source reference, an operation which isn't actually needed in this case). At this point, WL is not held by any strong reference, and will eventually be GC'ed, and hence that list's proxy's referent will be cleared. On the next fire, that one will be cleared - and so on. So, after a sequence of a GC then an event fired, repeated four times, the BasicEventList would be alone.

In my last email, I had this severe nagging about such a "staggering GC backwards" (and that was why i wrote the section above starting with "Back to the above argument"), and now got a full-blown dejavu..! I had however apparently forgotten the complete argument.

See, even if one drops the reference backwards on the intermediate lists:

BL . P -w> SL . P -w> FL . P -w> WL . P -w> Calc

<s-+ <s-+ <s-+ <s-+

| | | |

Publisher ------+----------+----------/

.. the entire argument still seems to stand.

HOWEVER, if the Calc-object itself e.g. have some different event firing system outside of GlazedLists, whereby some new object X hooks itself up as a listener onto Calc's own event system, without X keeping a reference to Calc, one would be in trouble: Calc would be completely unreferenced and thus GCable, and the chain in front of it would tumble down. That would probably be very hard to track down. One can argue that this would hold for ANY object that one just adds oneself as a reference to without holding a reference back to - it will be GC'ed. Problem is that one could quite possibly expect "an active object" that fires events and all, to obviously somehow be referenced somewhere! Which is the case - only it is through a WeakReference.

The discussion should probably revolve around what is the most common problem - what would benefit GL users the most.

One question I sit with, though, is how you guys handle the problem now? With such a chain of intermediate lists that you have not got a reference to (you only reference the tip)? Neither dispose() nor removeListEventListener() recurse.

That is my reason for needing to extend the classes - which I couldn't, so I had to copy them.

Have this ever been tried implemented?

(How I personally handle the problem now is by doing these "reimplementations" to implement recursion, AND having some shim "trackers" that I dish out instead of the actual list instance. These are referenced using WeakReferences that I register with a ReferenceQueue. When the ref-cleaner thread checks in on such a shim (because it was GCed), it checks if the "user" has disposed the list in question. If it hasn't, I do it then - and log a angry error log message, with an "InstantiationStackTrace" for easy debugging!)

(Personally, I currently lean towards that dispose() and/or removeListEventListener() should recurse. If one at a certain stage of the pipeline didn't want the recursion to happen, one could insert a DontRecurseDisposeList shim that .. did as its name implies)

Endre.

----------------------- Original Message -----------------------



From: Endre StÃ¸lsvik%3Cjava@...

To: users@...

Cc:

Date: Wed, 9 Sep 2009 00:45:01 +0200

Subject: Re: WeakReferenceProxy



[dispose() has not been a part of the EventList interface for that much time. That is not the problem here, though, IMO]

The "leaf logic" is not necessary if I have understood this correctly. I believe that this has been "touched into" before on the list.

Consider:

BasicEventList -> SortedList -> FilteredList

The BasicEventList is strongly held (say, for the sake of argument, as a static), as is the FilteredList (again, for the sake of the argument, as a stack variable). The SortedList is just a intermediary, which hasn't got any references to it, except that it has registered with BasicEventList as listener, which thus strongly holds it.

A problem is that if we just let go of the FilteredList, nothing happens - it is still strongly referenced. The API of GL doesn't help us either - there is no way to get at the FilteredList anymore, and it is utterly leaked. (Both "memory leaked", but maybe more annoyingly, also "processing leaked", as all events still will be sent to it)

A perceived problem of introducing WeakReferenceProxies between the lists, is that SortedList would be GC'ed out of existence as nothing would reference it strongly, thus leaving the FilteredList hanging outside the event stream. This is not so, I believe:

Reasoning: All current lists except the BasicEventList, which obviously acts as "roots" for these chains, holds a reference to its _source_ (since they all extend TransformedList).

Thus, we really have this situation

BasicEventList -> SortedList -> FilteredList

 <- <-



When we introduce the WeakReferenceProxies, we end up like this (a WeakReferenceProxy also has a link to its source)

BasicEventList -strong-> WeakRefProxy -weak-> SortedList -strong-> WeakRefProxy -weak-> FilteredList

 <-strong---------------------- <-strong----------------------

 <-strong- <-strong-

We can for now basically ignore the fact that it isn't like this at all: It is not the lists that hold references to their listeners. The list holds a reference to its publisher, which holds a reference to ALL the listeners. But (I believe) it at this point boils down to the same.

If we let go of the FilteredList, there is nothing that holds it strongly anymore. NEITHER is there for SortedList. They would be free to be GC'ed.

When they are GC'ed, their referent in the WeakReferenceProxy is also cleared - thats how [Soft|Weak]References work.

When anything that triggers the WeakReferenceProxy purging happens (see below), these proxies are noticed (there is special handling for them in the publisher), and it will be noticed that they are cleared. Therefore, they are deregistered as listeners to their source (and the source field is nulled), and then they're also GCable.

Thus, we are now left with only the BasicEventList - just as we would want.

(The "node logic" of the publisher, which I still haven't gotten a proper answer to how really works, would maybe have to be extended to handle the WeakReferenceProxies also when stacking up the listening order (the "if a listener is also a list"-part: If that test fails, it should also check whether it is a WeakReferenceProxy, in which case, it should check the referent whether it is a list instead).
The conditions under which the WeakReferenceProxy are cleaned up are documented in the class doc:
Specifically, the proxy stops listening to L the


 * next time any of the following occurs:
 *
 * <ul>
 * <li> another ListEventListener is registered with the same EventList



 * <li> another ListEventListener is deregistered with the same EventList
 * <li> another ListEvent is broadcast for the same EventList
 * </ul>
It rests on the publisher. Thus, if you register or deregister any listener on any list that has the same publisher, all cleared WeakReferenceProxies will be purged.

The same goes for sending an event: If you make a change to any list whose ListEvent ends up going through any dead WeakReferenceProxy (on any list with the same publisher), the proxy listener will deregister itself, and hence trig the above mentioned situation.

Back to the above argument: The fact that the ASCII-art doesn't really represent the situation doesn't destroy the argument. The FilteredList is still GC'ed, and its proxy listener referent it cleared. This would happen at the same time, or later, or even before, to the SortedList's proxy listener. But, the WeakReferenceProxies themselves are actually strongly referenced still, by the fact that the BasicEventList (which is referenced through a static, remember) holds a reference to the publisher, which holds all the listeners, and thus the proxies. But, the clearing-logic still kicks in: Their referent is cleared, and thus they will be deregistered and out of the system, not incurring neither mem nor processing leaks.

Coincidentally, I've just these latter days used hours - actually, a full day - on hunting down just such a retention-bug due to WeakReferenceProxies and the publisher.

Here's a static method I ended up with to generically be able to "trig" a manual purging of all WeakReferenceProxies on a publisher, with some JavaDoc to explain (helping me to remember, at least!).

 /**

 * Special method for GlazedLists memory leak hunting (using a profiler): What

 * happens, is that several GlazedLists elements seem to be hanging for no good reason. It turns out that this is a

 * problem caused by two "crashing" aspects during testing: When using {@link Assert#assertEquals(Object, Object)}

 * and sticking (typically) some {@link List} as expected and an {@link EventList} as actual, the JUnit-framework

 * typically ends up invoking {@link AbstractList#equals(Object)} (<code>expected.equals(actual)</code>) which again

 * employs the {@link List#listIterator() ListIterators} of both lists for comparison. The ListIterator is in

 * GlazedLists an active iterator, employing a {@link ListEventListener} to listen on the {@link EventList}. Since

 * there is no dispose logic on the iterator, it is implemented using a {@link WeakReferenceProxy}, which is a

 * {@link ListEventListener} proxy implemented using a {@link WeakReference} which one registers on the list one

 * want to listen to. It lets the actual listener become GCable when it is ditched from the universe (it is the

 * WeakReference referent). This is surely handy for the {@link ListIterator} mentioned - when the code is finished

 * with the iterator, it goes out of scope, and since it then is only weakly referenced, it will become GC'ed, and

 * the referent in the WeakReference is cleared (nulled).

 * 

 * The WeakReferenceProxy is registered with the source list, and the source reference is contained within the

 * WeakRefrenceProxy. However, listeners are not registered with the list itself, but instead on the publisher for

 * the list. Thus we now end up with a strong reference to the source by way of any other list having the same

 * publisher. (Each EventList holds a reference to some publisher. Lists that want to work together needs the same

 * publisher. Thus, if any list is retained with this publisher, the source list in question will also be retained).

 * 

 * The publisher is cleaned of these weak proxies lazily (it is not possible to attach any {@link ReferenceQueue} to

 * them upon creation), and the cleaning can from the outside be triggered by adding or removing a ListEventListener

 * to any list that the publisher handles: When doing such add or remove, the entire set of listeners is traversed -

 * and in this process, any WeakReferenceProxies that is stumbled across that has a null referent is dropped.

 * 

 * The cleaning can however also be done by making any list change on any list that results in a

 * {@link ListEvent} being fired through any cleared {@link WeakReferenceProxy} in the

 * publisher-system. This because the proxy (obviously) has to check whether the referent is cleared, in which case

 * it also deregisters itself from the source (which it as mentioned carries a reference to), which triggers the

 * above mentioned process, thus removing all cleared WeakReferenceProxies in this publisher. Finally it

 * nulls source, which I actually believe thus happens twice for the ONE proxy that starts the process. Note though

 * that this isn't as certain - if you don't quite know how to be sure that you ensure an event is fired through

 * such a proxy, you will have to do some change to all lists. Instead, one only have to do one change to the set of

 * ListEventListeners registered with the publisher to be ensured of clearing.

 * 

 * How this method works: This method first GC's to have all WeakReferences cleared (the referent is nulled,

 * the referent being the ListEventListener that should get the event). It then then makes a dummy

 * {@link BasicEventList} using the supplied {@link ListEventPublisher}, makes a dummy

 * {@link ListEventListener}, then adds and remove the latter on the former. This should (and apparently does!)

 * ensure that these {@link WeakReferenceProxy}s are removed, and hence that the source lists of these

 * proxies become GCable.

 */

 public static void cleanListEventPublisherForWeakReferenceProxies(ListEventPublisher publisher) {

 System.gc();

 try {

 Thread.sleep(500);

 }

 catch (InterruptedException e) {

 Thread.currentThread().interrupt();

 }

 EventList<?> dummyList = new BasicEventList<Object>(publisher, LockFactory.DEFAULT.createReadWriteLock());

 ListEventListener<Object> dummyListener = new ListEventListener<Object>() {

 @Override

 public void listChanged(@SuppressWarnings ("unused") ListEvent<Object> listChanges) {

 /* no-op */

 }

 };

 dummyList.addListEventListener(dummyListener);

 dummyList.removeListEventListener(dummyListener);

 }
James

On Fri, Sep 4, 2009 at 11:58 AM, Bruce Alspaugh <compulinkltd@...> wrote:

After glancing at the JavaDoc for GlazedLists.weakReferenceProxy(EventList<E> source, ListEventListener<E> target), I have a few questions:

Would it have been possible to eliminate the need for the EventList.dispose() methods if EventList implementations registered weakReferenceProxys on their upstream source lists?

How does the weakReferenceProxy receive its notification to remove itself from the source? Does it use some sort of background thread to check a java.lang.ref.ReferenceQueue<T>?

Bruce

---------------------------------------------------------------------
To unsubscribe, e-mail: users-unsubscribe@...
For additional commands, e-mail: users-help@...
--------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@... For additional commands, e-mail: users-help@...

--------------------------------------------------------------------- To unsubscribe, e-mail: users-unsubscribe@... For additional commands, e-mail: users-help@...