public final Feature getFeature()
    {
        if (theFeature == null)
        {
            Task task = new Task();
            task.execute();
            while (!task.isDone()) {
                //Sleep for one second.
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException ignore) {}
            }

            try
            {
                theFeature = task.get();
            }
            catch (InterruptedException exception)
            {
                exception.printStackTrace();
            }
            catch (ExecutionException exception)
            {
                exception.printStackTrace();
            }
        }
        return theFeature;
    }

	 
    class Task extends SwingWorker<Feature, Void>
    {
        @Override
        public Feature doInBackground()
        {
            Feature feature = null;
            feature = Proxy.getInstance(theEntity).getFeature(theEntity, theFeatureName);
            return feature;
        }
    }

    public class MyWorker extends SwingWorker<Object, Integer>
    {
        private final RootEntityImpl aDispatchable;
        public MyWorker(final RootEntityImpl aDispatchable)
        {
            this.aDispatchable = aDispatchable;
        }
        
        protected Object doInBackground() throws Exception
        {
            Jas myRoot = (Jas) itsModelMap.getRelatedNode(aDispatchable);
            HoldingList myHoldingList = (HoldingList) itsNodeFinder.findNode(myRoot, HoldingList.class);
            FeatureImpl myFeatureImpl = null;
            if (myHoldingList != null && !myHoldingList.isAbsent())
            {
                myFeatureImpl = new RootEntityImpl.International();
                // Attach the Feature to its RootEntity.
                aDispatchable.addFeature(RootEntity.FEATURE_INTERNATIONAL, myFeatureImpl);
                itsModelMap.relate(myFeatureImpl, myHoldingList);
                // For now build all the holdings with company information
                try
                {
                    Holding myHolding = new Holding();
                    Map[] myResults = itsConnection.searchOneLevel(myHoldingList.getDN(), "(objectClass=" + myHolding.getManagedObjectName() + ")", null);
                    for (int i = 0; i < myResults.length; i++)
                    {
                        myHolding.fill(myResults[i]);
                        myHoldingList.addChild(myHolding);
                        buildSubTree(myHolding);
                        publish(Integer.valueOf(i+1));
                        myHolding = new Holding();
                    }
                }
                catch (ComException anEx)
                {
                    throw new PresentationModelException(anEx);
                }
            }
            return myFeatureImpl;
        }
        
        protected void process(List<Integer> holdingsLoaded)
        {
            for (Integer i : holdingsLoaded)
            {
                ProgressIndicator.getInstance().setString("Loaded " + i + " holdings");
            }
        }

        public void done() 
        {
            try 
            {
                rootFeatureImpl = get();
            } 
            catch (InterruptedException ignore) 
            {
            }
            catch (java.util.concurrent.ExecutionException e) 
            {
            }
        }
    }
    
    public Object handle(RootEntityImpl aDispatchable) throws PresentationModelException
    {
        Object myFeatureImpl = null;
        MyWorker worker = new MyWorker(aDispatchable);
        worker.execute();
        while (!worker.isDone())
        {
            myFeatureImpl = rootFeatureImpl;
        }
        return myFeatureImpl;
    }

        worker.execute();
        while (!worker.isDone())
        {
            myFeatureImpl = rootFeatureImpl;
        }
        return myFeatureImpl;