627 lines
19 KiB
C++
627 lines
19 KiB
C++
#include "xml_result.h"
|
|
#include <cstdlib>
|
|
#include <xercesc/util/Base64.hpp>
|
|
#include <xercesc/util/XMLString.hpp>
|
|
#include <xercesc/dom/DOM.hpp>
|
|
#include <xercesc/util/XMLString.hpp>
|
|
#include <xercesc/util/PlatformUtils.hpp>
|
|
#include <xercesc/util/XercesDefs.hpp>
|
|
//#include <xercesc/dom/DOMWriter.hpp>
|
|
#include <xercesc/framework/MemBufFormatTarget.hpp>
|
|
|
|
/* ***************************************************************************************************
|
|
|
|
here starts the reader implementation
|
|
|
|
*****************************************************************************************************/
|
|
#ifndef SIZETPRINTFLETTER
|
|
# ifndef __LP64__
|
|
# define SIZETPRINTFLETTER "u"
|
|
# else
|
|
# define SIZETPRINTFLETTER "lu"
|
|
# endif
|
|
#endif
|
|
|
|
void start_element_stub(void* userdata,const XML_Char* name, const XML_Char** attrs );
|
|
void end_element_stub(void* userdata,const XML_Char* name);
|
|
void data_stub(void* userdata, const XML_Char* data, int len);
|
|
|
|
/**
|
|
table for translation base64 -> 0 to 63
|
|
*/
|
|
static char base64_table[] = {
|
|
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
|
|
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
|
|
-1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
|
|
52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1,
|
|
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
|
|
15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
|
|
-1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
|
|
41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1
|
|
};
|
|
|
|
|
|
class xml_result_handler {
|
|
/**
|
|
*/
|
|
int alloc_stepsize;
|
|
/**
|
|
maximum allocated size of buffer list
|
|
*/
|
|
size_t bufferno_max;
|
|
/**
|
|
actual or new sample buffer
|
|
*/
|
|
size_t bufferno;
|
|
/**
|
|
buffers
|
|
*/
|
|
short int** buffers;
|
|
/**
|
|
number of samples (2 values for one sample) in each buffer, if actual buffer, this is the expected number
|
|
*/
|
|
size_t* sampleno;
|
|
/**
|
|
*/
|
|
double* frequencies;
|
|
/**
|
|
maximum allocated size of last sample buffer in bytes
|
|
*/
|
|
size_t bufferlength;
|
|
/**
|
|
position of in actual sample buffer
|
|
*/
|
|
size_t bufferpos;
|
|
/**
|
|
base64 byte buffer
|
|
*/
|
|
char base64buffer[4];
|
|
/**
|
|
the length of content in base64buffer
|
|
*/
|
|
int base64buffer_length;
|
|
/**
|
|
1 if we are inside a adcdata section, 2 if we are saving a description
|
|
*/
|
|
int section_state;
|
|
/**
|
|
error messages, that are found
|
|
*/
|
|
std::string error_message;
|
|
/**
|
|
descripton sections
|
|
*/
|
|
std::string description_text;
|
|
|
|
public:
|
|
xml_result_handler(XML_Parser p) {
|
|
/* set event handlers */
|
|
alloc_stepsize=1<<10;
|
|
XML_SetElementHandler(p,start_element_stub,end_element_stub);
|
|
XML_SetCharacterDataHandler(p,data_stub);
|
|
XML_SetUserData(p,this);
|
|
|
|
/* allocate some buffers */
|
|
sampleno=(size_t*)malloc(alloc_stepsize*sizeof(size_t));
|
|
buffers=(short int**)malloc(alloc_stepsize*sizeof(short int*));
|
|
frequencies=(double*)malloc(alloc_stepsize*sizeof(double));
|
|
if (sampleno==NULL || buffers==NULL) {
|
|
if (sampleno!=NULL) free(sampleno);
|
|
if (buffers!=NULL) free(buffers);
|
|
if (frequencies!=NULL) free(frequencies);
|
|
/* todo throw something */
|
|
return;
|
|
}
|
|
bufferno=0;
|
|
buffers[0]=NULL;
|
|
bufferno_max=alloc_stepsize;
|
|
section_state=0;
|
|
}
|
|
|
|
void start_element(const XML_Char* name, const XML_Char** attrs) {
|
|
if (strcmp(name,"adcdata")==0) {
|
|
/* is there enough space in array? */
|
|
if (bufferno>=bufferno_max) {
|
|
bufferno_max+=alloc_stepsize;
|
|
buffers=(short int**)realloc((void*)buffers,bufferno_max*sizeof(short int*));
|
|
sampleno=(size_t*)realloc((void*)sampleno,bufferno_max*sizeof(size_t));
|
|
frequencies=(double*)realloc((void*)frequencies,bufferno_max*sizeof(double));
|
|
if (buffers==NULL || sampleno==NULL || frequencies==NULL) fprintf(stderr,"could not reallocate the buffer");
|
|
}
|
|
/* todo read sample no*/
|
|
const XML_Char** pos=attrs;
|
|
while (*pos!=NULL) {
|
|
if (strcmp(*pos,"samples")==0 || strcmp(*pos,"s")==0) {
|
|
sampleno[bufferno]=strtoul(*(pos+1),NULL,0);
|
|
}
|
|
else if (strcmp(*pos,"frequency")==0 || strcmp(*pos,"f")==0) {
|
|
frequencies[bufferno]=strtod(*(pos+1),NULL);
|
|
}
|
|
pos+=2;
|
|
}
|
|
if (sampleno[bufferno]!=0) {
|
|
bufferlength=sampleno[bufferno]*2*sizeof(short int);
|
|
/* fresh buffer */
|
|
buffers[bufferno]=(short int*)malloc(bufferlength);
|
|
}
|
|
else {
|
|
bufferlength=0;
|
|
buffers[bufferno]=NULL;
|
|
}
|
|
bufferpos=0;
|
|
/* todo check result */
|
|
base64buffer_length=0;
|
|
section_state=1;
|
|
}
|
|
if (strcmp(name,"description")) {
|
|
section_state=3;
|
|
}
|
|
if (strcmp(name,"error")==0) {
|
|
section_state=2;
|
|
}
|
|
if (section_state==3) {
|
|
description_text+="<";
|
|
description_text+=name;
|
|
const XML_Char** attr=attrs;
|
|
while(*attr!=NULL) {
|
|
description_text+=" ";
|
|
description_text+=*(attr++);
|
|
description_text+="='";
|
|
description_text+=*(attr++);
|
|
description_text+="'";
|
|
}
|
|
description_text+=">";
|
|
}
|
|
}
|
|
|
|
void end_element(const XML_Char* name) {
|
|
if (strcmp(name,"adcdata")==0) {
|
|
/* empty base64 buffer */
|
|
if (bufferpos+base64buffer_length-1>=bufferlength) {
|
|
bufferlength+=alloc_stepsize;
|
|
buffers[bufferno]=(short int*)realloc(buffers[bufferno],bufferlength);
|
|
/* todo reallocate check */
|
|
}
|
|
|
|
if (base64buffer_length>1) {
|
|
unsigned char s=base64buffer[0];
|
|
s<<=2;
|
|
s|=(base64buffer[1]>>4);
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
if (base64buffer_length>2) {
|
|
s=base64buffer[1]&15;
|
|
s<<=4;
|
|
s|=(base64buffer[2]>>2);
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
if (base64buffer_length>3) {
|
|
s=base64buffer[2]&3;
|
|
s<<=6;
|
|
s|=base64buffer[3];
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
}
|
|
}
|
|
}
|
|
/* check right sample number */
|
|
if (bufferpos!=sampleno[bufferno]*2*sizeof(short int)) {
|
|
sampleno[bufferno]=bufferpos/(2*sizeof(short int));
|
|
}
|
|
/* prepare for next buffer */
|
|
bufferlength=0;
|
|
bufferno++;
|
|
section_state=0;
|
|
}
|
|
if (strcmp(name,"error")==0) {
|
|
if (!error_message.empty() && error_message[error_message.size()-1]!='\n') {
|
|
error_message.push_back('\n');
|
|
}
|
|
section_state=0;
|
|
}
|
|
if (section_state==3) {
|
|
description_text+="<";
|
|
description_text+=name;
|
|
description_text+="/>";
|
|
}
|
|
if (strcmp(name,"description")) {
|
|
section_state=0;
|
|
}
|
|
}
|
|
|
|
void data(const XML_Char* the_data, int len) {
|
|
if (section_state==1) {
|
|
int pos=0;
|
|
while (pos<len) {
|
|
/* fill buffer */
|
|
while (base64buffer_length<4 && pos<len) {
|
|
if (((unsigned char)the_data[pos])<128) {
|
|
char value=base64_table[(unsigned char)the_data[pos]];
|
|
if (value!=-1) {
|
|
base64buffer[base64buffer_length]=value;
|
|
base64buffer_length++;
|
|
}
|
|
}
|
|
pos++;
|
|
}
|
|
/* interprete buffer, that has 4*6 bits=3 byte */
|
|
if (base64buffer_length==4) {
|
|
/* check the space */
|
|
if (bufferpos+3>=bufferlength) {
|
|
/* to do reallocate */
|
|
bufferlength+=alloc_stepsize;
|
|
buffers[bufferno]=(short int*)realloc(buffers[bufferno],bufferlength);
|
|
if (buffers[bufferno]==NULL) fprintf(stderr,"could not enlarge the sample buffer\n");
|
|
}
|
|
/* read three bytes from four letters */
|
|
unsigned char s=base64buffer[0];
|
|
s<<=2;
|
|
s|=(base64buffer[1]>>4);
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
s=base64buffer[1]&15;
|
|
s<<=4;
|
|
s|=(base64buffer[2]>>2);
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
s=base64buffer[2]&3;
|
|
s<<=6;
|
|
s|=base64buffer[3];
|
|
((char*)buffers[bufferno])[bufferpos]=s;
|
|
bufferpos++;
|
|
base64buffer_length=0;
|
|
}
|
|
}
|
|
}
|
|
else if (section_state==3) {
|
|
description_text+=the_data;
|
|
}
|
|
else if (section_state==2) {
|
|
error_message+=the_data;
|
|
}
|
|
}
|
|
|
|
~xml_result_handler() {
|
|
if (sampleno!=NULL && buffers!=NULL) {
|
|
size_t pos=0;
|
|
while (pos<=bufferno) {
|
|
if (buffers[pos]!=NULL) free(buffers[pos]);
|
|
pos++;
|
|
}
|
|
}
|
|
if (sampleno!=NULL) free(sampleno);
|
|
if (buffers!=NULL) free(buffers);
|
|
}
|
|
|
|
|
|
/**
|
|
print number of samples and frequency of the obtained data
|
|
*/
|
|
void print_info(FILE* f) {
|
|
if (buffers==NULL || sampleno==NULL) {
|
|
fprintf(f,"nothing saved\n");
|
|
return;
|
|
}
|
|
for (size_t i=0; i<bufferno; i++) {
|
|
fprintf(f,"%" SIZETPRINTFLETTER ": %" SIZETPRINTFLETTER " samples %f Hz frequency\n",i,sampleno[i],frequencies[i]);
|
|
if (buffers[i]!=NULL) {
|
|
for (size_t j=0; j<sampleno[i]; j++) {
|
|
short int a=buffers[i][j*2];
|
|
short int b=buffers[i][j*2+1];
|
|
fprintf(f,"%hd %hd\n",a,b);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
};
|
|
|
|
void start_element_stub(void* userdata,const XML_Char* name, const XML_Char** attrs ) {
|
|
((xml_result_handler*)userdata)->start_element(name,attrs);
|
|
}
|
|
|
|
void end_element_stub(void* userdata,const XML_Char* name) {
|
|
((xml_result_handler*)userdata)->end_element(name);
|
|
}
|
|
|
|
void data_stub(void* userdata, const XML_Char* data, int len ) {
|
|
((xml_result_handler*)userdata)->data(data,len);
|
|
}
|
|
|
|
|
|
xml_result_reader::xml_result_reader() {
|
|
jobfilenamepattern="";
|
|
}
|
|
|
|
xml_result_reader::~xml_result_reader() {
|
|
}
|
|
|
|
xml_result_reader::xml_result_reader(const std::string& jobpattern) {
|
|
jobfilenamepattern=jobpattern;
|
|
}
|
|
|
|
/* ToDo error handling */
|
|
result* xml_result_reader::read(size_t no) {
|
|
if (jobfilenamepattern=="") return NULL;
|
|
char* tmp_name=(char*)malloc(jobfilenamepattern.size()+50);
|
|
if (tmp_name==NULL) return NULL;
|
|
snprintf(tmp_name,jobfilenamepattern.size()+50,jobfilenamepattern.c_str(),no);
|
|
result* new_result=NULL;
|
|
new_result=read(std::string(tmp_name));
|
|
free(tmp_name);
|
|
return new_result;
|
|
}
|
|
|
|
result* xml_result_reader::read(const std::string& jobfilename) {
|
|
/*open file*/
|
|
FILE* result_file=fopen(jobfilename.c_str(),"rb");
|
|
if (result_file==NULL) return NULL;
|
|
|
|
XML_Parser parser=XML_ParserCreate(NULL);
|
|
if (parser==NULL) {
|
|
fclose(result_file);
|
|
return NULL;
|
|
}
|
|
|
|
xml_result_handler h(parser);
|
|
|
|
for (;;) {
|
|
const size_t BUFF_SIZE=1<<10;
|
|
int bytes_read;
|
|
void *buff = XML_GetBuffer(parser, BUFF_SIZE);
|
|
if (buff == NULL) {
|
|
fprintf(stderr, "could not get the buffer from XML Parser\n");
|
|
fclose(result_file);
|
|
return NULL;
|
|
}
|
|
|
|
bytes_read = fread(buff, 1, BUFF_SIZE, result_file);
|
|
if (bytes_read < 0) {
|
|
/* handle error */
|
|
fprintf(stderr,"error while reading\n");
|
|
break;
|
|
}
|
|
|
|
if (! XML_ParseBuffer(parser, bytes_read, bytes_read == 0)) {
|
|
/* handle parse error */
|
|
fprintf(stderr,"error while parsing line %d: %s\n",static_cast<int>(XML_GetCurrentLineNumber(parser)),XML_ErrorString(XML_GetErrorCode(parser)));
|
|
break;
|
|
}
|
|
|
|
// peaceful end
|
|
if (bytes_read == 0) break;
|
|
}
|
|
|
|
fclose(result_file);
|
|
return NULL;
|
|
}
|
|
|
|
/* ************************************************************************************************
|
|
|
|
here starts the writer implementation
|
|
|
|
**************************************************************************************************/
|
|
|
|
xml_result_writer::xml_result_writer(data_save_mode_type how) {
|
|
resultfilename_pattern="";
|
|
data_save_mode=how;
|
|
}
|
|
|
|
xml_result_writer::xml_result_writer(const std::string& pattern, data_save_mode_type how) {
|
|
resultfilename_pattern=pattern;
|
|
data_save_mode=how;
|
|
}
|
|
|
|
|
|
int xml_result_writer::write_to_file(const std::string& filename, const result* res) const {
|
|
// find the way to write
|
|
const adc_result* adc_res=dynamic_cast<const adc_result*>(res);
|
|
if (adc_res!=NULL) {
|
|
write_adc_to_file(filename,adc_res);
|
|
return 0;
|
|
}
|
|
const adc_results* adc_ress=dynamic_cast<const adc_results*>(res);
|
|
if (adc_ress!=NULL) {
|
|
write_adcs_to_file(filename, adc_ress);
|
|
return 0;
|
|
}
|
|
const configuration_results* config_ress=dynamic_cast<const configuration_results*>(res);
|
|
if (config_ress!=NULL) {
|
|
write_configuration_results_to_file(filename, *config_ress);
|
|
return 0;
|
|
}
|
|
|
|
const error_result* err_res=dynamic_cast<const error_result*>(res);
|
|
if (err_res!=NULL) write_error_to_file(filename,err_res);
|
|
else
|
|
write_unknown_to_file(filename, res);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_unknown_to_file(const std::string& filename, const result* res) const {
|
|
FILE* out=fopen(filename.c_str(),"w");
|
|
if (out==0) fprintf(stderr,"could not open file %s\n",filename.c_str());
|
|
fprintf(out,"<?xml version=\"1.0\"?>\n");
|
|
fprintf(out,"<result job=\"%" SIZETPRINTFLETTER "\">\n",res->job_no);
|
|
if (res==NULL)
|
|
fprintf(out,"<!-- got NULL pointer result... -->\n");
|
|
else
|
|
fprintf(out,"<!-- don't know how to print result... -->\n");
|
|
fprintf(out,"</result>\n");
|
|
fclose(out);
|
|
return 0;
|
|
}
|
|
|
|
|
|
int xml_result_writer::write_error_to_file(const std::string& filename, const error_result* res) const {
|
|
/* write an extra message to stderr */
|
|
fprintf(stderr,"job %" SIZETPRINTFLETTER ": %s\n",res->job_no,res->error_message.c_str());
|
|
FILE* out=fopen(filename.c_str(),"w");
|
|
if (out==0) {
|
|
fprintf(stderr,"could not open file %s\n",filename.c_str());
|
|
return 0;
|
|
}
|
|
fprintf(out,"<?xml version=\"1.0\"?>\n");
|
|
fprintf(out,"<result job=\"%" SIZETPRINTFLETTER "\">\n",res->job_no);
|
|
fprintf(out," <error>%s</error>\n",res->error_message.c_str());
|
|
fprintf(out,"</result>");
|
|
fclose(out);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_configuration_results_to_file(const std::string& filename, const configuration_results& ress) const {
|
|
|
|
FILE* out=fopen(filename.c_str(),"w");
|
|
fprintf(out,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
|
|
fprintf(out,"<result job=\"%" SIZETPRINTFLETTER "\">\n<configuration>\n",ress.job_no);
|
|
XMLCh tempStr[300];
|
|
xercesc::XMLString::transcode("LS", tempStr, 299);
|
|
xercesc::DOMImplementation *impl2 = xercesc::DOMImplementationRegistry::getDOMImplementation(tempStr);
|
|
xercesc::DOMLSSerializer *theSerializer=(static_cast<xercesc::DOMImplementationLS*>(impl2))->createLSSerializer();
|
|
xercesc::DOMLSOutput *theOutputDesc=(static_cast<xercesc::DOMImplementationLS*>(impl2))->createLSOutput();
|
|
|
|
for (configuration_results::const_iterator i=ress.begin(); i!=ress.end(); ++i)
|
|
if ((*i)->tag->getDocumentElement()!=NULL) {
|
|
xercesc::MemBufFormatTarget mem;
|
|
theOutputDesc->setByteStream(&mem);
|
|
xercesc::DOMNode *the_node = (*i)->tag->getDocumentElement();
|
|
theSerializer->write(the_node ,theOutputDesc);
|
|
//theSerializer->writeNode(&mem,*((*i)->tag->getDocumentElement()));
|
|
|
|
fwrite((char*)mem.getRawBuffer(),sizeof(char),mem.getLen(),out);
|
|
mem.reset();
|
|
}
|
|
theSerializer->release();
|
|
|
|
// todo
|
|
fprintf(out,"</configuration>\n</result>\n");
|
|
fclose(out);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_adcs_to_file(const std::string& filename, const adc_results* ress) const {
|
|
// fall back to some default mode
|
|
data_save_mode_type how=data_save_mode;
|
|
if (how==defaultmode) how=ascii;
|
|
FILE* out=fopen(filename.c_str(),"w");
|
|
if (out==0) {
|
|
fprintf(stderr,"could not open file %s\n",filename.c_str());
|
|
return 0;
|
|
}
|
|
fprintf(out,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
|
|
fprintf(out,"<result job=\"%" SIZETPRINTFLETTER "\">\n",ress->job_no);
|
|
fwrite(ress->description.c_str(),ress->description.size(),1,out);
|
|
fprintf(out,"\n");
|
|
int num_res=0;
|
|
for (adc_results::const_iterator res=ress->begin(); res!=ress->end(); ++res) {
|
|
switch (how) {
|
|
case separate_file:
|
|
{
|
|
// write separate data file
|
|
char result_filename[1<<10];
|
|
snprintf(result_filename,sizeof(result_filename),"adc.%09" SIZETPRINTFLETTER ".%d.bin",ress->job_no,num_res);
|
|
write_adcdata_separate(out, std::string(result_filename), *res);
|
|
}
|
|
break;
|
|
case base64:
|
|
write_adcdata_base64(out,*res);
|
|
break;
|
|
case csv:
|
|
write_adcdata_formated(out,"%d; %d\n",*res);
|
|
break;
|
|
case ascii:
|
|
write_adcdata_formated(out,"%d\t%d\n",*res);
|
|
break;
|
|
default:
|
|
/* forget data */
|
|
fprintf(stderr,"forgeting adc data\n");
|
|
}
|
|
num_res++;
|
|
}
|
|
fprintf(out,"</result>\n");
|
|
fclose(out);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_adc_to_file(const std::string& filename, const adc_result* res) const {
|
|
// fall back to some default mode
|
|
data_save_mode_type how=data_save_mode;
|
|
if (how==defaultmode) how=ascii;
|
|
FILE* out=fopen(const_cast<char*>(filename.c_str()),"w");
|
|
if (out==0) {
|
|
fprintf(stderr,"write_adc_to_file: could not open file %s\n",filename.c_str());
|
|
return 0;
|
|
}
|
|
fprintf(out,"<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
|
|
fprintf(out,"<result job=\"%" SIZETPRINTFLETTER "\">\n",res->job_no);
|
|
fwrite(res->description.c_str(),res->description.size(),1,out);
|
|
fprintf(out,"\n");
|
|
switch (how) {
|
|
case separate_file:
|
|
{
|
|
// write separate data file
|
|
write_adcdata_separate(out, filename+".bin", res);
|
|
}
|
|
break;
|
|
case base64:
|
|
write_adcdata_base64(out,res);
|
|
break;
|
|
case csv:
|
|
write_adcdata_formated(out,"%d; %d\n",res);
|
|
break;
|
|
case ascii:
|
|
write_adcdata_formated(out,"%d\t%d\n",res);
|
|
break;
|
|
default:
|
|
/* forget data */
|
|
fprintf(stderr,"forgetting adc data\n");
|
|
}
|
|
fprintf(out,"</result>\n");
|
|
fclose(out);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_adcdata_separate(FILE* out, const std::string& datafilename, const adc_result* res) const {
|
|
/* todo: error handling */
|
|
FILE* binout=fopen(datafilename.c_str(),"wb");
|
|
if (binout==0) {
|
|
fprintf(stderr,"could not open file %s\n",datafilename.c_str());
|
|
return 0;
|
|
}
|
|
fwrite(res->data, sizeof(short int)*res->nchannels, res->samples, binout);
|
|
fclose(binout);
|
|
fprintf(out,
|
|
"<adcdatafile path=\"%s\" samples=\"%" SIZETPRINTFLETTER "\" rate=\"%g\" channels=\"%i\"/>\n",
|
|
datafilename.c_str(),
|
|
res->samples,
|
|
res->sampling_frequency,
|
|
res->nchannels);
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_adcdata_formated(FILE* out, const std::string& format, const adc_result* res) const {
|
|
fprintf(out,"<adcdata samples=\"%" SIZETPRINTFLETTER "\" rate=\"%g\" channels=\"%i\">\n",res->samples,res->sampling_frequency, res->nchannels);
|
|
for(size_t i=0;i<res->samples;++i) {
|
|
for(int j=0;j<res->nchannels;++j) {
|
|
fprintf(out, format.c_str(), res->data[i*2+ j]);
|
|
}
|
|
}
|
|
fprintf(out,"</adcdata>\n");
|
|
return 0;
|
|
}
|
|
|
|
int xml_result_writer::write_adcdata_base64(FILE* out, const adc_result* res) const {
|
|
xercesc::XMLPlatformUtils::Initialize();
|
|
fprintf(out,"<adcdata samples=\"%" SIZETPRINTFLETTER "\" rate=\"%g\" channels=\"%i\">\n",res->samples,res->sampling_frequency, res->nchannels);
|
|
unsigned int base64length=0;
|
|
XMLByte* base64buffer=xercesc::Base64::encode( reinterpret_cast<XMLByte*>(res->data),
|
|
res->samples*res->nchannels*sizeof(short int),
|
|
reinterpret_cast<XMLSize_t*>(&base64length),
|
|
xercesc::XMLPlatformUtils::fgMemoryManager );
|
|
fwrite(base64buffer,1,base64length,out);
|
|
fprintf(out,"</adcdata>\n");
|
|
xercesc::XMLPlatformUtils::fgMemoryManager->deallocate(base64buffer);
|
|
return 0;
|
|
}
|