copie de fichiers par petites parties

Le
gpgnews
Bonjour,
dans le code qui suit, j'aimerai copier un fichier A dans un fichier B
par petites portions, j'ai l'impression que cela ne fonctionne pas
correctement, j'aimerai boen que vous me dites ce que vous en pensez


int WriteDataWithTries( int p_file_desc,
const char* p_data,
unsigned int p_length,
int p_position,
unsigned int p_delay,
unsigned int p_tries
)
{
int l_val = ERROR;
if( (ERROR != p_file_desc) &&
(NULL != p_data) &&
(0 != p_length))
{
int l_begin_pos = p_position;
// Get the current position if needed
if(l_begin_pos < 0)
{
l_begin_pos = lseek(p_file_desc,0,SEEK_CUR);
}

if(0 <= l_begin_pos)
{
unsigned int l_index = 0;
unsigned int l_write = 0;
do
{
if(ERROR != lseek(p_file_desc,l_begin_pos,SEEK_SET))
{
l_write =
writeData(p_file_desc,const_cast<char*>(p_data),p_length);
if(p_length == l_write)
{
l_val = l_write;
}
else
{
DelayFunction(p_delay);
}
}
++l_index;
} while((l_write != p_length) && (l_index < p_tries));
}
}
else if (0 == p_length)
{
l_val = 0; // return 0 when copying 0 bit
}
return (l_val);
}

int ReadDataWithTries( int p_file_desc,
char* p_data,
unsigned int p_length,
int p_position,
unsigned int p_delay,
unsigned int p_tries
)
{
int l_val = ERROR;
if( (ERROR != p_file_desc) &&
(NULL != p_data) &&
(0 != p_length))
{
int l_begin_pos = p_position;
// Get the current position if needed
if(l_begin_pos < 0)
{
l_begin_pos = lseek(p_file_desc,0,SEEK_CUR);
}
if(0 <= l_begin_pos)
{
int l_index = 0;
int l_read = 0;
vector <int> l_errno_table;
do
{
if(ERROR != lseek(p_file_desc,l_begin_pos,SEEK_SET))
{
l_read = read(p_file_desc,p_data,p_length);
if(ERROR != l_read)
{
l_val = l_read;
}
else
{
DelayFunction(p_delay);
}
}
++l_index;
} while((l_read == ERROR) && (l_index <(int) p_tries));
}
}

return (l_val);
}


Utilisation :
char l_copy_buffer[1024];
unsigned int l_position = 0;

int l_id_fic_source;
l_id_fic_source = open(FichierA,O_RDONLY,0);
if (ERROR!=l_id_fic_source)
{
int l_id_fic_destination;
l_id_fic_destination = open(FichierB,O_WRONLY|O_CREAT ,0);

if (ERROR!=l_id_fic_destination)
{
int l_num_elem_read = 0 ;
int l_num_elem_write = 0 ;
bool l_flag_exit_loop = false;

// copy of the N Blocks composing the file
while(false==l_flag_exit_loop)
{
l_num_elem_read = ReadDataWithTries(l_id_fic_source,
l_copy_buffer, 1024,
l_position, 10, 3);

if (ERROR != l_num_elem_read)
{
l_num_elem_write =
WriteDataWithTries(l_id_fic_destination, l_copy_buffer,
l_num_elem_read,
l_position, 10, 3);
// Copy is correct if the number of elements copied is
// the same one as the number of elements read
if (l_num_elem_read == l_num_elem_write)
{
// The end of the file is reached
// if the last reading did not reach the specified max
if (1024 > l_num_elem_read)
{
l_status = OK;
l_flag_exit_loop = true;
}
// incrementing of the reading pointer
l_position += l_num_elem_read;
}
else
{
l_flag_exit_loop = true;
l_status = ERROR;
}
}
else
{
l_flag_exit_loop = true;
l_status = ERROR;
}
}

// files Closing
if (ERROR!=l_id_fic_source)
{
close(l_id_fic_source);
}
if (ERROR!=l_id_fic_destination)
{
close(l_id_fic_destination);
}
}
}

merci.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Antoine Leca
Le #998357
En news:,
"merci." va escriure:

dans le code qui suit, j'aimerai copier un fichier A dans un fichier B
par petites portions, j'ai l'impression que cela ne fonctionne pas
correctement, j'aimerai boen que vous me dites ce que vous en pensez


Que ton code est trop compliqué.

Et qu'il y a des trucs rigolos... par exemple :
Utilisation :
unsigned int l_position = 0;
[...]

l_num_elem_read = ReadDataWithTries(l_id_fic_source,
l_copy_buffer, 1024,
l_position, 10, 3);
qui renvoie vers

int ReadDataWithTries( int p_file_desc,
char* p_data,
unsigned int p_length,
int p_position,
unsigned int p_delay,
unsigned int p_tries
)
[...]

int l_begin_pos = p_position;
// Get the current position if needed
if(l_begin_pos < 0)


Je me demande ici comment on peut arriver à passer dans la
condition < 0... OK, en fait je vois très bien comment on peut faire, par
exemple quand on a lu 32 blocs cela risque de m'arriver ! mais bon, dans tes
exemples de test je ne pense pas que le problème se pose à toi.
Et en passant, d'habitude on déclare l_begin_pos comme un long (puisqu'on le
passe à lseek.)


Pour en revenir à ton problème, reviens donc d'un cran en arrière, par
exemple en supprimant la logique de repositionnement (tous les lseek()) : de
toutes manières, ou bien ton bout de programme est le seul à manipuler les
fichiers identifiés par
l_id_fic_source et l_id_fic_destination et tu n'as pas besoin de
repositionner en permanence, lire ou écrire succesivement est suffisant ; ou
bien tu veux avoir du code compatible multi-tâches, et ton système n'est pas
suffisant, il faut ajouter des sémaphores d'exclusion (la partie entre le
lseek(,,SEEK_SET) et le read() ou le write() est une section critique.)
Enlève aussi la logique des délais et des réessais.
Tu verras alors peut-être un peu plus clair.


Pour moi, le problème est dans la logique de lecture, car je suis sur
Windows, et je reviens en général à la ligne.


Antoine

Bruno Desthuilliers
Le #998356
En news:,
"merci." va escriure:

dans le code qui suit, j'aimerai copier un fichier A dans un fichier B
par petites portions, j'ai l'impression que cela ne fonctionne pas
correctement, j'aimerai boen que vous me dites ce que vous en pensez


Que ton code est trop compliqué.

Et qu'il y a des trucs rigolos... par exemple :
(snip)

Et que ce n'est pas du C, à moins que le C n'ait intégré les cast façon
C++ depuis la dernière fois que j'en ai fait:

writeData(p_file_desc,const_cast<char*>(p_data),p_length);


Charlie Gordon
Le #998355
"Bruno Desthuilliers" écrit dans le message de news: 47051ab0$0$21631$
En news:,
"merci." va escriure:

dans le code qui suit, j'aimerai copier un fichier A dans un fichier B
par petites portions, j'ai l'impression que cela ne fonctionne pas
correctement, j'aimerai boen que vous me dites ce que vous en pensez


Que ton code est trop compliqué.

Et qu'il y a des trucs rigolos... par exemple :
(snip)

Et que ce n'est pas du C, à moins que le C n'ait intégré les cast façon
C++ depuis la dernière fois que j'en ai fait:

writeData(p_file_desc,const_cast<char*>(p_data),p_length);


Quelle syntaxe horrible !

--
Chqrlie



Publicité
Poster une réponse
Anonyme