zip_progress.c File Reference

#include <stdlib.h>
#include "zipint.h"

Go to the source code of this file.

Classes
struct	zip_progress
struct	legacy_ud

Macros
#define	_ZIP_COMPILING_DEPRECATED

Functions
static void	_zip_progress_free_cancel_callback (zip_progress_t *progress)
static void	_zip_progress_free_progress_callback (zip_progress_t *progress)
static zip_progress_t *	_zip_progress_new (zip_t *za)
static void	_zip_progress_set_cancel_callback (zip_progress_t *progress, zip_cancel_callback callback, void(*ud_free)(void *), void *ud)
static void	_zip_progress_set_progress_callback (zip_progress_t *progress, double precision, zip_progress_callback callback, void(*ud_free)(void *), void *ud)
void	_zip_progress_end (zip_progress_t *progress)
void	_zip_progress_free (zip_progress_t *progress)
int	_zip_progress_start (zip_progress_t *progress)
int	_zip_progress_subrange (zip_progress_t *progress, double start, double end)
int	_zip_progress_update (zip_progress_t *progress, double sub_current)
ZIP_EXTERN int	zip_register_progress_callback_with_state (zip_t *za, double precision, zip_progress_callback callback, void(*ud_free)(void *), void *ud)
ZIP_EXTERN int	zip_register_cancel_callback_with_state (zip_t *za, zip_cancel_callback callback, void(*ud_free)(void *), void *ud)
static void	_zip_legacy_progress_callback (zip_t *za, double progress, void *vud)
ZIP_EXTERN void	zip_register_progress_callback (zip_t *za, zip_progress_callback_t progress_callback)

Macro Definition Documentation

_ZIP_COMPILING_DEPRECATED

#define _ZIP_COMPILING_DEPRECATED

Definition at line 38 of file zip_progress.c.

Function Documentation

_zip_legacy_progress_callback()

static void _zip_legacy_progress_callback ( zip_t *  za, double  progress, void *  vud  )

static

Definition at line 270 of file zip_progress.c.

                                                                     {
    struct legacy_ud *ud = (struct legacy_ud *)vud;
 
    ud->callback(progress);
}

References legacy_ud::callback.

Referenced by zip_register_progress_callback().

_zip_progress_end()

void _zip_progress_end

(

zip_progress_t *

progress

)

Definition at line 68 of file zip_progress.c.

                                            {
    _zip_progress_update(progress, 1.0);
}

References _zip_progress_update().

Referenced by zip_close().

_zip_progress_free()

void _zip_progress_free

(

zip_progress_t *

progress

)

Definition at line 74 of file zip_progress.c.

                                             {
    if (progress == NULL) {
        return;
    }
 
    _zip_progress_free_progress_callback(progress);
    _zip_progress_free_cancel_callback(progress);
 
    free(progress);
}

References _zip_progress_free_cancel_callback(), _zip_progress_free_progress_callback(), free(), and NULL.

Referenced by zip_discard(), zip_register_cancel_callback_with_state(), and zip_register_progress_callback_with_state().

_zip_progress_free_cancel_callback()

static void _zip_progress_free_cancel_callback ( zip_progress_t *  progress )

static

Definition at line 121 of file zip_progress.c.

                                                             {
    if (progress->ud_cancel_free) {
        progress->ud_cancel_free(progress->ud_cancel);
    }
 
    progress->callback_cancel = NULL;
    progress->ud_cancel = NULL;
    progress->ud_cancel_free = NULL;
}

References zip_progress::callback_cancel, NULL, zip_progress::ud_cancel, and zip_progress::ud_cancel_free.

Referenced by _zip_progress_free(), _zip_progress_set_cancel_callback(), and zip_register_cancel_callback_with_state().

_zip_progress_free_progress_callback()

static void _zip_progress_free_progress_callback ( zip_progress_t *  progress )

static

Definition at line 110 of file zip_progress.c.

                                                               {
    if (progress->ud_progress_free) {
        progress->ud_progress_free(progress->ud_progress);
    }
 
    progress->callback_progress = NULL;
    progress->ud_progress = NULL;
    progress->ud_progress_free = NULL;
}

