Returns the optional progress listener for receiving updates about object
download status.

@return the optional progress listener for receiving updates about object
download status.

@deprecated use {@link #getGeneralProgressListener()} instead.
175722
@Deprecated
    public com.ibm.cloud.objectstorage.services.s3.model.ProgressListener getProgressListener() {
        ProgressListener generalProgressListener = getGeneralProgressListener();
        if (generalProgressListener instanceof LegacyS3ProgressListener) {
            return ((LegacyS3ProgressListener)generalProgressListener).unwrap();
        } else {
             return null;
        }
    }
1024135
public JMProgressiveManager<T, R> getAfterCompletion() {
		try {
			completableFuture.get();
		} catch (InterruptedException | ExecutionException e) {
			handleException(log, e, "stopSync");
		}
		return this;
	}
1040612
function checkIfAnotherSessionInProgress() {
        var result = $.Deferred();
        if(updateJsonHandler) {
            var state = updateJsonHandler.state;

            updateJsonHandler.refresh()
                .done(function() {
                    var val = updateJsonHandler.get(updateProgressKey);
                    if(val !== null) {
                        result.resolve(val);
                    } else {
                        result.reject();
                    }
                })
                .fail(function() {
                    updateJsonHandler.state = state;
                    result.reject();
                });
        }
        return result.promise();
    }
621252
protected JProgressBar getProgressBar() {
        if (progressBar == null) {
            progressBar = createProgressBar();
            Assert.notNull(progressBar, "createProgressBar should not return null");
        }
        return progressBar;
    }
1179766
private void deliverWaveformPreviewUpdate(final int player, final WaveformPreview preview) {
        final Set<WaveformListener> listeners = getWaveformListeners();
        if (!listeners.isEmpty()) {
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    final WaveformPreviewUpdate update = new WaveformPreviewUpdate(player, preview);
                    for (final WaveformListener listener : listeners) {
                        try {
                            listener.previewChanged(update);

                        } catch (Throwable t) {
                            logger.warn("Problem delivering waveform preview update to listener", t);
                        }
                    }
                }
            });
        }
    }
269181
public JMProgressiveManager<T, R>
			registerCountChangeListener(Consumer<Number> countChangeListener) {
		return registerListener(progressiveCount, countChangeListener);
	}
1065452
public boolean notifyProgress(int value, int maximum) {
    this.value = value;
    this.maximum = maximum;
    this.progress = (double) value / (double) maximum;
    return !isCancelPending();
  }
211754
private void updateProgress(DownloadRequest request, long bytesWritten, long totalBytes) {
    long currentTimestamp = System.currentTimeMillis();
    if (bytesWritten != totalBytes
        && currentTimestamp - lastProgressTimestamp < request.progressInterval()) {
      return;
    }

    /* save progress timestamp */
    lastProgressTimestamp = currentTimestamp;

    if (!request.isCanceled()) {
      delivery.postProgress(request, bytesWritten, totalBytes);
    }
  }
296599
public InputStream getBody(ProgressListener listener) {
        if (this.inputStream == null) {
            String contentEncoding = this.connection.getContentEncoding();
            try {
                if (this.rawInputStream == null) {
                    this.rawInputStream = this.connection.getInputStream();
                }

                if (listener == null) {
                    this.inputStream = this.rawInputStream;
                } else {
                    this.inputStream = new ProgressInputStream(this.rawInputStream, listener,
                        this.getContentLength());
                }

                if (contentEncoding != null && contentEncoding.equalsIgnoreCase("gzip")) {
                    this.inputStream = new GZIPInputStream(this.inputStream);
                }
            } catch (IOException e) {
                throw new BoxAPIException("Couldn't connect to the Box API due to a network error.", e);
            }
        }

        return this.inputStream;
    }
261582
function (progressListener) {
            var self = this, listeners = self[PROMISE_PROGRESS_LISTENERS];
            if (listeners === false) {
                return self;
            }
            if (!listeners) {
                listeners = self[PROMISE_PROGRESS_LISTENERS] = [];
            }
            listeners.push(progressListener);
            return self;
        }
676345
public BaseListener getNextEnabledListener()
    {
        if (m_listener != null)
        {
            if (m_listener.isEnabled())
                return m_listener;
            else
                return m_listener.getNextEnabledListener();
        }
        else
            return null;
    }
