910 lines
62 KiB
Fortran
910 lines
62 KiB
Fortran
!> @ingroup Library
|
|
!> @{
|
|
!> @defgroup Lib_Base64Library Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> @ingroup Interface
|
|
!> @{
|
|
!> @defgroup Lib_Base64Interface Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> @ingroup PublicProcedure
|
|
!> @{
|
|
!> @defgroup Lib_Base64PublicProcedure Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> @ingroup PrivateProcedure
|
|
!> @{
|
|
!> @defgroup Lib_Base64PrivateProcedure Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> @ingroup GlobalVarPar
|
|
!> @{
|
|
!> @defgroup Lib_Base64GlobalVarPar Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> @ingroup PrivateVarPar
|
|
!> @{
|
|
!> @defgroup Lib_Base64PrivateVarPar Lib_Base64
|
|
!> base64 encoding/decoding library
|
|
!> @}
|
|
|
|
!> This module contains base64 encoding/decoding procedures.
|
|
!> @todo \b Decoding: Implement decoding functions.
|
|
!> @todo \b DocComplete: Complete the documentation.
|
|
!> @ingroup Lib_Base64Library
|
|
module Lib_Base64
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
USE IR_Precision ! Integers and reals precision definition.
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
private
|
|
public:: b64_encode
|
|
!public:: b64_decode
|
|
public:: pack_data
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
!> @ingroup Lib_Base64GlobalVarPar
|
|
!> @{
|
|
!> @}
|
|
!> @ingroup Lib_Base64PrivateVarPar
|
|
!> @{
|
|
character(64):: base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/" !< Base64 alphabet.
|
|
!> @}
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
!> @brief Subroutine for encoding numbers (integer and real) to base64.
|
|
!> @ingroup Lib_Base64Interface
|
|
interface b64_encode
|
|
module procedure b64_encode_R8_a, &
|
|
b64_encode_R4_a, &
|
|
b64_encode_I8_a, &
|
|
b64_encode_I4_a, &
|
|
b64_encode_I2_a, &
|
|
b64_encode_I1_a
|
|
endinterface
|
|
!!> @brief Subroutine for decoding numbers (integer and real) from base64.
|
|
!!> @ingroup Lib_Base64Interface
|
|
!interface b64_decode
|
|
! module procedure b64_decode_R8_a, &
|
|
! b64_decode_R4_a, &
|
|
! b64_decode_I8_a, &
|
|
! b64_decode_I4_a, &
|
|
! b64_decode_I2_a, &
|
|
! b64_decode_I1_a
|
|
!endinterface
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array. This is useful for encoding different kinds
|
|
!> variables into a single stream of bits.
|
|
!> @ingroup Lib_Base64Interface
|
|
interface pack_data
|
|
module procedure pack_data_R8_R4,pack_data_R8_I8,pack_data_R8_I4,pack_data_R8_I2,pack_data_R8_I1, &
|
|
pack_data_R4_R8,pack_data_R4_I8,pack_data_R4_I4,pack_data_R4_I2,pack_data_R4_I1, &
|
|
pack_data_I8_R8,pack_data_I8_R4,pack_data_I8_I4,pack_data_I8_I2,pack_data_I8_I1, &
|
|
pack_data_I4_R8,pack_data_I4_R4,pack_data_I4_I8,pack_data_I4_I2,pack_data_I4_I1, &
|
|
pack_data_I2_R8,pack_data_I2_R4,pack_data_I2_I8,pack_data_I2_I4,pack_data_I2_I1, &
|
|
pack_data_I1_R8,pack_data_I1_R4,pack_data_I1_I8,pack_data_I1_I4,pack_data_I1_I2
|
|
endinterface
|
|
!-----------------------------------------------------------------------------------------------------------------------------------
|
|
contains
|
|
!> @ingroup Lib_Base64PrivateProcedure
|
|
!> @{
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R8_R4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R8P), intent(IN):: a1(1:) !< Firs data stream.
|
|
real(R4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R8_R4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R8_I8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R8_I8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R8_I4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R8_I4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R8_I2(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I2P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R8_I2
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R8_I1(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I1P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R8_I1
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R4_R8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R4P), intent(IN):: a1(1:) !< Firs data stream.
|
|
real(R8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R4_R8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R4_I8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R4_I8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R4_I4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R4_I4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R4_I2(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I2P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R4_I2
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_R4_I1(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
real(R4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I1P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_R4_I1
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I8_R8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I8P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I8_R8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I8_R4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I8P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I8_R4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I8_I4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I8_I4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I8_I2(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I2P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I8_I2
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I8_I1(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I8P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I1P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I8_I1
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I4_R8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I4_R8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I4_R4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I4_R4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I4_I8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I4_I8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I4_I2(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I2P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I4_I2
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I4_I1(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I1P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I4_I1
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I2_R8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I2P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I2_R8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I2_R4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I2P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I2_R4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I2_I8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I2P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I2_I8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I2_I4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I2P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I2_I4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I2_I1(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I2P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I1P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I2_I1
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I1_R8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I1_R8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I1_R4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: a1(1:) !< First data stream.
|
|
real(R4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I1_R4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I1_I8(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I8P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I1_I8
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I1_I4(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I4P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I1_I4
|
|
|
|
!> @brief Subroutine for packing different kinds of data into single I1P array.
|
|
pure subroutine pack_data_I1_I2(a1,a2,packed)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: a1(1:) !< First data stream.
|
|
integer(I2P), intent(IN):: a2(1:) !< Second data stream.
|
|
integer(I1P), allocatable, intent(INOUT):: packed(:) !< Packed data into I1P array.
|
|
integer(I1P), allocatable:: p1(:) !< Temporary packed data of first stream.
|
|
integer(I1P), allocatable:: p2(:) !< Temporary packed data of second stream.
|
|
integer(I4P):: np !< Size of temporary packed data.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
np = size(transfer(a1,p1)) ; allocate(p1(1:np)) ; p1 = transfer(a1,p1)
|
|
np = size(transfer(a2,p2)) ; allocate(p2(1:np)) ; p2 = transfer(a2,p2)
|
|
if (allocated(packed)) deallocate(packed) ; allocate(packed(1:size(p1,dim=1)+size(p2,dim=1))) ; packed = [p1,p2]
|
|
deallocate(p1,p2)
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine pack_data_I1_I2
|
|
|
|
!> @brief Subroutine for encoding bits (must be multiple of 24 bits) into base64 charcaters code (of length multiple of 4).
|
|
!> @note The bits stream are encoded in chunks of 24 bits as the following example (in little endian order):
|
|
!> @code
|
|
!> +--first octet--+-second octet--+--third octet--+
|
|
!> |7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|7 6 5 4 3 2 1 0|
|
|
!> +-----------+---+-------+-------+---+-----------+
|
|
!> |5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|5 4 3 2 1 0|
|
|
!> +--1.index--+--2.index--+--3.index--+--4.index--+
|
|
!> @endcode
|
|
!> The 4 indexes are stored into 4 elements 8 bits array, thus 2 bits of each array element are not used.
|
|
pure subroutine encode_bits(bits,padd,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I1P), intent(IN):: bits(1:) !< Bits to be encoded.
|
|
integer(I4P), intent(IN):: padd !< Number of padding characters ('=').
|
|
character(1), intent(OUT):: code(1:) !< Characters code.
|
|
integer(I1P):: sixb(1:4) !< 6 bits slices (stored into 8 bits integer) of 24 bits input.
|
|
integer(I8P):: c,e !< Counters.
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
c = 1_I8P
|
|
do e=1_I8P,size(bits,dim=1,kind=I8P),3_I8P ! loop over array elements: 3 bytes (24 bits) scanning
|
|
sixb = 0_I1P
|
|
call mvbits(bits(e ),2,6,sixb(1),0)
|
|
call mvbits(bits(e ),0,2,sixb(2),4) ; call mvbits(bits(e+1),4,4,sixb(2),0)
|
|
call mvbits(bits(e+1),0,4,sixb(3),2) ; call mvbits(bits(e+2),6,2,sixb(3),0)
|
|
call mvbits(bits(e+2),0,6,sixb(4),0)
|
|
sixb = sixb + 1_I1P
|
|
code(c :c )(1:1) = base64(sixb(1):sixb(1))
|
|
code(c+1:c+1)(1:1) = base64(sixb(2):sixb(2))
|
|
code(c+2:c+2)(1:1) = base64(sixb(3):sixb(3))
|
|
code(c+3:c+3)(1:1) = base64(sixb(4):sixb(4))
|
|
c = c + 4_I8P
|
|
enddo
|
|
if (padd>0) code(size(code,dim=1)-padd+1:)(1:1)='='
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine encode_bits
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (R8P).
|
|
pure subroutine b64_encode_R8_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
real(R8P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_R8_a
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (R4P).
|
|
pure subroutine b64_encode_R4_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
real(R4P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_R4_a
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (I8P).
|
|
pure subroutine b64_encode_I8_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
integer(I8P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_I8_a
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (I4P).
|
|
pure subroutine b64_encode_I4_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
integer(I4P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_I4_a
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (I2P).
|
|
pure subroutine b64_encode_I2_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
integer(I2P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_I2_a
|
|
|
|
!> @brief Subroutine for encoding array numbers to base64 (I1P).
|
|
pure subroutine b64_encode_I1_a(nB,n,code)
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
implicit none
|
|
integer(I4P), intent(IN):: nB !< Number of bytes of single element of n.
|
|
integer(I1P), intent(IN):: n(1:) !< Array of numbers to be encoded.
|
|
character(1), allocatable, intent(OUT):: code(:) !< Encoded array.
|
|
integer(I1P):: nI1P(1:((size(n,dim=1)*nB+2)/3)*3) !< One byte integer array containing n.
|
|
integer(I4P):: padd !< Number of padding characters ('=').
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
if (allocated(code)) deallocate(code) ; allocate(code(1:((size(n,dim=1)*nB+2)/3)*4)) ! allocating code chars
|
|
nI1P = transfer(n,nI1P) ! casting n to integer array of 1 byte elem
|
|
padd = mod((size(n,dim=1)*nB),3_I4P) ; if (padd>0_I4P) padd = 3_I4P - padd ! computing the number of padding characters
|
|
call encode_bits(bits=nI1P,padd=padd,code=code) ! encoding bits
|
|
return
|
|
!---------------------------------------------------------------------------------------------------------------------------------
|
|
endsubroutine b64_encode_I1_a
|
|
|
|
!!> @brief Subroutine for decoding array numbers from base64 (R8P).
|
|
!pure subroutine b64_decode_R8_a(code,n)
|
|
!!--------------------------------------------------------------------------------------------------------------------------------
|
|
!implicit none
|
|
!real(R8P), intent(OUT):: n(1:) !< Number to be decoded.
|
|
!character(ncR8P*size(n,dim=1)), intent(IN):: code !< Encoded number.
|
|
!integer(I4P):: c,d !< Counters.
|
|
!!--------------------------------------------------------------------------------------------------------------------------------
|
|
|
|
!!--------------------------------------------------------------------------------------------------------------------------------
|
|
!d = 1_I4P
|
|
!do c=1,len(code),ncR8P
|
|
! call b64_decode_R8_s(code=code(c:c+ncR8P-1),n=n(d))
|
|
! d = d + 1_I4P
|
|
!enddo
|
|
!return
|
|
!!--------------------------------------------------------------------------------------------------------------------------------
|
|
!endsubroutine b64_decode_R8_a
|
|
!> @}
|
|
endmodule Lib_Base64
|