/** Get the instance of DataObjectPool - value of static field 'POOL'. * Initialize the field if necessary. * * @return The DataObjectPool. */ static DataObjectPool getPOOL() { synchronized (lockPOOL) { if (POOL != null) return POOL; POOL = new DataObjectPool (); } lp.addChangeListener(POOL); return POOL; }
/** Changes the primary file to new one. * @param item the item to change * @param newFile new primary file to set */ private synchronized void changePrimaryFile ( Item item, FileObject newFile ) { map.remove (item.primaryFile); item.primaryFile = newFile; map.put (newFile, item); countRegistration(newFile); }
/** Rescan all primary files of currently existing data * objects. * * @return set of DataObjects that refused to be revalidated */ public Set revalidate () { Set files; synchronized (this) { files = createSetOfAllFiles (map.values ()); } return revalidate (files); }
/** Calls into one loader. Setups security condition to allow DataObject ocnstructor * to succeed. */ public static DataObject handleFindDataObject (DataLoader loader, FileObject fo, DataLoader.RecognizedFiles rec) throws java.io.IOException { DataObject ret; Collection prev = enterAllowContructor (); try { // make sure this thread is allowed to recognize getPOOL ().enterRecognition(fo); ret = loader.handleFindDataObject (fo, rec); } finally { exitAllowConstructor (prev); } return ret; }
/** Creates and finishes registration of MultiDataObject. */ public static MultiDataObject createMultiObject (MultiFileLoader loader, FileObject fo) throws java.io.IOException { MultiDataObject ret; Collection prev = enterAllowContructor (); try { ret = loader.createMultiObject (fo); } finally { exitAllowConstructor (prev); } return ret; }
/** List all children. * @return array with children */ public List getChildrenList () { ListTask lt; try { DataObjectPool.getPOOL().enterPriviledgedProcessor (PROCESSOR); lt = getChildrenList (null); lt.task.waitFinished(); } finally { DataObjectPool.getPOOL().exitPriviledgedProcessor (PROCESSOR); } return lt.result; }
/** Called when there is a collision between a data object that * this loader tries to create and already existing one. * * @param obj existing data object * @param file the original file that has been recognized by this loader * as bellonging to obj data object * @return the data object created for this or null */ DataObject checkCollision (DataObject obj, FileObject file) { /* JST: Make protected when necessary. Do not forget to * change UniFileDataLoader too. */ FileObject primary = obj.getPrimaryFile (); /*Set refusing = */DataObjectPool.getPOOL().revalidate ( new HashSet (Collections.singleton(primary)) ); // ok, the obj is discarded DataObject result = DataObjectPool.getPOOL().find (primary); return result; }
doh = new Item (fo); map.put (fo, doh); countRegistration(fo); notifyAdd (doh); countRegistration(fo); notifyAdd (doh); doh = new Item (fo); map.put (fo, doh); countRegistration(fo); notifyAdd (doh);
private final MultiDataObject createMultiObject(FileObject fo) throws DataObjectExistsException, IOException { MultiFileLoader loader = getMultiFileLoader (); MultiDataObject obj; if (loader != null) { obj = DataObjectPool.createMultiObject(loader, fo); } else { obj = (MultiDataObject)getLoader ().findDataObject (fo, RECOGNIZER); } return obj; }
/** Refresh of all folders. */ private void refreshAllFolders () { Set files; synchronized (this) { files = new HashSet (map.keySet ()); } Iterator it = files.iterator (); while (it.hasNext ()) { FileObject fo = (FileObject)it.next (); if (fo.isFolder ()) { DataObject obj = find (fo); if (obj instanceof DataFolder) { DataFolder df = (DataFolder)obj; FileObject file = df.getPrimaryFile (); synchronized (this) { if (toNotify.isEmpty() || !toNotify.contains((Item)map.get(file))) { FolderList.changedDataSystem (file); } } } } } }
try { synchronized (this) { enterRecognition (obj.getPrimaryFile().getParent());
/** Calls into FolderLoader. Setups security condition to allow DataObject constructor * to succeed. */ public static MultiDataObject createMultiObject(DataLoaderPool.FolderLoader loader, FileObject fo, DataFolder original) throws java.io.IOException { MultiDataObject ret; Collection prev = enterAllowContructor (); try { ret = loader.createMultiObject (fo, original); } finally { exitAllowConstructor (prev); } return ret; }
newFolder = (DataFolder) DataObjectPool.createMultiObject (folderLoader, newFile, this); dispose = false; break;
/** Executes atomic action with priviledge to create DataObjects. */ public void runAtomicActionSimple (FileObject fo, FileSystem.AtomicAction action) throws java.io.IOException { Collection prev = enterAllowContructor (); try { fo.getFileSystem ().runAtomicAction(action); } finally { exitAllowConstructor (prev); } }
/** When the loader pool is changed, then all objects are rescanned. */ public void stateChanged (javax.swing.event.ChangeEvent ev) { Set set; synchronized (this) { // copy the values synchronously set = new HashSet (map.values ()); } set = createSetOfAllFiles (set); revalidate (set); }