273972
public static void unregisterProgressListener(@NonNull final Context context, @NonNull final DfuProgressListener listener) {
		if (mProgressBroadcastReceiver != null) {
			final boolean empty = mProgressBroadcastReceiver.removeProgressListener(listener);

			if (empty) {
				LocalBroadcastManager.getInstance(context).unregisterReceiver(mProgressBroadcastReceiver);
				mProgressBroadcastReceiver = null;
			}
		}
	}
1016904
public synchronized boolean isDeleteInProgress()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
        {
            SibTr.entry(tc, "isDeleteInProgress");
            SibTr.exit(tc, "isDeleteInProgress", Boolean.valueOf(_deleteInProgress));
        }

        return _deleteInProgress;
    }
754393
@NonNull
    @Override
    public Loader<SortedList<File>> getLoader() {
        return new AsyncTaskLoader<SortedList<File>>(getActivity()) {

            FileObserver fileObserver;

            @Override
            public SortedList<File> loadInBackground() {
                File[] listFiles = mCurrentPath.listFiles();
                final int initCap = listFiles == null ? 0 : listFiles.length;

                SortedList<File> files = new SortedList<>(File.class, new SortedListAdapterCallback<File>(getDummyAdapter()) {
                    @Override
                    public int compare(File lhs, File rhs) {
                        return compareFiles(lhs, rhs);
                    }

                    @Override
                    public boolean areContentsTheSame(File file, File file2) {
                        return file.getAbsolutePath().equals(file2.getAbsolutePath()) && (file.isFile() == file2.isFile());
                    }

                    @Override
                    public boolean areItemsTheSame(File file, File file2) {
                        return areContentsTheSame(file, file2);
                    }
                }, initCap);


                files.beginBatchedUpdates();
                if (listFiles != null) {
                    for (java.io.File f : listFiles) {
                        if (isItemVisible(f)) {
                            files.add(f);
                        }
                    }
                }
                files.endBatchedUpdates();

                return files;
            }

            /**
             * Handles a request to start the Loader.
             */
            @Override
            protected void onStartLoading() {
                super.onStartLoading();

                // handle if directory does not exist. Fall back to root.
                if (mCurrentPath == null || !mCurrentPath.isDirectory()) {
                    mCurrentPath = getRoot();
                }

                // Start watching for changes
                fileObserver = new FileObserver(mCurrentPath.getPath(),
                        FileObserver.CREATE |
                                FileObserver.DELETE
                                | FileObserver.MOVED_FROM | FileObserver.MOVED_TO
                ) {

                    @Override
                    public void onEvent(int event, String path) {
                        // Reload
                        onContentChanged();
                    }
                };
                fileObserver.startWatching();

                forceLoad();
            }

            /**
             * Handles a request to completely reset the Loader.
             */
            @Override
            protected void onReset() {
                super.onReset();

                // Stop watching
                if (fileObserver != null) {
                    fileObserver.stopWatching();
                    fileObserver = null;
                }
            }
        };
    }
133866
public static Future<?> publishProgress(
            final ProgressListener listener,
            final ProgressEventType type) {
        if (listener == ProgressListener.NOOP || listener == null
        ||  type == null) {
            return null;
        }
        return deliverEvent(listener, new ProgressEvent(type));
    }
558953
public ByteSink getByteSink()
    {
        ByteSink bs = byteSink;
        if ( progressListener != null ) {
            bs = new ProgressByteSink( bs, progressListener );
        }
        return bs;
    }
