Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* 
   * Copyright (c) 2007 Wayne Meissner
   * 
   * This file is part of gstreamer-java.
   *
   * This code is free software: you can redistribute it and/or modify it under
   * the terms of the GNU Lesser General Public License version 3 only, as
   * published by the Free Software Foundation.
   *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License
  * version 3 for more details.
  *
  * You should have received a copy of the GNU Lesser General Public License
  * version 3 along with this work.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.gstreamer.lowlevel;
 
 
 
 
 public abstract class NativeObject extends org.gstreamer.lowlevel.Handle {
     private static final Logger logger = Logger.getLogger(NativeObject.class.getName());
     public static final Level LIFECYCLE = .;
     
     // Use this to propagate low level pointer arguments up the constructor chain
     protected static class Initializer {
         public final Pointer ptr;
         public final boolean needRefownsHandle;
         public Initializer() {
             this. = null;
             this. = false;
             this. = false;
         }
         public Initializer(Pointer ptrboolean needRefboolean ownsHandle) {
             this. = ptr;
             this. = needRef;
             this. = ownsHandle;
         }
     }
     protected static final Initializer defaultInit = new Initializer();
     
     /*
      * The default for new objects is to not need a refcount increase, and that
      * they own the native object.  Special cases can use the other constructor.
      */
     protected static Initializer initializer(Pointer ptr) {
         return initializer(ptrfalsetrue);
     }
     protected static Initializer initializer(Pointer ptrboolean needRefboolean ownsHandle) {
         if (ptr == null) {
             throw new IllegalArgumentException("Invalid native pointer");
         }
         return new Initializer(ptrneedRefownsHandle);
     }
    
Creates a new instance of NativeObject
 
     protected NativeObject(final Initializer init) {
         .entering("NativeObject""<init>"new Object[] { init });
         if (init == null) {
             throw new IllegalArgumentException("Initializer cannot be null");
         }
         .log("Creating " + getClass().getSimpleName() + " (" + init.ptr + ")");
          = new NativeRef(this);
         this. = init.ptr;
         this..set(init.ownsHandle);
         
         //
         // Only store this object in the map if we can tell when it has been disposed 
         // (i.e. must be at least a GObject - MiniObject and other NativeObject subclasses
         // don't signal destruction, so it is impossible to know if the instance 
         // is stale or not
         //
         if (GObject.class.isAssignableFrom(getClass())) {
             getInstanceMap().put(init.ptr);
         }
         
     }
     
     abstract protected void disposeNativeHandle(Pointer ptr);
     
     public void dispose() {
        .log("Disposing object " + getClass().getName() + " = " + );
//        System.out.println("Disposing " + handle);
        if (!.getAndSet(true)) {
            getInstanceMap().remove();
            if (.get()) {
                disposeNativeHandle();
            }
            .set(false);
        }
    }
    
    protected void invalidate() {
        .log("Invalidating object " + this + " = " + handle());
        getInstanceMap().remove(handle(), );
        .set(true);
        .set(false);
        .set(false);
    }
    
    @Override
    protected void finalize() throws Throwable {
        try {
            .log("Finalizing " + getClass().getSimpleName() + " (" +  + ")");
//            System.out.println("Finalizing " + getClass().getSimpleName() + " (" + handle + ")");
            dispose();
        } finally {
            super.finalize();
        }
    }
    protected Object nativeValue() {
        return handle();
    }
    protected Pointer handle() {
        if (!.get()) {
            throw new IllegalStateException("Native object has been disposed");
        }
        return ;
    }
    public Pointer getNativeAddress() {
        return ;
    }
    protected boolean isDisposed() {
        return .get();
    }
    protected static NativeObject instanceFor(Pointer ptr) {
        WeakReference<NativeObjectref = getInstanceMap().get(ptr);
        
        //
        // If the reference was there, but the object it pointed to had been collected, remove it from the map
        //
        if (ref != null && ref.get() == null) {
            getInstanceMap().remove(ptr);
        }
        return ref != null ? ref.get() : null;
    }
    public static <T extends NativeObject> T objectFor(Pointer ptrClass<T> clsboolean needRef) {
        return objectFor(ptrclsneedReftrue);
    }
    public static <T extends NativeObject> T objectFor(Pointer ptrClass<T> clsboolean needRefboolean ownsHandle) {
        return objectFor(ptrclsneedRef ? 1 : 0, ownsHandle);
    }
        
    public static <T extends NativeObject> T objectFor(Pointer ptrClass<T> clsint refAdjustboolean ownsHandle) {
        .entering("NativeObject""instanceFor"new Object[] { ptrrefAdjustownsHandle });
        
        // Ignore null pointers
        if (ptr == null) {
            return null;
        }
        NativeObject obj = GObject.class.isAssignableFrom(cls) ? NativeObject.instanceFor(ptr) : null;
        if (obj != null && cls.isInstance(obj)) {
            if (refAdjust < 0) {
                ((RefCountedObjectobj).unref(); // Lose the extra ref added by gstreamer
            }
            return cls.cast(obj);
        }
        
        //
        // If it is a GObject or MiniObject, read the g_class field to find
        // the most exact class match
        //
        if (GObject.class.isAssignableFrom(cls) || MiniObject.class.isAssignableFrom(cls)) {
            cls = classFor(ptrcls);
        }
        try {
            Constructor<T> constructor = cls.getDeclaredConstructor(Initializer.class);
            T retVal = constructor.newInstance(initializer(ptrrefAdjust > 0, ownsHandle));
            //retVal.initNativeHandle(ptr, refAdjust > 0, ownsHandle);
            return retVal;
        } catch (SecurityException ex) {
            throw new RuntimeException(ex);
        } catch (IllegalAccessException ex) {
            throw new RuntimeException(ex);
        } catch (InstantiationException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchMethodException ex) {
            throw new RuntimeException(ex);
        } catch (InvocationTargetException ex) {
            throw new RuntimeException(ex);
        }
    }
    
    @SuppressWarnings("unchecked")
    protected static <T extends NativeObjectClass<T> classFor(Pointer ptrClass<T> defaultClass) {
        Class<? extends NativeObjectcls = GstTypes.classFor(ptr);
        if (cls != null && cls.isAnnotationPresent(HasSubtype.class)) {
            cls = (Class<T>)SubtypeMapper.subtypeFor(clsptr);
        }
        return (cls != null && defaultClass.isAssignableFrom(cls)) ? (Class<T>) cls : defaultClass
    }
    
    @Override
    public boolean equals(Object o) {
        return o instanceof NativeObject && ((NativeObjecto)..equals();
    }
    
    @Override
    public int hashCode() {
        return .hashCode();
    }
    
    @Override
    public String toString() {
        return getClass().getSimpleName() + "(" + handle() + ")";
    }
    
    //
    // No longer want to garbage collect this object
    //
    public void disown() {
        .log("Disowning " + handle());
        .set(false);
    }
    
    static {
        //
        // Add a shutdown task to cleanup any dangling object references, so 
        // Gst.deinit() can shutdown cleanly.  Unreffing objects after gst_deinit()
        // has been called could be asking for trouble.
        //
        Gst.addStaticShutdownTask(new Runnable() {
            public void run() {
                System.gc(); 
                int gcCount = 20;
                // Give the GC a chance to cleanup nicely
                while (!getInstanceMap().isEmpty() && gcCount-- > 0) {
                    try {
                        Thread.sleep(10);
                        System.gc();
                    } catch (InterruptedException ex) {
                        break;
                    }
                }
                for (Object o : getInstanceMap().values().toArray()) {
                    NativeObject obj = ((NativeRefo).get();
                    if (obj != null && !obj.disposed.get()) {
//                        System.out.println("Disposing " + obj);
                        obj.dispose();
                    }
                }
            }
        });
    }
    private static final ConcurrentMap<PointerNativeRefgetInstanceMap() {
        return .;
    }
    static class NativeRef extends WeakReference<NativeObject> {
        public NativeRef(NativeObject obj) {
            super(obj);
        }
    }
    private final AtomicBoolean disposed = new AtomicBoolean(false);
    private final AtomicBoolean valid = new AtomicBoolean(true);
    private final Pointer handle;
    protected final AtomicBoolean ownsHandle = new AtomicBoolean(false);
    private final NativeRef nativeRef;
    private static final class StaticData {
        private static final ConcurrentMap<PointerNativeRefinstanceMap = new ConcurrentHashMap<PointerNativeRef>();
        static {
            //
            // Add a shutdown task to cleanup any dangling object references, so 
            // Gst.deinit() can shutdown cleanly.  Unreffing objects after gst_deinit()
            // has been called could be asking for trouble.
            //
            Gst.addStaticShutdownTask(new Runnable() {
                public void run() {
                    System.gc(); 
                    int gcCount = 20;
                    // Give the GC a chance to cleanup nicely
                    while (!getInstanceMap().isEmpty() && gcCount-- > 0) {
                        try {
                            Thread.sleep(10);
                            System.gc();
                        } catch (InterruptedException ex) {
                            break;
                        }
                    }
                    for (Object o : getInstanceMap().values().toArray()) {
                        NativeObject obj = ((NativeRefo).get();
                        if (obj != null && !obj.disposed.get()) {
    //                        System.out.println("Disposing " + obj);
                            obj.dispose();
                        }
                    }
                }
            });
        }
    }
New to GrepCode? Check out our FAQ X