References zip_progress::callback_progress, NULL, zip_progress::ud_progress, and zip_progress::ud_progress_free.

Referenced by _zip_progress_free(), _zip_progress_set_progress_callback(), and zip_register_progress_callback_with_state().

_zip_progress_new()

static zip_progress_t * _zip_progress_new ( zip_t *  za )

static

Definition at line 87 of file zip_progress.c.

                             {
    zip_progress_t *progress = (zip_progress_t *)malloc(sizeof(*progress));
 
    if (progress == NULL) {
        zip_error_set(&za->error, ZIP_ER_MEMORY, 0);
        return NULL;
    }
 
    progress->za = za;
 
    progress->callback_progress = NULL;
    progress->ud_progress_free = NULL;
    progress->ud_progress = NULL;
    progress->precision = 0.0;
 
    progress->callback_cancel = NULL;
    progress->ud_cancel_free = NULL;
    progress->ud_cancel = NULL;
 
    return progress;
}

References zip_progress::callback_cancel, zip_progress::callback_progress, zip::error, malloc(), NULL, zip_progress::precision, zip_progress::ud_cancel, zip_progress::ud_cancel_free, zip_progress::ud_progress, zip_progress::ud_progress_free, zip_progress::za, za, ZIP_ER_MEMORY, and zip_error_set().

Referenced by zip_register_cancel_callback_with_state(), and zip_register_progress_callback_with_state().

_zip_progress_set_cancel_callback()

void _zip_progress_set_cancel_callback ( zip_progress_t *  progress, zip_cancel_callback  callback, void(*)(void *)  ud_free, void *  ud  )

static

Definition at line 142 of file zip_progress.c.

                                                                                                                             {
    _zip_progress_free_cancel_callback(progress);
 
    progress->callback_cancel = callback;
    progress->ud_cancel_free = ud_free;
    progress->ud_cancel = ud;
}

References _zip_progress_free_cancel_callback(), zip_progress::callback_cancel, zip_progress::ud_cancel, and zip_progress::ud_cancel_free.

Referenced by zip_register_cancel_callback_with_state().

_zip_progress_set_progress_callback()

static void _zip_progress_set_progress_callback ( zip_progress_t *  progress, double  precision, zip_progress_callback  callback, void(*)(void *)  ud_free, void *  ud  )

static

Definition at line 132 of file zip_progress.c.

                                                                                                                                                   {
    _zip_progress_free_progress_callback(progress);
 
    progress->callback_progress = callback;
    progress->ud_progress_free = ud_free;
    progress->ud_progress = ud;
    progress->precision = precision;
}

References _zip_progress_free_progress_callback(), zip_progress::callback_progress, zip_progress::precision, zip_progress::ud_progress, and zip_progress::ud_progress_free.

Referenced by zip_register_progress_callback_with_state().

_zip_progress_start()

int _zip_progress_start

(

zip_progress_t *

progress

)

Definition at line 151 of file zip_progress.c.

                                              {
    if (progress == NULL) {
        return 0;
    }
 
    if (progress->callback_progress != NULL) {
        progress->last_update = 0.0;
        progress->callback_progress(progress->za, 0.0, progress->ud_progress);
    }
 
    if (progress->callback_cancel != NULL) {
        if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
            return -1;
        }
    }
 
    return 0;
}

References zip_progress::callback_cancel, zip_progress::callback_progress, zip_progress::last_update, NULL, zip_progress::ud_cancel, zip_progress::ud_progress, and zip_progress::za.

Referenced by zip_close().

_zip_progress_subrange()

int _zip_progress_subrange	(	zip_progress_t *	progress,
		double	start,
		double	end
	)

Definition at line 172 of file zip_progress.c.

                                                                           {
    if (progress == NULL) {
        return 0;
    }
 
    progress->start = start;
    progress->end = end;
 
    return _zip_progress_update(progress, 0.0);
}

References _zip_progress_update(), test_evm::end, zip_progress::end, NULL, start, and zip_progress::start.

Referenced by zip_close().

_zip_progress_update()

int _zip_progress_update	(	zip_progress_t *	progress,
		double	sub_current
	)

