| /aoo42x/main/connectivity/java/sdbc_postgresql/src/com/sun/star/sdbcx/comp/postgresql/ |
| H A D | PostgresqlConnection.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PostgresqlPreparedStatement.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PostgresqlResultSet.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PostgresqlStatement.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PostgresqlDriver.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PostgresqlTable.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/connectivity/java/dbtools/src/org/apache/openoffice/comp/sdbc/dbtools/comphelper/ |
| H A D | PropertySet.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | PropertySetAdapter.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/connectivity/java/dbtools/src/org/apache/openoffice/comp/sdbc/dbtools/sdbcx/ |
| H A D | ODescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OIndexColumn.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OKeyColumn.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OColumn.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OIndex.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OKey.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OView.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OCatalog.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | OTable.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/connectivity/java/dbtools/src/org/apache/openoffice/comp/sdbc/dbtools/sdbcx/descriptors/ |
| H A D | SdbcxIndexColumnDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxIndexDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxKeyColumnDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxKeyDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxTableDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxColumnDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| H A D | SdbcxViewDescriptor.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|
| /aoo42x/main/connectivity/java/dbtools/src/org/apache/openoffice/comp/sdbc/dbtools/util/ |
| H A D | DatabaseMetaDataResultSet.java | diff 5b780c4a Sat Sep 16 08:27:31 UTC 2017 Damjan Jovanovic <damjan@apache.org> Locking and disposal cleanup.
Firstly, add isDisposed() and checkDisposed() methods to
main/javaunohelper's com.sun.star.lib.uno.helper.ComponentBase, so that
Java components can easily test and assert their disposal state. Comment
these for a clearer understanding of how disposal works, namely that
locking against disposal must cover all access of that component, so that
the component can't be disposed half-way through being used. These methods
are stricter than before, where only bDisposed was checked, which allowed
the component to be used during disposal (as postDisposing() runs before
bDisposed is set)!!
Fix and simplify locking in the PostgreSQL driver, first by using the new
methods in ComponentBase instead of tracking disposal separately with our
own variable, then expand locking to entire methods so components can't be
disposed during a method's execution, and finally eliminate disposal
tracking in components that purely wrap another component and modify
data in transit, as all disposal management is done by the wrapped
component and we don't have to worry as long as our postDispose() has
nothing special to do and just delegates to the wrapped component.
Also eliminate internal locks in objects, and use "this" as the lock for
the non-container objects like Table / Column / Key, while using the
parent's "this" as the lock for contain objects like Tables, Columns, Keys
etc., as this further simplifies locking, allow using method-level locking
instead of "synchronized (this)", reduces the number of fields, simplifies
locking in subclasses, and theoretically allows callers to hold the lock
across multiple method invocations.
Other minor fixes, some exception cleanup, use of AtomicInteger to generate
numbers in PropertySetAdapter, etc.
Patch by: me
git-svn-id: https://svn.apache.org/repos/asf/openoffice/trunk@1808517 13f79535-47bb-0310-9956-ffa450edef68
|