* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
/* EIO - EFL data type library
|
|
|
|
* Copyright (C) 2010 Enlightenment Developers:
|
|
|
|
* Cedric Bail <cedric.bail@free.fr>
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* Lesser General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
|
|
* License along with this library;
|
|
|
|
* if not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
2010-10-20 22:03:23 -07:00
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
#include "eio_private.h"
|
|
|
|
#include "Eio.h"
|
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/*============================================================================*
|
|
|
|
* Local *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @cond LOCAL
|
|
|
|
*/
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
static int
|
|
|
|
eio_strcmp(const void *a, const void *b)
|
|
|
|
{
|
|
|
|
return strcmp(a, b);
|
|
|
|
}
|
2011-02-17 07:59:07 -08:00
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_recursive_progress(Eio_Dir_Copy *copy, Eio_File *handler, const Eina_File_Direct_Info *info)
|
|
|
|
{
|
2011-03-09 08:21:11 -08:00
|
|
|
if (copy->filter_cb && !copy->filter_cb(©->progress.common.data, handler, info))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
switch (info->type)
|
|
|
|
{
|
|
|
|
case EINA_FILE_UNKNOWN:
|
|
|
|
eio_file_thread_error(©->progress.common, handler->thread);
|
|
|
|
return EINA_FALSE;
|
|
|
|
case EINA_FILE_LNK:
|
|
|
|
copy->links = eina_list_append(copy->links, eina_stringshare_add(info->path));
|
|
|
|
break;
|
|
|
|
case EINA_FILE_DIR:
|
|
|
|
copy->dirs = eina_list_append(copy->dirs, eina_stringshare_add(info->path));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
copy->files = eina_list_append(copy->files, eina_stringshare_add(info->path));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
static Eina_Bool
|
2011-02-17 07:59:07 -08:00
|
|
|
_eio_file_recursiv_ls(Ecore_Thread *thread,
|
|
|
|
Eio_File *common,
|
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
2012-02-22 01:30:43 -08:00
|
|
|
Eina_Iterator *(*Eina_File_Ls)(const char *target),
|
2011-02-17 07:59:07 -08:00
|
|
|
void *data,
|
|
|
|
const char *target)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
2011-02-17 07:59:07 -08:00
|
|
|
Eina_File_Direct_Info *info;
|
|
|
|
Eina_Iterator *it = NULL;
|
|
|
|
Eina_List *dirs = NULL;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
const char *dir;
|
|
|
|
|
2012-02-22 01:30:43 -08:00
|
|
|
it = Eina_File_Ls(target);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
if (!it)
|
|
|
|
{
|
2011-02-17 07:59:07 -08:00
|
|
|
eio_file_thread_error(common, thread);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(common, eina_iterator_container_get(it));
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
EINA_ITERATOR_FOREACH(it, info)
|
|
|
|
{
|
2011-02-17 07:59:07 -08:00
|
|
|
Eina_Bool filter = EINA_TRUE;
|
|
|
|
struct stat buffer;
|
|
|
|
|
2010-10-29 22:59:39 -07:00
|
|
|
switch (info->type)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
2010-11-03 05:35:21 -07:00
|
|
|
case EINA_FILE_DIR:
|
|
|
|
if (lstat(info->path, &buffer) != 0)
|
|
|
|
goto on_error;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
if (S_ISLNK(buffer.st_mode))
|
|
|
|
info->type = EINA_FILE_LNK;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
filter = filter_cb(data, common, info);
|
|
|
|
if (filter && info->type == EINA_FILE_DIR)
|
|
|
|
dirs = eina_list_append(dirs, eina_stringshare_add(info->path));
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
2011-05-24 03:41:37 -07:00
|
|
|
eio_file_container_set(common, NULL);
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
eina_iterator_free(it);
|
2011-02-17 07:59:07 -08:00
|
|
|
it = NULL;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2012-02-20 06:06:04 -08:00
|
|
|
EINA_LIST_FREE(dirs, dir)
|
|
|
|
{
|
|
|
|
Eina_Bool err;
|
|
|
|
|
2012-02-22 01:30:43 -08:00
|
|
|
err = !_eio_file_recursiv_ls(thread, common, filter_cb, Eina_File_Ls, data, dir);
|
2012-02-20 06:06:04 -08:00
|
|
|
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
if (err) goto on_error;
|
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
2011-02-17 07:59:07 -08:00
|
|
|
if (it) eina_iterator_free(it);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
EINA_LIST_FREE(dirs, dir)
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_recursiv_ls(Ecore_Thread *thread, Eio_Dir_Copy *copy, const char *target)
|
|
|
|
{
|
|
|
|
if (!_eio_file_recursiv_ls(thread, ©->progress.common,
|
|
|
|
(Eio_Filter_Direct_Cb) _eio_dir_recursive_progress,
|
2012-02-22 01:30:43 -08:00
|
|
|
eina_file_stat_ls,
|
2011-02-17 07:59:07 -08:00
|
|
|
copy, target))
|
|
|
|
return EINA_FALSE;
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_init(Ecore_Thread *thread,
|
2011-03-09 06:53:55 -08:00
|
|
|
long long *step, long long *count,
|
2010-10-20 05:09:58 -07:00
|
|
|
int *length_source, int *length_dest,
|
|
|
|
Eio_Dir_Copy *order,
|
|
|
|
Eio_File_Progress *progress)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
|
|
|
struct stat buffer;
|
|
|
|
|
|
|
|
/* notify main thread of the amount of work todo */
|
2010-10-20 05:09:58 -07:00
|
|
|
*step = 0;
|
2010-11-03 05:35:21 -07:00
|
|
|
*count = eina_list_count(order->files)
|
|
|
|
+ eina_list_count(order->dirs) * 2
|
|
|
|
+ eina_list_count(order->links);
|
2010-10-20 05:09:58 -07:00
|
|
|
eio_progress_send(thread, &order->progress, *step, *count);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
/* sort the content, so we create the directory in the right order */
|
2010-10-20 05:09:58 -07:00
|
|
|
order->dirs = eina_list_sort(order->dirs, -1, eio_strcmp);
|
|
|
|
order->files = eina_list_sort(order->files, -1, eio_strcmp);
|
2010-11-03 05:35:21 -07:00
|
|
|
order->links = eina_list_sort(order->links, -1, eio_strcmp);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
/* prepare stuff */
|
2010-10-20 05:09:58 -07:00
|
|
|
*length_source = eina_stringshare_strlen(order->progress.source);
|
|
|
|
*length_dest = eina_stringshare_strlen(order->progress.dest);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
memcpy(progress, &order->progress, sizeof (Eio_File_Progress));
|
|
|
|
progress->source = NULL;
|
|
|
|
progress->dest = NULL;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
/* create destination dir if not available */
|
2010-10-20 05:09:58 -07:00
|
|
|
if (stat(order->progress.dest, &buffer) != 0)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
if (stat(order->progress.source, &buffer) != 0)
|
2010-10-13 10:46:02 -07:00
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
eio_file_thread_error(&order->progress.common, thread);
|
|
|
|
return EINA_FALSE;
|
2010-10-13 10:46:02 -07:00
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
if (mkdir(order->progress.dest, buffer.st_mode) != 0)
|
2010-10-13 10:46:02 -07:00
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
eio_file_thread_error(&order->progress.common, thread);
|
|
|
|
return EINA_FALSE;
|
2010-10-13 10:46:02 -07:00
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_target(Eio_Dir_Copy *order, char *target, const char *dir, int length_source, int length_dest)
|
|
|
|
{
|
|
|
|
int length;
|
|
|
|
|
|
|
|
length = eina_stringshare_strlen(dir);
|
|
|
|
|
|
|
|
memcpy(target, order->progress.dest, length_dest);
|
|
|
|
target[length_dest] = '/';
|
|
|
|
memcpy(target + length_dest + 1, dir + length_source, length - length_source + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_mkdir(Ecore_Thread *thread, Eio_Dir_Copy *order,
|
2011-03-09 06:53:55 -08:00
|
|
|
long long *step, long long count,
|
2010-10-20 05:09:58 -07:00
|
|
|
int length_source, int length_dest)
|
|
|
|
{
|
|
|
|
const char *dir;
|
|
|
|
Eina_List *l;
|
|
|
|
char target[PATH_MAX];
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
/* create all directory */
|
2010-10-20 05:09:58 -07:00
|
|
|
EINA_LIST_FOREACH(order->dirs, l, dir)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
|
|
|
/* build target dir path */
|
2010-10-20 05:09:58 -07:00
|
|
|
_eio_dir_target(order, target, dir, length_source, length_dest);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* create the directory (we will apply the mode later) */
|
|
|
|
if (mkdir(target, 0777) != 0)
|
2010-10-13 10:46:02 -07:00
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
eio_file_thread_error(&order->progress.common, thread);
|
|
|
|
return EINA_FALSE;
|
2010-10-13 10:46:02 -07:00
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* inform main thread */
|
|
|
|
(*step)++;
|
|
|
|
eio_progress_send(thread, &order->progress, *step, count);
|
|
|
|
|
|
|
|
/* check for cancel request */
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
}
|
|
|
|
|
2010-11-03 05:35:21 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_link(Ecore_Thread *thread, Eio_Dir_Copy *order,
|
2011-03-09 06:53:55 -08:00
|
|
|
long long *step, long long count,
|
2010-11-03 05:35:21 -07:00
|
|
|
int length_source, int length_dest)
|
|
|
|
{
|
2011-04-25 10:01:26 -07:00
|
|
|
const char *ln;
|
2010-11-03 05:35:21 -07:00
|
|
|
Eina_List *l;
|
|
|
|
char oldpath[PATH_MAX];
|
|
|
|
char target[PATH_MAX];
|
|
|
|
char buffer[PATH_MAX];
|
|
|
|
char *newpath;
|
|
|
|
|
|
|
|
/* Build once the base of the link target */
|
|
|
|
memcpy(buffer, order->progress.dest, length_dest);
|
|
|
|
buffer[length_dest] = '/';
|
|
|
|
|
|
|
|
/* recreate all links */
|
2011-04-25 10:01:26 -07:00
|
|
|
EINA_LIST_FOREACH(order->links, l, ln)
|
2010-11-03 05:35:21 -07:00
|
|
|
{
|
|
|
|
ssize_t length;
|
|
|
|
|
|
|
|
/* build oldpath link */
|
2011-04-25 10:01:26 -07:00
|
|
|
_eio_dir_target(order, oldpath, ln, length_source, length_dest);
|
2010-11-03 05:35:21 -07:00
|
|
|
|
|
|
|
/* read link target */
|
2011-04-25 10:01:26 -07:00
|
|
|
length = readlink(ln, target, PATH_MAX);
|
2010-11-03 05:35:21 -07:00
|
|
|
if (length < 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
if (strncmp(target, order->progress.source, length_source) == 0)
|
|
|
|
{
|
|
|
|
/* The link is inside the zone to copy, so rename it */
|
|
|
|
memcpy(buffer + length_dest + 1, target + length_source, length - length_source + 1);
|
|
|
|
newpath = target;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* The link is outside the zone to copy */
|
|
|
|
newpath = target;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* create the link */
|
2011-02-17 07:59:07 -08:00
|
|
|
if (symlink(newpath, oldpath) != 0)
|
2010-11-03 05:35:21 -07:00
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* inform main thread */
|
|
|
|
(*step)++;
|
|
|
|
eio_progress_send(thread, &order->progress, *step, count);
|
|
|
|
|
|
|
|
/* check for cancel request */
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
eio_file_thread_error(&order->progress.common, thread);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
static Eina_Bool
|
|
|
|
_eio_dir_chmod(Ecore_Thread *thread, Eio_Dir_Copy *order,
|
2011-03-09 06:53:55 -08:00
|
|
|
long long *step, long long count,
|
2010-10-20 05:09:58 -07:00
|
|
|
int length_source, int length_dest,
|
|
|
|
Eina_Bool rmdir_source)
|
|
|
|
{
|
|
|
|
const char *dir;
|
|
|
|
char target[PATH_MAX];
|
|
|
|
struct stat buffer;
|
|
|
|
|
|
|
|
while(order->dirs)
|
|
|
|
{
|
|
|
|
/* destroy in reverse order so that we don't prevent change of lower dir */
|
|
|
|
dir = eina_list_data_get(eina_list_last(order->dirs));
|
|
|
|
order->dirs = eina_list_remove_list(order->dirs, eina_list_last(order->dirs));
|
|
|
|
|
|
|
|
/* build target dir path */
|
|
|
|
_eio_dir_target(order, target, dir, length_source, length_dest);
|
|
|
|
|
|
|
|
/* FIXME: in some case we already did a stat call, so would be nice to reuse previous result here */
|
|
|
|
/* stat the original dir for mode info */
|
|
|
|
if (stat(dir, &buffer) != 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* set the orginal mode to the newly created dir */
|
|
|
|
if (chmod(target, buffer.st_mode) != 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* if required destroy original directory */
|
|
|
|
if (rmdir_source)
|
2010-10-13 10:46:02 -07:00
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
if (rmdir(dir) != 0)
|
|
|
|
goto on_error;
|
2010-10-13 10:46:02 -07:00
|
|
|
}
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* inform main thread */
|
|
|
|
(*step)++;
|
|
|
|
eio_progress_send(thread, &order->progress, *step, count);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* check for cancel request */
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
if (ecore_thread_check(thread))
|
2010-10-20 05:09:58 -07:00
|
|
|
goto on_cancel;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
return EINA_TRUE;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
eio_file_thread_error(&order->progress.common, thread);
|
|
|
|
on_cancel:
|
|
|
|
if (dir) eina_stringshare_del(dir);
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_copy_heavy(void *data, Ecore_Thread *thread)
|
2010-10-20 05:09:58 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *copy = data;
|
|
|
|
const char *file = NULL;
|
2010-11-03 05:35:21 -07:00
|
|
|
const char *dir;
|
2011-04-25 10:01:26 -07:00
|
|
|
const char *ln;
|
2010-10-20 05:09:58 -07:00
|
|
|
|
|
|
|
Eio_File_Progress file_copy;
|
|
|
|
char target[PATH_MAX];
|
|
|
|
|
|
|
|
int length_source = 0;
|
|
|
|
int length_dest = 0;
|
2011-03-09 06:53:55 -08:00
|
|
|
long long count;
|
|
|
|
long long step;
|
2010-10-20 05:09:58 -07:00
|
|
|
|
|
|
|
/* list all the content that should be copied */
|
|
|
|
if (!_eio_dir_recursiv_ls(thread, copy, copy->progress.source))
|
|
|
|
return ;
|
|
|
|
|
|
|
|
/* init all structure needed to copy the file */
|
|
|
|
if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, copy, &file_copy))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* suboperation is a file copy */
|
|
|
|
file_copy.op = EIO_FILE_COPY;
|
|
|
|
|
|
|
|
/* create all directory */
|
|
|
|
if (!_eio_dir_mkdir(thread, copy, &step, count, length_source, length_dest))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* copy all files */
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
EINA_LIST_FREE(copy->files, file)
|
|
|
|
{
|
2010-10-20 05:09:58 -07:00
|
|
|
/* build target file path */
|
|
|
|
_eio_dir_target(copy, target, file, length_source, length_dest);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
file_copy.source = file;
|
|
|
|
file_copy.dest = eina_stringshare_add(target);
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* copy the file */
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
if (!eio_file_copy_do(thread, &file_copy))
|
|
|
|
{
|
|
|
|
copy->progress.common.error = file_copy.common.error;
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* notify main thread */
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
step++;
|
|
|
|
eio_progress_send(thread, ©->progress, step, count);
|
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
eina_stringshare_del(file_copy.dest);
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
}
|
|
|
|
file_copy.dest = NULL;
|
|
|
|
file = NULL;
|
|
|
|
|
2010-11-03 05:35:21 -07:00
|
|
|
/* recreate link */
|
|
|
|
if (!_eio_dir_link(thread, copy, &step, count, length_source, length_dest))
|
|
|
|
goto on_error;
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* set directory right back */
|
|
|
|
if (!_eio_dir_chmod(thread, copy, &step, count, length_source, length_dest, EINA_FALSE))
|
|
|
|
goto on_error;
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
on_error:
|
|
|
|
/* cleanup the mess */
|
|
|
|
if (file_copy.dest) eina_stringshare_del(file_copy.dest);
|
|
|
|
if (file) eina_stringshare_del(file);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(copy->files, file)
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
EINA_LIST_FREE(copy->dirs, dir)
|
|
|
|
eina_stringshare_del(dir);
|
2011-04-25 10:01:26 -07:00
|
|
|
EINA_LIST_FREE(copy->links, ln)
|
|
|
|
eina_stringshare_del(ln);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
if (!ecore_thread_check(thread))
|
|
|
|
eio_progress_send(thread, ©->progress, count, count);
|
|
|
|
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_copy_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *copy = data;
|
|
|
|
Eio_Progress *progress = msg_data;
|
|
|
|
|
|
|
|
eio_progress_cb(progress, ©->progress);
|
|
|
|
}
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
static void
|
|
|
|
_eio_dir_copy_free(Eio_Dir_Copy *copy)
|
|
|
|
{
|
|
|
|
eina_stringshare_del(copy->progress.source);
|
|
|
|
eina_stringshare_del(copy->progress.dest);
|
|
|
|
free(copy);
|
|
|
|
}
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_copy_end(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *copy = data;
|
|
|
|
|
2010-11-12 06:08:01 -08:00
|
|
|
copy->progress.common.done_cb((void*) copy->progress.common.data, ©->progress.common);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_dir_copy_free(copy);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_copy_error(void *data, Ecore_Thread *thread __UNUSED__)
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *copy = data;
|
|
|
|
|
|
|
|
eio_file_error(©->progress.common);
|
|
|
|
|
2010-10-06 02:54:00 -07:00
|
|
|
_eio_dir_copy_free(copy);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_move_heavy(void *data, Ecore_Thread *thread)
|
2010-10-20 05:09:58 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *move = data;
|
|
|
|
const char *file = NULL;
|
|
|
|
const char *dir = NULL;
|
|
|
|
|
|
|
|
Eio_File_Progress file_move;
|
|
|
|
char target[PATH_MAX];
|
|
|
|
|
|
|
|
int length_source;
|
|
|
|
int length_dest;
|
2011-03-09 06:53:55 -08:00
|
|
|
long long count;
|
|
|
|
long long step;
|
2010-10-20 05:09:58 -07:00
|
|
|
|
|
|
|
/* just try a rename, maybe we are lucky... */
|
|
|
|
if (rename(move->progress.source, move->progress.dest) == 0)
|
|
|
|
{
|
|
|
|
/* we are really lucky */
|
|
|
|
eio_progress_send(thread, &move->progress, 1, 1);
|
|
|
|
return ;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* list all the content that should be moved */
|
|
|
|
if (!_eio_dir_recursiv_ls(thread, move, move->progress.source))
|
|
|
|
return ;
|
|
|
|
|
|
|
|
/* init all structure needed to move the file */
|
|
|
|
if (!_eio_dir_init(thread, &step, &count, &length_source, &length_dest, move, &file_move))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* sub operation is a file move */
|
|
|
|
file_move.op = EIO_FILE_MOVE;
|
|
|
|
|
|
|
|
/* create all directory */
|
|
|
|
if (!_eio_dir_mkdir(thread, move, &step, count, length_source, length_dest))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
/* move file around */
|
|
|
|
EINA_LIST_FREE(move->files, file)
|
|
|
|
{
|
|
|
|
/* build target file path */
|
|
|
|
_eio_dir_target(move, target, file, length_source, length_dest);
|
|
|
|
|
|
|
|
file_move.source = file;
|
|
|
|
file_move.dest = eina_stringshare_add(target);
|
|
|
|
|
|
|
|
/* first try to rename */
|
|
|
|
if (rename(file_move.source, file_move.dest) < 0)
|
|
|
|
{
|
|
|
|
if (errno != EXDEV)
|
|
|
|
{
|
|
|
|
eio_file_thread_error(&move->progress.common, thread);
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* then try real copy */
|
|
|
|
if (!eio_file_copy_do(thread, &file_move))
|
|
|
|
{
|
|
|
|
move->progress.common.error = file_move.common.error;
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* and unlink the original */
|
|
|
|
if (unlink(file) != 0)
|
|
|
|
{
|
|
|
|
eio_file_thread_error(&move->progress.common, thread);
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
step++;
|
|
|
|
eio_progress_send(thread, &move->progress, step, count);
|
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
eina_stringshare_del(file_move.dest);
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
}
|
|
|
|
file_move.dest = NULL;
|
|
|
|
file = NULL;
|
|
|
|
|
2010-11-03 05:35:21 -07:00
|
|
|
/* recreate link */
|
|
|
|
if (!_eio_dir_link(thread, move, &step, count, length_source, length_dest))
|
|
|
|
goto on_error;
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
/* set directory right back */
|
|
|
|
if (!_eio_dir_chmod(thread, move, &step, count, length_source, length_dest, EINA_TRUE))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
if (rmdir(move->progress.source) != 0)
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
/* cleanup the mess */
|
|
|
|
if (file_move.dest) eina_stringshare_del(file_move.dest);
|
|
|
|
if (file) eina_stringshare_del(file);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(move->files, file)
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
EINA_LIST_FREE(move->dirs, dir)
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
|
|
|
|
if (!ecore_thread_check(thread))
|
|
|
|
eio_progress_send(thread, &move->progress, count, count);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
2010-10-12 07:59:30 -07:00
|
|
|
|
2010-10-20 06:48:13 -07:00
|
|
|
static void
|
2010-11-12 05:28:19 -08:00
|
|
|
_eio_dir_rmrf_heavy(void *data, Ecore_Thread *thread)
|
2010-10-20 06:48:13 -07:00
|
|
|
{
|
|
|
|
Eio_Dir_Copy *rmrf = data;
|
|
|
|
const char *file = NULL;
|
|
|
|
const char *dir = NULL;
|
|
|
|
|
2011-03-09 06:53:55 -08:00
|
|
|
long long count;
|
|
|
|
long long step;
|
2010-10-20 06:48:13 -07:00
|
|
|
|
|
|
|
/* list all the content that should be moved */
|
|
|
|
if (!_eio_dir_recursiv_ls(thread, rmrf, rmrf->progress.source))
|
|
|
|
return ;
|
|
|
|
|
|
|
|
/* init counter */
|
|
|
|
step = 0;
|
|
|
|
count = eina_list_count(rmrf->files) + eina_list_count(rmrf->dirs) + 1;
|
|
|
|
|
|
|
|
EINA_LIST_FREE(rmrf->files, file)
|
|
|
|
{
|
|
|
|
if (unlink(file) != 0)
|
|
|
|
{
|
|
|
|
eio_file_thread_error(&rmrf->progress.common, thread);
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_stringshare_replace(&rmrf->progress.dest, file);
|
|
|
|
|
|
|
|
step++;
|
|
|
|
eio_progress_send(thread, &rmrf->progress, step, count);
|
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
}
|
|
|
|
file = NULL;
|
|
|
|
|
2011-04-19 08:27:21 -07:00
|
|
|
/* reverse directory listing, so the leaf would be destroyed before
|
|
|
|
the root */
|
|
|
|
rmrf->dirs = eina_list_reverse(rmrf->dirs);
|
|
|
|
|
2010-10-20 06:48:13 -07:00
|
|
|
EINA_LIST_FREE(rmrf->dirs, dir)
|
|
|
|
{
|
|
|
|
if (rmdir(dir) != 0)
|
|
|
|
{
|
|
|
|
eio_file_thread_error(&rmrf->progress.common, thread);
|
|
|
|
goto on_error;
|
|
|
|
}
|
|
|
|
|
|
|
|
eina_stringshare_replace(&rmrf->progress.dest, dir);
|
|
|
|
|
|
|
|
step++;
|
|
|
|
eio_progress_send(thread, &rmrf->progress, step, count);
|
|
|
|
|
|
|
|
if (ecore_thread_check(thread))
|
|
|
|
goto on_error;
|
|
|
|
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
}
|
|
|
|
dir = NULL;
|
|
|
|
|
|
|
|
if (rmdir(rmrf->progress.source) != 0)
|
|
|
|
goto on_error;
|
|
|
|
step++;
|
|
|
|
|
|
|
|
on_error:
|
|
|
|
if (dir) eina_stringshare_del(dir);
|
|
|
|
if (file) eina_stringshare_del(file);
|
|
|
|
|
|
|
|
EINA_LIST_FREE(rmrf->dirs, dir)
|
|
|
|
eina_stringshare_del(dir);
|
|
|
|
EINA_LIST_FREE(rmrf->files, file)
|
|
|
|
eina_stringshare_del(file);
|
|
|
|
|
|
|
|
if (!ecore_thread_check(thread))
|
|
|
|
eio_progress_send(thread, &rmrf->progress, count, count);
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
static Eina_Bool
|
2012-02-22 03:51:45 -08:00
|
|
|
_eio_dir_stat_find_forward(Eio_File_Dir_Ls *async,
|
2011-02-17 07:59:07 -08:00
|
|
|
Eio_File *handler,
|
2012-02-22 03:51:45 -08:00
|
|
|
Eina_File_Direct_Info *info)
|
2011-02-17 07:59:07 -08:00
|
|
|
{
|
|
|
|
Eina_Bool filter = EINA_TRUE;
|
2011-08-29 04:20:27 -07:00
|
|
|
double current;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
if (async->filter_cb)
|
|
|
|
{
|
|
|
|
filter = async->filter_cb((void*) async->ls.common.data, &async->ls.common, info);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (filter)
|
|
|
|
{
|
2011-06-22 09:09:14 -07:00
|
|
|
Eio_File_Direct_Info *send;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
send = eio_direct_info_malloc();
|
|
|
|
if (!send) return EINA_FALSE;
|
|
|
|
|
2011-06-22 09:09:14 -07:00
|
|
|
memcpy(&send->info, info, sizeof (Eina_File_Direct_Info));
|
2011-08-29 04:20:27 -07:00
|
|
|
send->associated = async->ls.common.worker.associated;
|
|
|
|
async->ls.common.worker.associated = NULL;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
2011-08-29 04:20:27 -07:00
|
|
|
async->pack = eina_list_append(async->pack, send);
|
|
|
|
}
|
|
|
|
else if (async->ls.common.worker.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.worker.associated);
|
|
|
|
async->ls.common.worker.associated = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
current = ecore_time_get();
|
|
|
|
if (current - async->start > EIO_PACKED_TIME)
|
|
|
|
{
|
|
|
|
async->start = current;
|
|
|
|
ecore_thread_feedback(handler->thread, async->pack);
|
|
|
|
async->pack = NULL;
|
2011-02-17 07:59:07 -08:00
|
|
|
}
|
|
|
|
|
2012-02-22 04:46:51 -08:00
|
|
|
return filter;
|
2011-02-17 07:59:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_stat_find_heavy(void *data, Ecore_Thread *thread)
|
|
|
|
{
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_File_Dir_Ls *async = data;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
async->ls.common.thread = thread;
|
2011-08-29 04:20:27 -07:00
|
|
|
async->pack = NULL;
|
|
|
|
async->start = ecore_time_get();
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
_eio_file_recursiv_ls(thread, &async->ls.common,
|
|
|
|
(Eio_Filter_Direct_Cb) _eio_dir_stat_find_forward,
|
2012-02-22 01:30:43 -08:00
|
|
|
eina_file_stat_ls,
|
|
|
|
async, async->ls.directory);
|
|
|
|
|
|
|
|
if (async->pack) ecore_thread_feedback(thread, async->pack);
|
|
|
|
async->pack = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_direct_find_heavy(void *data, Ecore_Thread *thread)
|
|
|
|
{
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_File_Dir_Ls *async = data;
|
2012-02-22 01:30:43 -08:00
|
|
|
|
|
|
|
async->ls.common.thread = thread;
|
|
|
|
async->pack = NULL;
|
|
|
|
async->start = ecore_time_get();
|
|
|
|
|
|
|
|
_eio_file_recursiv_ls(thread, &async->ls.common,
|
|
|
|
(Eio_Filter_Direct_Cb) _eio_dir_stat_find_forward,
|
|
|
|
eina_file_direct_ls,
|
2011-02-17 07:59:07 -08:00
|
|
|
async, async->ls.directory);
|
2011-08-29 04:20:27 -07:00
|
|
|
|
|
|
|
if (async->pack) ecore_thread_feedback(thread, async->pack);
|
|
|
|
async->pack = NULL;
|
2011-02-17 07:59:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_stat_find_notify(void *data, Ecore_Thread *thread __UNUSED__, void *msg_data)
|
|
|
|
{
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_File_Dir_Ls *async = data;
|
2011-08-29 04:20:27 -07:00
|
|
|
Eina_List *pack = msg_data;
|
|
|
|
Eio_File_Direct_Info *info;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
2011-08-29 04:20:27 -07:00
|
|
|
EINA_LIST_FREE(pack, info)
|
|
|
|
{
|
|
|
|
async->ls.common.main.associated = info->associated;
|
2011-06-22 09:09:14 -07:00
|
|
|
|
2011-08-29 04:20:27 -07:00
|
|
|
async->main_cb((void*) async->ls.common.data, &async->ls.common, &info->info);
|
2011-06-22 09:09:14 -07:00
|
|
|
|
2011-08-29 04:20:27 -07:00
|
|
|
if (async->ls.common.main.associated)
|
|
|
|
{
|
|
|
|
eina_hash_free(async->ls.common.main.associated);
|
|
|
|
async->ls.common.main.associated = NULL;
|
|
|
|
}
|
2011-02-17 07:59:07 -08:00
|
|
|
|
2011-08-29 04:20:27 -07:00
|
|
|
eio_direct_info_free(info);
|
|
|
|
}
|
2011-02-17 07:59:07 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_stat_done(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eio_File_Ls *async = data;
|
|
|
|
|
|
|
|
async->common.done_cb((void*) async->common.data, &async->common);
|
|
|
|
|
|
|
|
eina_stringshare_del(async->directory);
|
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_eio_dir_stat_error(void *data, Ecore_Thread *thread __UNUSED__)
|
|
|
|
{
|
|
|
|
Eio_File_Ls *async = data;
|
|
|
|
|
|
|
|
eio_file_error(&async->common);
|
|
|
|
|
|
|
|
eina_stringshare_del(async->directory);
|
|
|
|
free(async);
|
|
|
|
}
|
|
|
|
|
2010-10-20 12:17:30 -07:00
|
|
|
/**
|
|
|
|
* @endcond
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* Global *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
|
|
|
|
/*============================================================================*
|
|
|
|
* API *
|
|
|
|
*============================================================================*/
|
|
|
|
|
|
|
|
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_dir_copy(const char *source,
|
|
|
|
const char *dest,
|
2011-03-09 08:21:11 -08:00
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
Eio_Progress_Cb progress_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
2010-10-08 13:14:21 -07:00
|
|
|
Eio_Dir_Copy *copy;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
2010-10-08 13:14:21 -07:00
|
|
|
copy = malloc(sizeof(Eio_Dir_Copy));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(copy, NULL);
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
copy->progress.op = EIO_DIR_COPY;
|
|
|
|
copy->progress.progress_cb = progress_cb;
|
|
|
|
copy->progress.source = eina_stringshare_add(source);
|
|
|
|
copy->progress.dest = eina_stringshare_add(dest);
|
2011-03-09 08:21:11 -08:00
|
|
|
copy->filter_cb = filter_cb;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
copy->files = NULL;
|
2010-10-20 06:48:13 -07:00
|
|
|
copy->dirs = NULL;
|
2011-01-04 08:58:58 -08:00
|
|
|
copy->links = NULL;
|
* eio: add eio_dir_copy.
Little example on how to use it :
#include <Ecore.h>
#include <Eio.h>
static void
_test_notify_cb(void *data, const Eio_Progress *info)
{
switch (info->op)
{
case EIO_FILE_COPY:
printf("[%s] %f%%\n", info->dest, info->percent);
break;
case EIO_DIR_COPY:
printf("global [%li/%li] %f%%\n", info->current, info->max, info->percent);
break;
}
}
static void
_test_done_cb(void *data)
{
printf("copy done\n");
ecore_main_loop_quit();
}
static void
_test_error_cb(int error, void *data)
{
fprintf(stderr, "error: [%s]\n", strerror(error));
ecore_main_loop_quit();
}
int
main(int argc, char **argv)
{
Eio_File *cp;
if (argc != 3)
{
fprintf(stderr, "eio_cp source_file destination_file\n");
return -1;
}
ecore_init();
eio_init();
cp = eio_dir_copy(argv[1], argv[2],
_test_notify_cb,
_test_done_cb,
_test_error_cb,
NULL);
ecore_main_loop_begin();
eio_shutdown();
ecore_shutdown();
return 0;
}
NOTE: be aware that it's your duty to provide the "right target".
Meaning that copying to '.' will copy the content directly inside
'.' and not in a subdirectory.
SVN revision: 53069
2010-10-05 09:46:41 -07:00
|
|
|
|
|
|
|
if (!eio_long_file_set(©->progress.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_dir_copy_heavy,
|
|
|
|
_eio_dir_copy_notify,
|
|
|
|
_eio_dir_copy_end,
|
|
|
|
_eio_dir_copy_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return ©->progress.common;
|
|
|
|
}
|
|
|
|
|
2010-10-20 05:09:58 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_dir_move(const char *source,
|
|
|
|
const char *dest,
|
2011-03-09 08:21:11 -08:00
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
2010-10-20 05:09:58 -07:00
|
|
|
Eio_Progress_Cb progress_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
|
|
|
Eio_Dir_Copy *move;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(source, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dest, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
|
|
|
|
|
|
|
move = malloc(sizeof(Eio_Dir_Copy));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(move, NULL);
|
|
|
|
|
|
|
|
move->progress.op = EIO_DIR_MOVE;
|
|
|
|
move->progress.progress_cb = progress_cb;
|
|
|
|
move->progress.source = eina_stringshare_add(source);
|
|
|
|
move->progress.dest = eina_stringshare_add(dest);
|
2011-03-09 08:21:11 -08:00
|
|
|
move->filter_cb = filter_cb;
|
2010-10-20 05:09:58 -07:00
|
|
|
move->files = NULL;
|
2010-10-20 06:48:13 -07:00
|
|
|
move->dirs = NULL;
|
2011-01-04 08:58:58 -08:00
|
|
|
move->links = NULL;
|
2010-10-20 05:09:58 -07:00
|
|
|
|
|
|
|
if (!eio_long_file_set(&move->progress.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_dir_move_heavy,
|
|
|
|
_eio_dir_copy_notify,
|
|
|
|
_eio_dir_copy_end,
|
|
|
|
_eio_dir_copy_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &move->progress.common;
|
|
|
|
}
|
|
|
|
|
2010-10-20 06:48:13 -07:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_dir_unlink(const char *path,
|
2011-03-09 08:21:11 -08:00
|
|
|
Eio_Filter_Direct_Cb filter_cb,
|
2010-10-20 06:48:13 -07:00
|
|
|
Eio_Progress_Cb progress_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
|
|
|
Eio_Dir_Copy *rmrf;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(path, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
|
|
|
|
|
|
|
rmrf = malloc(sizeof(Eio_Dir_Copy));
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(rmrf, NULL);
|
|
|
|
|
|
|
|
rmrf->progress.op = EIO_UNLINK;
|
|
|
|
rmrf->progress.progress_cb = progress_cb;
|
|
|
|
rmrf->progress.source = eina_stringshare_add(path);
|
|
|
|
rmrf->progress.dest = NULL;
|
2011-03-09 08:21:11 -08:00
|
|
|
rmrf->filter_cb = filter_cb;
|
2010-10-20 06:48:13 -07:00
|
|
|
rmrf->files = NULL;
|
|
|
|
rmrf->dirs = NULL;
|
2011-01-04 08:58:58 -08:00
|
|
|
rmrf->links = NULL;
|
2010-10-20 06:48:13 -07:00
|
|
|
|
|
|
|
if (!eio_long_file_set(&rmrf->progress.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_dir_rmrf_heavy,
|
|
|
|
_eio_dir_copy_notify,
|
|
|
|
_eio_dir_copy_end,
|
|
|
|
_eio_dir_copy_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &rmrf->progress.common;
|
|
|
|
}
|
|
|
|
|
2011-02-17 07:59:07 -08:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_dir_stat_ls(const char *dir,
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_Filter_Dir_Cb filter_cb,
|
2011-02-17 07:59:07 -08:00
|
|
|
Eio_Main_Direct_Cb main_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_File_Dir_Ls *async;
|
2011-02-17 07:59:07 -08:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
|
|
|
|
2012-02-22 03:51:45 -08:00
|
|
|
async = malloc(sizeof(Eio_File_Dir_Ls));
|
2011-02-17 07:59:07 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
|
|
|
|
|
|
|
|
async->filter_cb = filter_cb;
|
|
|
|
async->main_cb = main_cb;
|
|
|
|
async->ls.directory = eina_stringshare_add(dir);
|
|
|
|
|
|
|
|
if (!eio_long_file_set(&async->ls.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_dir_stat_find_heavy,
|
|
|
|
_eio_dir_stat_find_notify,
|
|
|
|
_eio_dir_stat_done,
|
|
|
|
_eio_dir_stat_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &async->ls.common;
|
|
|
|
}
|
|
|
|
|
2012-02-22 01:30:43 -08:00
|
|
|
EAPI Eio_File *
|
|
|
|
eio_dir_direct_ls(const char *dir,
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_Filter_Dir_Cb filter_cb,
|
2012-02-22 01:30:43 -08:00
|
|
|
Eio_Main_Direct_Cb main_cb,
|
|
|
|
Eio_Done_Cb done_cb,
|
|
|
|
Eio_Error_Cb error_cb,
|
|
|
|
const void *data)
|
|
|
|
{
|
2012-02-22 03:51:45 -08:00
|
|
|
Eio_File_Dir_Ls *async;
|
2012-02-22 01:30:43 -08:00
|
|
|
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(dir, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(main_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(done_cb, NULL);
|
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(error_cb, NULL);
|
|
|
|
|
2012-02-22 03:51:45 -08:00
|
|
|
async = malloc(sizeof(Eio_File_Dir_Ls));
|
2012-02-22 01:30:43 -08:00
|
|
|
EINA_SAFETY_ON_NULL_RETURN_VAL(async, NULL);
|
|
|
|
|
|
|
|
async->filter_cb = filter_cb;
|
|
|
|
async->main_cb = main_cb;
|
|
|
|
async->ls.directory = eina_stringshare_add(dir);
|
|
|
|
|
|
|
|
if (!eio_long_file_set(&async->ls.common,
|
|
|
|
done_cb,
|
|
|
|
error_cb,
|
|
|
|
data,
|
|
|
|
_eio_dir_direct_find_heavy,
|
|
|
|
_eio_dir_stat_find_notify,
|
|
|
|
_eio_dir_stat_done,
|
|
|
|
_eio_dir_stat_error))
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return &async->ls.common;
|
|
|
|
}
|
|
|
|
|