Definition at line 184 of file zip_progress.c.

                                                                   {
    double current;
 
    if (progress == NULL) {
        return 0;
    }
 
    if (progress->callback_progress != NULL) {
        current = ZIP_MIN(ZIP_MAX(sub_current, 0.0), 1.0) * (progress->end - progress->start) + progress->start;
 
        if (current - progress->last_update > progress->precision) {
            progress->callback_progress(progress->za, current, progress->ud_progress);
            progress->last_update = current;
        }
    }
 
    if (progress->callback_cancel != NULL) {
        if (progress->callback_cancel(progress->za, progress->ud_cancel)) {
            return -1;
        }
    }
 
    return 0;
}

References zip_progress::callback_cancel, zip_progress::callback_progress, zip_progress::end, if(), zip_progress::last_update, NULL, zip_progress::precision, zip_progress::start, zip_progress::ud_cancel, zip_progress::ud_progress, zip_progress::za, ZIP_MAX, and ZIP_MIN.

Referenced by _zip_progress_end(), _zip_progress_subrange(), copy_data(), and copy_source().

zip_register_cancel_callback_with_state()

ZIP_EXTERN int zip_register_cancel_callback_with_state	(	zip_t *	za,
		zip_cancel_callback	callback,
		void(*)(void *)	ud_free,
		void *	ud
	)

Definition at line 238 of file zip_progress.c.

                                                                                                                    {
    if (callback != NULL) {
        if (za->progress == NULL) {
            if ((za->progress = _zip_progress_new(za)) == NULL) {
                return -1;
            }
        }
 
        _zip_progress_set_cancel_callback(za->progress, callback, ud_free, ud);
    }
    else {
        if (za->progress != NULL) {
            if (za->progress->callback_progress == NULL) {
                _zip_progress_free(za->progress);
                za->progress = NULL;
            }
            else {
                _zip_progress_free_cancel_callback(za->progress);
            }
        }
    }
 
    return 0;
}

References _zip_progress_free(), _zip_progress_free_cancel_callback(), _zip_progress_new(), _zip_progress_set_cancel_callback(), zip_progress::callback_progress, NULL, zip::progress, and za.

zip_register_progress_callback()

ZIP_EXTERN void zip_register_progress_callback	(	zip_t *	za,
		zip_progress_callback_t	progress_callback
	)

Definition at line 277 of file zip_progress.c.

                                                                                     {
    struct legacy_ud *ud;
 
    if (progress_callback == NULL) {
        zip_register_progress_callback_with_state(za, 0, NULL, NULL, NULL);
    }
 
    if ((ud = (struct legacy_ud *)malloc(sizeof(*ud))) == NULL) {
        return;
    }
 
    ud->callback = progress_callback;
 
    if (zip_register_progress_callback_with_state(za, 0.001, _zip_legacy_progress_callback, free, ud) < 0) {
        free(ud);
    }
}

References _zip_legacy_progress_callback(), legacy_ud::callback, free(), malloc(), NULL, progress_callback(), za, and zip_register_progress_callback_with_state().

zip_register_progress_callback_with_state()

ZIP_EXTERN int zip_register_progress_callback_with_state	(	zip_t *	za,
		double	precision,
		zip_progress_callback	callback,
		void(*)(void *)	ud_free,
		void *	ud
	)

Definition at line 211 of file zip_progress.c.

                                                                                                                                          {
    if (callback != NULL) {
        if (za->progress == NULL) {
            if ((za->progress = _zip_progress_new(za)) == NULL) {
                return -1;
            }
        }
 
        _zip_progress_set_progress_callback(za->progress, precision, callback, ud_free, ud);
    }
    else {
        if (za->progress != NULL) {
            if (za->progress->callback_cancel == NULL) {
                _zip_progress_free(za->progress);
                za->progress = NULL;
            }
            else {
                _zip_progress_free_progress_callback(za->progress);
            }
        }
    }
 
    return 0;
}

References _zip_progress_free(), _zip_progress_free_progress_callback(), _zip_progress_new(), _zip_progress_set_progress_callback(), zip_progress::callback_cancel, NULL, zip::progress, and za.

Referenced by zip_register_progress_callback().