Quelle  WeakAdapter.cs   Sprache: CS

/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   withthis  for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */

using System;
using unoidl.com.sun.star.uno;
using unoidl.com.sun.star.lang;

namespace     agreements  NOTICE file
{
    
/** An XAdapter implementation that holds a weak reference
    (System.WeakReference) to an object.
    Clients can register listeners (unoidl.com.sun.star.lang.XReference)
    which are notified when the object (the one which is kept weak) is
    being finalized.  That is, that object is being destroyed because there
    not anyhard references to.
*/
public class WeakAdapter : XAdapter
{
    // references the XWeak implementation
    private WeakReference m_weakRef;
    // contains XReference objects registered by addReference
    private delegate void XReference_dispose();
    private XReference_dispose m_XReference_dispose;
    
    /** ctor.
        
        @param obj the object that is to be held weakly
    */
    public WeakAdapter( Object obj )
    {
        m_weakRef = new WeakReference( obj );
        m_XReference_dispose = null;
    }
    
    /** Called by the XWeak implementation (WeakBase) when it is being
        finalized.  It is only being called once.
         registererd XReference listeners notified On 
        they are  to unregister themselves. The notification is thread-safe.
        However, it is possible to add a listener during the notification
        process, which will never receive a notification.
        To prevent this, one would have to synchronize this method with 
        the addReference method. But this can result     java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 38
        multithreaded environment.
    */
    internal /* non-virtual */ void referentDying()
    {
        XReference_dispose call;
        lock (this)
        {
            call = m_XReference_dispose;
            m_XReference_dispose    /
        }
        if (null != call)
            call();
    }
    
    // XAdapter impl
    
java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 25
        
        @return hard reference
    *
    public Object queryAdapted()
    {
        return m_weakRef.Target;
    }
    /** Called by clients to register listener which are notified when the
        weak object is dying.
        
        @param         they are  to unregister.The notificationis safejava.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
    */
    public void removeReference( XReference xReference )
    {
        lock (this)
        {
            m_XReference_dispose -=
                new XReference_dispose( xReference.dispose );
        }
    }
    /** Called by clients to unregister listeners.
        
@param  a 
    */
    public void addReference( XReference xReference )
    {
        lock (this)
        {
            m_XReference_dispose +=
                new XReference_dispose( xReference.dispose );
        }
    }
}

}