Select Git revision
front-controller.php
-
Sonia Zorba authored
removed globals from classes, added AJAX waiting animations, removed additional email address, little fixes
Sonia Zorba authoredremoved globals from classes, added AJAX waiting animations, removed additional email address, little fixes
SDFBlock.cpp 26.88 KiB
/***************************************************************************
SDFBlock.cpp - description
-------------------
begin : Thu Nov 29 2001
copyright : (C) 2001, 2013 by Andrea Bulgarelli
email : bulgarelli@iasfbo.inaf.it
***************************************************************************/
/***************************************************************************
* *
* This program is free software for non commercial purpose *
* and for public research institutes; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License. *
* For commercial purpose see appropriate license terms *
* *
***************************************************************************/
#include <sstream>
#include "SDFBlock.h"
#include "ConfigurationFile.h"
#include "PacketExceptionFileFormat.h"
using namespace PacketLib;
static SDFBlockType** blockTypeList = 0;
long SDFBlock::counter = 0;
SDFBlockType::SDFBlockType()
{
// cout << "SDFBlockType::SDFBlockType " << sizeof(SDFBlockType) << endl;
}
void SDFBlockType::loadType(pugi::xml_node node, const pugi::xml_document& doc,
std::map<pugi::xml_node, int>& physicalIndex)
{
nblockmax = 0;
const char* popName = node.attribute("name").value();
int dimline = strlen(popName);
name = (char*) new char[dimline+1];
strncpy(name, popName, dimline+1);
pugi::xml_node fNode = node.child("field");
if(fNode)
fixedPresent = true;
else
fixedPresent = false;
variablePresent = false;
pugi::xpath_node_set rbNodeSet = node.select_nodes("rblock");
if(rbNodeSet.size() == 0)
{
variablePresent = true;
numberOfRBlocks = rbNodeSet.size();
if(numberOfRBlocks > 65535)
throw new PacketExceptionFileFormat("Too many number of Rblocks in the packet type.");
rblockFilename = new char*[numberOfRBlocks];
rBlockVariable = new bool[numberOfRBlocks];
maxNumberOfBlock = new word[numberOfRBlocks];
indexOfNBlock = new word[numberOfRBlocks];
subFromNBlock = new word[numberOfRBlocks];
numberOfBlockFixed = new bool[numberOfRBlocks];
headerLevelOfNBlockIndex = new word[numberOfRBlocks];
operatorType = new byte[numberOfRBlocks];
for(int i=0; i < numberOfRBlocks; i++)
{
const pugi::xml_node rbNode = rbNodeSet[i].node(); pugi::xml_attribute idref = rbNode.attribute("idref");
if(idref)
rBlockVariable[i] = true;
else
rBlockVariable[i] = false;
const char* nblocks = rbNode.attribute("maxnumberofblocks").value();
maxNumberOfBlock[i] = atoi(nblocks);
if(maxNumberOfBlock[i] > 65535)
throw new PacketExceptionFileFormat("Too many number of blocks in the packet type.");
if(!idref)
headerLevelOfNBlockIndex[i] = 0;
else
{
string query = string("//field[@id=\"")+idref.value()+"\"]";
pugi::xml_node numberofblocksid = doc.select_nodes(query.c_str())[0].node();
pugi::xml_node nodetmp = rbNode;
unsigned int level = 0;
while(nodetmp.parent() != numberofblocksid.parent())
{
// if the parent is a packet means that the id is not in the fixed part of the
// recursive rblocks nor the sourcedatafield. So test the datafieldheader
// and header, otherwise complain.
if(string(nodetmp.parent().name()).compare("packet") == 0)
{
string idparentnodename = numberofblocksid.parent().name();
if(idparentnodename.compare("datafieldheader") == 0)
{
// we have already add 1 level because nodetmp in this case is
// the sourcedatafield node
}
else if(idparentnodename.compare("header") == 0)
{
// we add just one level for the same reason above
level++;
}
else
{
std::stringstream ss;
ss << "Error on id association. Id'" << idref.value() << "' doesn't exists. idref defined by rblock '" << rbNode.attribute("name").value() << "'.";
throw new PacketExceptionFileFormat(ss.str().c_str());
}
break;
}
level++;
nodetmp = nodetmp.parent();
}
headerLevelOfNBlockIndex[i] = level;
indexOfNBlock[i] = physicalIndex[numberofblocksid]; // TODO fix this..
pugi::xml_attribute offsetAttr = numberofblocksid.attribute("numberofblocksoffset");
const char* offset;
if(offsetAttr)
offset = offsetAttr.value();
else
offset = "0";
switch(offset[0])
{
case '/':
operatorType[i] = 1;
subFromNBlock[i] = atoi(offset+1);
break;
case '*':
operatorType[i] = 2;
subFromNBlock[i] = atoi(offset+1);
break;
default: operatorType[i] = 0;
subFromNBlock[i] = atoi(offset);
}
rblockFilename[i] = (char*) rbNode.attribute("name").value();
}
nblockmax += maxNumberOfBlock[i];
}
}
else
{
numberOfRBlocks = 0;
rblockFilename = 0;
rBlockVariable = 0;
maxNumberOfBlock = 0;
indexOfNBlock = 0;
subFromNBlock = 0;
numberOfBlockFixed = 0;
headerLevelOfNBlockIndex = 0;
operatorType = 0;
}
}
bool SDFBlockType::loadType(InputText& fp) throw(PacketException*)
{
char* popName = fp.getInputTextName();
try
{
int dimline = strlen(popName);
name = (char*) new char[dimline+1];
strcpy(name, popName);
//cout << type->name << endl;
fp.setpos(0);
char* line=fp.getLine("[RBlock Configuration]");
if(strlen(line) != 0)
{
/// fixed part
line = fp.getLine();
if(strcmp(line, "yes") == 0)
{
fixedPresent = true;
}
else
{
if(strcmp(line, "no") == 0)
fixedPresent = false;
else
throw new PacketExceptionFileFormat("Rblock file format error. Fixed part section - expected yes or no keywords.");
}
/// variable part
line = fp.getLine();
if(strcmp(line, "yes") == 0)
{
variablePresent = true;
}
else
{
if(strcmp(line, "no") == 0)
variablePresent = false;
else
throw new PacketExceptionFileFormat("Rblock file format error. Variable part section - expected yes or no keywords.");
}
if(variablePresent)
{ /// numero di rblocchi presenti
line = fp.getLine();
dword nev = atoi(line);
if(nev > 65535)
throw new PacketExceptionFileFormat("Too many number of Rblocks in the packet type.");
numberOfRBlocks = nev;
/// Memory allocation to handle the expected rblock
rblockFilename = new char* [nev];
rBlockVariable = new bool[nev];
maxNumberOfBlock = new word[nev];
indexOfNBlock = new word[nev];
subFromNBlock = new word[nev];
numberOfBlockFixed = new bool[nev];
headerLevelOfNBlockIndex = new word[nev];
operatorType = new byte[nev];
}
else
{
numberOfRBlocks = 0;
rblockFilename = 0;
rBlockVariable = 0;
maxNumberOfBlock = 0;
indexOfNBlock = 0;
subFromNBlock = 0;
numberOfBlockFixed = 0;
headerLevelOfNBlockIndex = 0;
operatorType = 0;
}
if(variablePresent)
{
/// It finds the [SourceDataFieldBlock] section
for(int i=0; i< numberOfRBlocks; i++)
{
char* linefind = Utility::integerToString3((char*)"[RBlock%d]", i+1);
fp.setpos(0);
line=fp.getLine(linefind);
/*if(i == 0)
line = fp.getLastLineRead();
else
line = fp.getLine();*/
if(strcmp(line, linefind) == 0)
{
if(i != 0)
{
line = 0;
}
/// delete[] linefind;
linefind = 0;
/// type of number of block
line = fp.getLine();
if(strcmp(line, "variable") == 0)
{
rBlockVariable[i] = true;
}
else
{
if(strcmp(line, "fixed") == 0)
{
rBlockVariable[i] = false;
}
else
throw new PacketExceptionFileFormat("It's impossibile to identify the type of rblock. Expected fixed or variable keywords.");
}
/// number of blocks line = fp.getLine();
dword nev = atoi(line);
if(nev > 65535)
throw new PacketExceptionFileFormat("Too many number of blocks in the packet type.");
maxNumberOfBlock[i] = (word) nev;
/// header level for the index of field
line = fp.getLine();
headerLevelOfNBlockIndex[i] = atoi(line);
/// index of field
line = fp.getLine();
indexOfNBlock[i] = atoi(line);
/// sum value
line = fp.getLine();
switch(line[0])
{
case '/':
operatorType[i] = 1;
subFromNBlock[i] = atoi(line+1);
break;
case '*':
operatorType[i] = 2;
subFromNBlock[i] = atoi(line+1);
break;
default:
operatorType[i] = 0;
subFromNBlock[i] = atoi(line);
}
/// file name of the rblock
rblockFilename[i] = fp.getLine();
// cout << "S " << rblockFilename[i] << endl;
}
else
throw new PacketExceptionFileFormat("No [RBlockX] section found.");
}
}
nblockmax = 0;
if(variablePresent)
{
for(int i=0; i < numberOfRBlocks; i++)
nblockmax += maxNumberOfBlock[i];
}
}
else
throw new PacketExceptionFileFormat("[RBlock Configuration] section not found");
}
catch(PacketException* e)
{
e->add(": ");
e->add(popName);
throw e;
}
return true;
}
SDFBlock::SDFBlock() : block(0)
{
tempBlock1 = ByteStreamPtr(new ByteStream());
counter++;
//cout << counter << " " << sizeof(SDFBlock) << endl;
/// create BlockType list if(blockTypeList == 0)
{
dword nb = CONFIG_MAXNUMBER_OFCONFIGILES;
blockTypeList = (SDFBlockType**) new SDFBlockType* [nb];
for(dword i = 0; i<nb; i++)
blockTypeList[i] = 0;
}
}
SDFBlock::~SDFBlock()
{
delete[] block;
}
void SDFBlock::loadFieldsSDFB(pugi::xml_node rbNode, const pugi::xml_document& doc,
std::map<pugi::xml_node, int>& physicalIndex)
{
popName = (char*) rbNode.attribute("name").value();
dword indexlist = 0;
type = 0;
while(blockTypeList[indexlist] != 0)
{
if(strcmp(blockTypeList[indexlist]->name, popName) == 0)
{
type = blockTypeList[indexlist];
break;
}
else
indexlist++;
}
this->previous = previous;
if(type == 0)
{
// cout << "create the type " << popName << endl;
type = new SDFBlockType;
blockTypeList[indexlist] = type;
type->loadType(rbNode, doc, physicalIndex);
}
// cout << "NZ " << type->name << endl;
if(type->variablePresent)
numberOfRealDataBlock = new word[type->numberOfRBlocks];
else
numberOfRealDataBlock = 0;
/// It loads the fixed part (if present)
fixed.previous = previous;
if(type->fixedPresent)
fixed.loadFields(rbNode);
if(type->variablePresent)
{
for(int i=0; i< type->numberOfRBlocks; i++)
if(type->rBlockVariable[i] == false)
numberOfRealDataBlock[i] = type->maxNumberOfBlock[i];
block = (SDFBlock*) new SDFBlock[type->nblockmax];
int indexRBlock = 0;
dword sumBlock = type->maxNumberOfBlock[indexRBlock];
word id = 0;
for(dword nblock=0; nblock < type->nblockmax; nblock++)
{
if(nblock >= sumBlock)
{
indexRBlock++;
id = 0;
sumBlock += type->maxNumberOfBlock[indexRBlock]; }
block[nblock].setPreviousPop(&fixed);
block[nblock].setRBlockType(indexRBlock);
block[nblock].setID(id);
pugi::xml_node childNode = rbNode.child(type->rblockFilename[indexRBlock]);
block[nblock].loadFieldsSDFB(childNode, doc, physicalIndex);
id++;
}
}
}
bool SDFBlock::loadFields(InputText& fp) throw (PacketException*)
{
// cout << "0------" << endl;
char* line;
popName = fp.getInputTextName();
dword indexlist = 0;
indexlist = 0;
type = 0;
while(blockTypeList[indexlist] != 0)
{
if(strcmp(blockTypeList[indexlist]->name, popName) == 0)
{
type = blockTypeList[indexlist];
break;
}
else
indexlist++;
}
this->previous = previous;
// cout << "T" << type << endl;
if(type == 0)
{
// cout << "create the type " << popName << endl;
type = new SDFBlockType;
blockTypeList[indexlist] = type;
type->loadType(fp);
}
// cout << "NZ " << type->name << endl;
if(type->variablePresent)
{
numberOfRealDataBlock = new word[type->numberOfRBlocks];
}
else
{
numberOfRealDataBlock = 0;
}
/// It loads the fixed part (if present)
if(type->fixedPresent)
{
fp.setpos(0);
line=fp.getLine("[Fixed Part]");
if(strcmp(line, "[Fixed Part]") == 0)
{
fixed.previous = previous; //AB2014
fixed.loadFields(fp);
}
else
throw new PacketExceptionFileFormat("[Fixed Part] section not found");
} else
fixed.previous = previous;//AB2014
if(type->variablePresent)
{
for(int i=0; i< type->numberOfRBlocks; i++) if(type->rBlockVariable[i] == false)
numberOfRealDataBlock[i] = type->maxNumberOfBlock[i];
}
if(type->variablePresent)
{
// cout << "CP --- " << type->name << endl;
block = (SDFBlock*) new SDFBlock[type->nblockmax];
int indexRBlock = 0;
dword sumBlock = type->maxNumberOfBlock[indexRBlock];
word id = 0;
for(dword nblock=0; nblock < type->nblockmax; nblock++)
{
// cout << "nblock: " << nblock << endl;
if(nblock >= sumBlock)
{
indexRBlock++;
id = 0;
sumBlock += type->maxNumberOfBlock[indexRBlock];
}
ConfigurationFile* file = new ConfigurationFile;
char** argv = new char* [1];
// cout << "indexRBlock " << indexRBlock << endl;
argv[0] = type->rblockFilename[indexRBlock];
if(file->open(argv))
{
block[nblock].setPreviousPop(&fixed);
block[nblock].setRBlockType(indexRBlock);
block[nblock].setID(id);
// cout << "now load " << argv[0] << endl;
block[nblock].loadFields(*file);
id++;
file->close();
delete[] argv;
delete file;
}
else {
delete[] argv;
throw new PacketExceptionFileFormat("rblock file name not found.");
}
}
}
// cout << "1------" << endl;
return true;
}
//OK
dword SDFBlock::sizeMax()
{
/// for fixed part
dword dim = fixed.size();
///variable part
for(dword i=0; i < type->nblockmax; i++)
{
dim += block[i].sizeMax();
}
return dim;
}
dword SDFBlock::size()
{
/// for fixed part
dword dim = fixed.size();
///variable part
word bi = 0;
word rbi = 0;
for(int i=0; i < type->nblockmax; i++)
{ bi = block[i].getID();
rbi = block[i].getRBlockType();
word nrdb = getNumberOfBlocks(rbi);
if(bi < nrdb)
dim += block[i].size();
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
return dim;
}
SDFBlock* SDFBlock::getBlock(word nblock, word rBlockIndex)
{
if(rBlockIndex == 0)
return &block[nblock];
word bi = 0;
word rbi = 0;
for(int i=0; i< type->nblockmax; i++)
{
bi = block[i].getID();
rbi = block[i].getRBlockType();
if(rbi == rBlockIndex && bi == nblock)
return &block[i];
}
return 0;
}
void SDFBlock::setNumberOfBlocks(word number, word rblockIndex) throw (PacketException*)
{
/// In case the variable part is not present or rBlockVariable = false,
/// the field where to save the value is not present. The dimension is fixed.
if(!type->variablePresent || !type->rBlockVariable[rblockIndex])
{
throw new PacketException("It is not possible to set setNumberOfBlocks for this rBlock: variable part not present");
return;
}
PartOfPacket* pop = &fixed;
if(number > type->maxNumberOfBlock[rblockIndex])
throw new PacketException("It is not possible to set setNumberOfBlocks: too much blocks");
numberOfRealDataBlock[rblockIndex] = number;
for(int i=0; i< type->headerLevelOfNBlockIndex[rblockIndex]; i++)
pop = pop->previous;
if(type->operatorType[rblockIndex] == 1)
{
number *= 2; //NON FUNZIONA BENE, DA CONTROLLARE
}
if(type->operatorType[rblockIndex] == 2)
{
number /= 2;
}
pop->setFieldValue(type->indexOfNBlock[rblockIndex], number - type->subFromNBlock[rblockIndex]);
numberOfRealDataBlock[rblockIndex] = number;
reset_output_stream = true;
}
word SDFBlock::getNumberOfBlocks(word rblockIndex)
{
if(!type->variablePresent)
return 0;
if(!type->rBlockVariable[rblockIndex])
return type->maxNumberOfBlock[rblockIndex];
PartOfPacket* pop = &fixed;
for(int i=0; i< type->headerLevelOfNBlockIndex[rblockIndex]; i++)
pop = pop->previous;
if(type->operatorType[rblockIndex] == 0)
numberOfRealDataBlock[rblockIndex] = pop->getFieldValue(type->indexOfNBlock[rblockIndex]) + type->subFromNBlock[rblockIndex]; if(type->operatorType[rblockIndex] == 1)
{
word nb = pop->getFieldValue(type->indexOfNBlock[rblockIndex]);
if(nb % 2 != 0)
nb++;
nb = nb / 2;
nb += type->subFromNBlock[rblockIndex];
numberOfRealDataBlock[rblockIndex] = nb;
}
if(type->operatorType[rblockIndex] == 2)
{
word nb = pop->getFieldValue(type->indexOfNBlock[rblockIndex]);
nb = nb * 2;
nb += type->subFromNBlock[rblockIndex];
numberOfRealDataBlock[rblockIndex] = nb;
}
return numberOfRealDataBlock[rblockIndex];
}
word SDFBlock::getCurrentNumberOfBlocks()
{
word nblock = 0;
for(int i=0; i< type->numberOfRBlocks; i++)
nblock = getNumberOfBlocks(i);
return nblock;
}
bool SDFBlock::setOutputStream(ByteStreamPtr os, dword first)
{
dword start = first;
/// It sets the output stream for the fixed part (if present)
if(type->fixedPresent)
{
fixed.setOutputStream(os, start);
outputstream = ByteStreamPtr(new ByteStream((os->stream + start), size(), os->isBigendian()));
start += fixed.size();
}
if(type->variablePresent)
{
dword bi = 0;
dword rbi = 0;
for(word i=0; i < type->nblockmax; i++)
{
bi = block[i].getID();
rbi = block[i].getRBlockType();
if(bi < getNumberOfBlocks(rbi))
{
/// Only for valid blocks
block[i].setOutputStream(os, start);
start += block[i].size();
}
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
}
return true;
}
ByteStreamPtr SDFBlock::generateStream(bool bigendian)
{
if(type->fixedPresent)
fixed.generateStream(bigendian);
if(type->variablePresent)
{
word bi = 0;
word rbi = 0;
for(int i=0; i < type->nblockmax; i++)
{ bi = block[i].getID();
rbi = block[i].getRBlockType();
if(bi < getNumberOfBlocks(rbi))
{
/// Only for valid blocks
block[i].generateStream(bigendian);
}
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
}
return outputstream;
}
bool SDFBlock::setByteStream(ByteStreamPtr s, int decodeType)
{
//cout << "bool SDFBlock::setByteStream(ByteStreamPtr s)" << " " << s << endl; //AB
dword bytestart=0;
dword bytestop=0;
this->stream->setStream(s, 0, s->size() - 1);
if(decodeType == 0)
return true;
//ByteStreamPtr tmpstream = new ByteStream(s->stream, s->size(), s->isBigendian());
//ByteStreamPtr s = new ByteStream(k->stream, k->size(), k->isBigendian());
// It sets the output stream for the fixed part (if present)
if(type->fixedPresent)
{
bytestop += fixed.size() - 1;
if(tempBlock1->setStream(s, bytestart, bytestop))
if(!fixed.setByteStream(tempBlock1))
return false;
bytestart = bytestop + 1;
}
if(decodeType == 1)
return true;
if(type->variablePresent)
{
word bi = 0;
word rbi = 0;
for(int i=0; i < type->nblockmax; i++)
{
bi = block[i].getID();
rbi = block[i].getRBlockType();
word nrdb = getNumberOfBlocks(rbi);
if(bi < nrdb)
{
/// Only for valid blocks
/// 1) first of all the fixed part of block[i] must be set
/// before calling block[i].size(), otherwise only random values are present
tempBlock1->setStream(s, bytestart, s->size() - 1);
block[i].setByteStream(tempBlock1, decodeType);
/// 2) Now the correct computation of the dimension can be started
if(bytestop != 0)
bytestop += block[i].size();
else
bytestop += block[i].size() - 1;
if(tempBlock1->setStream(s, bytestart, bytestop))
if(!block[i].setByteStream(tempBlock1, decodeType))
return false;
bytestart = bytestop + 1;
}
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
}
return true;
}
char** SDFBlock::printValue(const char* addString)
{
char** cc;
char** ct;
word index=0;
word ntf = getTotalNumberOfFields();
cc = new char* [ntf+1];
if(type->fixedPresent)
{
ct = (char**) fixed.printValue(addString);
for(int ii=0; ct[ii] != 0; ii++)
{
cc[index] = ct[ii];
index++;
}
}
if(type->variablePresent)
{
word bi = 0;
word rbi = 0;
for(int i=0; i < type->nblockmax; i++)
{
bi = block[i].getID();
rbi = block[i].getRBlockType();
if(bi < getNumberOfBlocks(rbi))
{
/// Only for valid blocks
ct = block[i].printValue(addString);
for(int ii=0; ct[ii] != 0; ii++)
{
cc[index] = ct[ii];
index++;
}
}
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
}
cc[index] = 0;
return cc;
}
void SDFBlock::printValueStdout()
{
if(type->fixedPresent)
{
fixed.printValueStdout();
}
if(type->variablePresent)
{
word bi = 0;
word rbi = 0;
for(int i=0; i < type->nblockmax; i++)
{
bi = block[i].getID();
rbi = block[i].getRBlockType();
if(bi < getNumberOfBlocks(rbi))
{
/// Only for valid blocks
block[i].printValueStdout();
}
else
i += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
} }
}
string* SDFBlock::printStructure()
{
return new string("string* SDFBlock::printStructure() - TODO");
}
word SDFBlock::getTotalNumberOfFields()
{
/// for fixed part
word dim = fixed.getNumberOfFields();
word bi = 0;
word rbi = 0;
int j;
for(j=0; j < type->nblockmax; j++)
{
bi = block[j].getID();
rbi = block[j].getRBlockType();
if(bi < getNumberOfBlocks(rbi))
dim += block[j].getNumberOfFields();
else
j += type->maxNumberOfBlock[rbi] - getNumberOfBlocks(rbi) - 1;
}
return dim;
}
word SDFBlock::getFieldValue(string fieldname) {
return fixed.getFieldValue(fieldname);
}
signed short SDFBlock::getFieldValue_16i(string fieldname) {
return fixed.getFieldValue_16i(fieldname);
}
word SDFBlock::getFieldValue_16ui(string fieldname) {
return fixed.getFieldValue_16ui(fieldname);
}
signed long SDFBlock::getFieldValue_32i(string fieldname){
return fixed.getFieldValue_32i(fieldname);
}
unsigned long SDFBlock::getFieldValue_32ui(string fieldname){
return fixed.getFieldValue_32ui(fieldname);
}
float SDFBlock::getFieldValue_32f(string fieldname){
return fixed.getFieldValue_32f(fieldname);
}
double SDFBlock::getFieldValue_64f(string fieldname){
return fixed.getFieldValue_64f(fieldname);
}
void SDFBlock::setFieldValue(string fieldname, word value){
fixed.setFieldValue(fieldname, value);
}
void SDFBlock::setFieldValue_16i(string fieldname, signed short value){
fixed.setFieldValue_16i(fieldname, value);
}
void SDFBlock::setFieldValue_16ui(string fieldname, word value){
fixed.setFieldValue_16ui(fieldname, value);
}
void SDFBlock::setFieldValue_32i(string fieldname, signed long value){
fixed.setFieldValue_32i(fieldname, value);
}
void SDFBlock::setFieldValue_32ui(string fieldname, unsigned long value){
fixed.setFieldValue_32ui(fieldname, value);
}
void SDFBlock::setFieldValue_32f(string fieldname, float value){
fixed.setFieldValue_32f(fieldname, value);
}
void SDFBlock::setFieldValue_64f(string fieldname, double value){
fixed.setFieldValue_64f(fieldname, value);
}