vtk/src/vtk/vtkJavaMemoryManager.java

   1 package vtk;
   2
   3 /**
   4  * This interface provide all the methods needed for the management of vtkObject
   5  * in the Java world. They are used internally inside the generated Java code of
   6  * the VTK objects to keep track of the reference count of the corresponding VTK
   7  * C++ object and therefore allow to release memory when it became possible.
   8  *
   9  * Only the 3 following methods should be called by the user: - gc(boolean) : to
  10  * run the garbage collection - getAutoGarbageCollector() : to get the EDT
  11  * garbage collection scheduler - deleteAll() : to free any remaining VTK
  12  * object.
  13  *
  14  * @author sebastien jourdain - sebastien.jourdain@kitware.com
  15  */
  16 public interface vtkJavaMemoryManager {
  17   /**
  18    * Create or return an existing instance of the vtkObject that corresponds
  19    * to the pointer id vtkId.
  20    *
  21    * @param vtkId
  22    *            is used to uniquely identify a vtkObject inside the C++ layer.
  23    *
  24    * @return a java object that map its underlying C++ instance.
  25    */
  26   vtkObjectBase getJavaObject(Long vtkId);
  27
  28   /**
  29    * Store the Java instance of a vtkObject inside a weak pointer map.
  30    *
  31    * @param id
  32    *            is used to uniquely identify a vtkObject inside the C++ layer.
  33    * @param obj
  34    *            is the Java instance that is stored inside a WeakPointer of
  35    *            the map.
  36    */
  37   void registerJavaObject(Long id, vtkObjectBase obj);
  38
  39   /**
  40    * If found the Java object is removed from the map and we decrease the
  41    * reference count of the underneath C++ instance.
  42    *
  43    * @param id
  44    */
  45   void unRegisterJavaObject(Long id);
  46
  47   /**
  48    * Execute the garbage collection in the Java + VTK context to release Java
  49    * instance that are not used anymore which keep holding a C++ instance
  50    * around.
  51    *
  52    * @param debug
  53    *            allow to add extra information inside the return object such
  54    *            as the class name of the objects lefts as well as their
  55    *            numbers.
  56    *
  57    * @return an information object that provide useful information for
  58    *         statistic or debugging purpose.
  59    */
  60   vtkReferenceInformation gc(boolean debug);
  61
  62   /**
  63    * @return an helper class that allow to trigger the garbage collector at a
  64    *         given frequency inside the EDT.
  65    */
  66   vtkJavaGarbageCollector getAutoGarbageCollector();
  67
  68   /**
  69    * This method will clean up the Map of the Java objects and will release
  70    * any vtkObject that was held by a Java one. This will prevent you from
  71    * using any existing VTK Java object.
  72    *
  73    * @return the size of the map that we cleared
  74    */
  75   int deleteAll();
  76
  77   /**
  78    * @return the number of vtkObject that are currently used inside the Java
  79    *         world.
  80    */
  81   int getSize();
  82
  83   /**
  84    * @return the vtkReferenceInformation object generated by the last gc() call
  85    */
  86   vtkReferenceInformation getLastReferenceInformation();
  87 }