434791
@SuppressWarnings({"checkstyle:npathcomplexity", "checkstyle:cyclomaticcomplexity",
		"checkstyle:returncount", "checkstyle:magicnumber"})
	public boolean compile(IProgressMonitor progress) {
		final IProgressMonitor monitor = progress == null ? new NullProgressMonitor() : progress;
		try {
			monitor.beginTask(Messages.SarlBatchCompiler_42, 18);
			if (!checkConfiguration(monitor)) {
				return false;
			}
			monitor.worked(1);
			final ResourceSet resourceSet = this.resourceSetProvider.get();
			configureExtraLanguageGenerators();
			if (!configureWorkspace(resourceSet, monitor)) {
				return false;
			}
			if (getLogger().isDebugEnabled()) {
				getLogger().debug(Utils.dump(getGeneratorConfig(), false));
			}
			monitor.worked(2);
			monitor.subTask(Messages.SarlBatchCompiler_43);
			if (this.generatorConfigProvider instanceof GeneratorConfigProvider) {
				((GeneratorConfigProvider) this.generatorConfigProvider).install(resourceSet, getGeneratorConfig());
			}
			if (monitor.isCanceled()) {
				return false;
			}
			if (this.generatorConfigProvider2 instanceof GeneratorConfigProvider2) {
				((GeneratorConfigProvider2) this.generatorConfigProvider2).install(resourceSet, getGeneratorConfig2());
			}
			if (getLogger().isDebugEnabled()) {
				getLogger().debug(Utils.dump(getGeneratorConfig2(), false));
			}
			if (monitor.isCanceled()) {
				return false;
			}
			monitor.worked(3);
			monitor.subTask(Messages.SarlBatchCompiler_44);
			final File stubClassDirectory = createTempDir(BINCLASS_FOLDER_PREFIX);
			if (monitor.isCanceled()) {
				return false;
			}
			monitor.worked(4);
			try {
				monitor.subTask(Messages.SarlBatchCompiler_45);
				this.compilerPhases.setIndexing(resourceSet, true);
				if (monitor.isCanceled()) {
					return false;
				}
				monitor.worked(5);
				// install a type provider without index lookup for the first phase
				installJvmTypeProvider(resourceSet, stubClassDirectory, true, monitor);
				if (monitor.isCanceled()) {
					return false;
				}
				monitor.worked(6);
				loadSARLFiles(resourceSet, monitor);
				if (monitor.isCanceled()) {
					return false;
				}
				monitor.worked(7);
				final File stubSourceDirectory = createStubs(resourceSet, monitor);
				if (monitor.isCanceled()) {
					return false;
				}
				monitor.worked(8);
				if (!preCompileStubs(stubSourceDirectory, stubClassDirectory, monitor)) {
					if (monitor.isCanceled()) {
						return false;
					}
					reportInternalWarning(Messages.SarlBatchCompiler_2);
				}
				monitor.worked(9);
				if (!preCompileJava(stubSourceDirectory, stubClassDirectory, monitor)) {
					if (monitor.isCanceled()) {
						return false;
					}
					if (getLogger().isDebugEnabled()) {
						getLogger().debug(Messages.SarlBatchCompiler_3);
					}
				}
				monitor.worked(10);
			} finally {
				monitor.subTask(Messages.SarlBatchCompiler_46);
				this.compilerPhases.setIndexing(resourceSet, false);
				if (monitor.isCanceled()) {
					return false;
				}
			}
			monitor.worked(11);
			// install a fresh type provider for the second phase, so we clear all previously cached classes and misses.
			installJvmTypeProvider(resourceSet, stubClassDirectory, false, monitor);
			if (monitor.isCanceled()) {
				return false;
			}
			monitor.worked(12);
			generateJvmElements(resourceSet, monitor);
			if (monitor.isCanceled()) {
				return false;
			}
			monitor.worked(13);
			final List<Resource> validatedResources = new ArrayList<>();
			final List<Issue> issues = validate(resourceSet, validatedResources, monitor);
			if (monitor.isCanceled()) {
				return false;
			}
			if (!issues.isEmpty()) {
				if (reportCompilationIssues(issues)) {
					return false;
				}
			}
			monitor.worked(14);
			overrideXtextInternalLoggers();
			generateJavaFiles(validatedResources, monitor);
			if (monitor.isCanceled()) {
				return false;
			}
			monitor.worked(15);
			if (isJavaPostCompilationEnable()) {
				postCompileJava(monitor);
				if (monitor.isCanceled()) {
					return false;
				}
			}
			monitor.worked(16);
		} finally {
			monitor.subTask(Messages.SarlBatchCompiler_47);
			destroyClassLoader(this.jvmTypesClassLoader);
			destroyClassLoader(this.annotationProcessingClassLoader);
			if (isDeleteTempDirectory()) {
				monitor.subTask(Messages.SarlBatchCompiler_48);
				for (final File file : this.tempFolders) {
					cleanFolder(file, ACCEPT_ALL_FILTER, true, true);
				}
			}
			unconfigureExtraLanguageGenerators();
			monitor.done();
		}
		return true;
	}