// Handles .n
static ZERO_OR_ERROR FS_read_a_part( struct one_wire_query *owq_part )
{
struct parsedname *pn = PN(owq_part);
size_t extension = pn->extension;
struct filetype * ft = pn->selected_filetype ;
struct one_wire_query * owq_all ;
// bitfield
if ( ft->format == ft_bitfield ) {
return FS_read_a_bit( owq_part ) ;
}
// non-bitfield
owq_all = OWQ_create_aggregate( owq_part ) ;
if ( owq_all == NO_ONE_WIRE_QUERY ) {
return -ENOENT ;
}
// First fill the whole array with current values
if ( FS_read_owq( owq_all ) < 0 ) {
OWQ_destroy( owq_all ) ;
return -EINVAL ;
}
// Copy ascii/binary field
switch (ft->format) {
case ft_binary:
case ft_ascii:
case ft_vascii:
case ft_alias:
{
size_t extension_index;
char *buffer_pointer = OWQ_buffer(owq_all);
// All prior elements
for (extension_index = 0; extension_index < extension; ++extension_index) {
// move past their buffer position
buffer_pointer += OWQ_array_length(owq_all, extension_index);
}
// now move current element's buffer to location
OWQ_length(owq_part) = OWQ_array_length(owq_all, extension) ;
memmove( OWQ_buffer(owq_part), buffer_pointer, OWQ_length(owq_part));
break;
}
default:
// Copy value field
memcpy( &OWQ_val(owq_part), &OWQ_array(owq_all)[pn->extension], sizeof(union value_object) );
break;
}
OWQ_destroy(owq_all);
return 0 ;
}
static SIZE_OR_ERROR OWQ_parse_output_array_no_commas(struct one_wire_query *owq)
{
size_t extension;
size_t total_length = 0;
size_t elements = OWQ_pn(owq).selected_filetype->ag->elements;
for (extension = 0; extension < elements; ++extension) {
total_length += OWQ_array_length(owq, extension);
}
return total_length;
}
static SIZE_OR_ERROR OWQ_parse_output_ascii_array(struct one_wire_query *owq)
{
size_t extension;
size_t elements = OWQ_pn(owq).selected_filetype->ag->elements;
size_t total_length = 0;
size_t current_offset = OWQ_array_length(owq, 0);
for (extension = 0; extension < elements; ++extension) {
total_length += OWQ_array_length(owq, extension);
}
for (extension = 1; extension < elements; ++extension) {
memmove(&OWQ_buffer(owq)[current_offset + 1], &OWQ_buffer(owq)[current_offset], total_length - current_offset);
OWQ_buffer(owq)[current_offset] = ',';
++total_length;
current_offset += 1 + OWQ_array_length(owq, extension);
}
return total_length;
}
// Handles: ALL
static ZERO_OR_ERROR FS_write_in_parts( struct one_wire_query *owq_all )
{
struct one_wire_query * owq_part = OWQ_create_separate( 0, owq_all ) ;
struct parsedname *pn = PN(owq_all);
size_t elements = pn->selected_filetype->ag->elements;
size_t extension ;
char *buffer_pointer;
ZERO_OR_ERROR z_or_e = 0 ;
// Create a "single" OWQ copy to iterate with
if ( owq_part == NO_ONE_WIRE_QUERY ) {
return -ENOENT ;
}
// create a buffer for certain types
// point to 0th element's buffer first
buffer_pointer = OWQ_buffer(owq_all);
OWQ_size(owq_part) = FileLength(PN(owq_part));
OWQ_offset(owq_part) = 0;
// loop through all eloements
for (extension = 0; extension < elements; ++extension) {
ZERO_OR_ERROR single_write;
switch (pn->selected_filetype->format) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
OWQ_length(owq_part) = OWQ_array_length(owq_all,extension) ;
OWQ_buffer(owq_part) = buffer_pointer;
buffer_pointer += OWQ_length(owq_part);
break;
default:
memcpy(&OWQ_val(owq_part), &OWQ_array(owq_all)[extension], sizeof(union value_object));
break;
}
OWQ_pn(owq_part).extension = extension;
single_write = FS_write_owq(owq_part);
if (single_write != 0) {
z_or_e = single_write ;
}
}
return z_or_e;
}
// Handles .n
static ZERO_OR_ERROR FS_write_a_part( struct one_wire_query *owq_part )
{
struct parsedname *pn = PN(owq_part);
size_t extension = pn->extension;
struct filetype * ft = pn->selected_filetype ;
ZERO_OR_ERROR z_or_e ;
struct one_wire_query * owq_all ;
// bitfield
if ( ft->format == ft_bitfield ) {
return FS_write_a_bit( owq_part ) ;
}
// non-bitfield
owq_all = OWQ_create_aggregate( owq_part ) ;
if ( owq_all == NO_ONE_WIRE_QUERY ) {
return -ENOENT ;
}
// First fill the whole array with current values
if ( FS_read_local( owq_all ) < 0 ) {
OWQ_destroy( owq_all ) ;
return -ENOENT ;
}
// Copy ascii/binary field
switch (ft->format) {
case ft_binary:
case ft_ascii:
case ft_vascii:
case ft_alias:
{
size_t extension_index;
size_t elements = ft->ag->elements;
char *buffer_pointer = OWQ_buffer(owq_all);
char *entry_pointer;
char *target_pointer;
// All prior elements
for (extension_index = 0; extension_index < extension; ++extension) {
// move past their buffer position
buffer_pointer += OWQ_array_length(owq_all, extension_index);
}
entry_pointer = buffer_pointer; // this element's buffer start
target_pointer = buffer_pointer + OWQ_length(owq_part); // new start next element
buffer_pointer = buffer_pointer + OWQ_array_length(owq_all, extension); // current start next element
// move rest of elements to new locations
for (extension_index = extension + 1; extension_index < elements; ++extension) {
size_t this_length = OWQ_array_length(owq_all, extension_index);
memmove(target_pointer, buffer_pointer, this_length);
target_pointer += this_length;
buffer_pointer += this_length;
}
// now move current element's buffer to location
memmove(entry_pointer, OWQ_buffer(owq_part), OWQ_length(owq_part));
OWQ_array_length(owq_all,extension) = OWQ_length(owq_part) ;
}
break;
default:
// Copy value field
memcpy(&OWQ_array(owq_all)[pn->extension], &OWQ_val(owq_part), sizeof(union value_object));
break;
}
// Write whole thing out
z_or_e = FS_write_owq(owq_all);
OWQ_destroy(owq_all);
return z_or_e ;
}
// Handles: ALL
static ZERO_OR_ERROR FS_read_in_parts( struct one_wire_query *owq_all )
{
struct parsedname *pn = PN(owq_all);
struct filetype * ft = pn->selected_filetype ;
struct one_wire_query * owq_part ;
size_t elements = pn->selected_filetype->ag->elements;
size_t extension;
char * buffer_pointer = OWQ_buffer(owq_all) ;
size_t buffer_left = OWQ_size(owq_all) ;
// single for BYTE or iteration
owq_part = OWQ_create_separate( 0, owq_all ) ;
if ( owq_part == NO_ONE_WIRE_QUERY ) {
return -ENOENT ;
}
// bitfield
if ( ft->format == ft_bitfield ) {
OWQ_pn(owq_part).extension = EXTENSION_BYTE ;
if ( FS_read_owq(owq_part) < 0 ) {
OWQ_destroy( owq_part ) ;
return -EINVAL ;
}
for (extension = 0; extension < elements; ++extension) {
OWQ_array_Y(owq_all,extension) = UT_getbit_U( OWQ_U(owq_part), extension ) ;
}
OWQ_destroy( owq_part ) ;
return 0 ;
}
if ( BAD( OWQ_allocate_read_buffer( owq_part )) ) {
LEVEL_DEBUG("Can't allocate buffer space");
OWQ_destroy( owq_part ) ;
return -EMSGSIZE ;
}
/* Loop through get data */
for (extension = 0; extension < elements; ++extension) {
size_t part_length ;
OWQ_pn(owq_part).extension = extension;
if ( FS_read_owq(owq_part) < 0 ) {
OWQ_destroy( owq_part ) ;
return -EINVAL ;
}
// Check that there is enough space for the combined message
switch ( ft->format ) {
case ft_ascii:
case ft_vascii:
case ft_alias:
case ft_binary:
part_length = OWQ_length(owq_part) ;
if ( buffer_left < part_length ) {
OWQ_destroy( owq_part ) ;
return -EMSGSIZE ;
}
memcpy( buffer_pointer, OWQ_buffer(owq_part), part_length ) ;
OWQ_array_length(owq_all,extension) = part_length ;
buffer_pointer += part_length ;
buffer_left -= part_length ;
break ;
default:
// copy object (single to mixed array)
memcpy(&OWQ_array(owq_all)[extension], &OWQ_val(owq_part), sizeof(union value_object));
break;
}
}
OWQ_destroy( owq_part ) ;
return 0;
}
