Prototype
E_RTN EMemory::SpaceSwapAdjacent( ulonglong ullSpaceToSwapSize,
ulonglong ullOffset = 0,
ulonglong ullOffsetSize = EMemory::SizeUpToEnd );

Cette fonction intervertit tous les blocs d'octets adjacents (contigus) d'une taille indicative de ullSpaceToSwapSize octet(s) d'un intervalle de travail.

Par exemple pour les données "ABCDE" et pour une taille indicative de 1 octet, la fonction intervertit "A" et "B", "C" et "D" mais "E" n'a pas de donnée avec laquelle s'intervertir. Donc le résultat final est "BADCE".

Pour que la fonction puisse intervertir des blocs d'octets, il faut que l'espace de travail ait assez de données pour pouvoir le faire. C'est à dire que pour intervertir des blocs de 3 octets, il faut au moins 6 octets (les 3 premiers octets sont intervertis avec les 3 prochains octets).

Si la taille de l'intervalle de travail ne dispose pas d'assez de blocs à intervertir, la fonction se termine (dans l'exemple ci-dessus, l'octet "E" n'est pas intervertis car il n'y a pas de bloc avec lequel l'intervertir).

 

Argument

ulonglong ullSpaceToSwapSize

taille indicative des blocs d'octets à intervertir.

ulonglong ullOffset = 0

offset de départ de l'intervalle de travail de l'interversion.

ulonglong ullOffsetSize = EMemory::SizeUpToEnd

étendue de l'intervalle de travail de l'interversion.

 

Retour

E_RTN

voir la section retour de la librairie Eclat.

 

Exemple

Description :

Interversion des blocs d'octets adjacents d'une taille indicative de 3 octets sur l'ensemble de l'espace de travail d'un objet EMemory alloué de 13 octets d'espace de travail contenant les données 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x4B, 0x4C et 0x4D ("ABCDEFGHIJKLM" en ASCII).

Remarque : L'octet 0x4D ("M") n'est pas interverti car il n'y a plus assez de place dans l'espace de travail pour former un bloc d'octets de 3 octets et qu'il n'y a pas de bloc d'octets avec lequel l'intervertir.

Code :

EMemory eMem( "ABCDEFGHIJKLM", 13 ); // objet EMemory alloué de 13 octets

eMem.TraceEx( _T("eMem") );
eMem.SpaceSwapAdjacent( 3 );
eMem.TraceEx( _T("eMem") );

Sortie :

### Object EMemory 'eMem' Trace #
# Object address='0x0012F468', status='EMemory::ObjectStatus_Enable' (code '3').
# Buffer address='0x00000001', workspace size='13' byte(s).
# Array data from offset '0x00000000' to offset '0x0000000C', length=13 byte(s).
# Offset start 0x00000000 41 42 43 44 45 46 47 48 49 4A 4B 4C 4D .. .. .. [ABCDEFGHIJKLM]
### End #

### Object EMemory 'eMem' Trace #
# Object address='0x0012F468', status='EMemory::ObjectStatus_Enable' (code '3').
# Buffer address='0x00000001', workspace size='13' byte(s).
# Array data from offset '0x00000000' to offset '0x0000000C', length=13 byte(s).
# Offset start 0x00000000 44 45 46 41 42 43 4A 4B 4C 47 48 49 4D .. .. .. [DEFABCJKLGHIM]
### End #

Vue :

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E ..
  00 01 02 03 04 05 06 07 08 09 0A 0B 0C
  41
A		 42
B		 43
C		 44
D		 45
E		 46
F		 47
G		 48
H		 49
I		 4A
J		 4B
K		 4C
L		 4D
M

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E ..
  00 01 02 03 04 05 06 07 08 09 0A 0B 0C
  44
D		 45
E		 46
F		 41
A		 42
B		 43
C		 4A
J		 4B
K		 4C
L		 47
G		 48
H		 49
I		 4D
M

 

Voir aussi
E_RTN EMemory::SpaceSwap( ulonglong ullOffsetDest, ulonglong ullOffsetSource );
E_RTN EMemory::SpaceSwap( ulonglong ullOffsetDest, ulonglong ullOffsetSource, ulonglong ullOffsetDestSourceSize );
E_RTN EMemory::SpaceSwap( ulonglong ullOffsetDest, ulonglong ullOffsetDestSize, ulonglong ullOffsetSource, ulonglong ullOffsetSourceSize );
E_RTN EMemory::SpaceSwapSymetric( ulonglong ullSpaceToSwapSize, ulonglong ullOffset = 0, ulonglong ullOffsetSize = EMemory::SizeUpToEnd );

 

Minimum
Version 1.0.0