/***************************************************************************
* setStaticFieldFunctionObject
***************************************************************************/
bool CCilVm::setStaticFieldFunctionObject( const RID rid,
const RID ridMethod )
{
assert( TypeFromToken( ridMethod ) == MDT_METHODDEF );
//Create function object and store it to static field
CVmObject newobject;
RID ridObj = getFunctionObjectRID();
newobject.setRID( ridObj );
newobject.setObjectName( getMetaData().getObjectNameRID( ridObj ) );
newobject.setPrototypeObject( &getPrototypeObject( ridObj ) );
newobject.setConstructorProperty( ridMethod );
newobject.setCallProperty( ridMethod );
getObjectPool().push_back( newobject );
CVariable var;
var.setObjectRef( &getObjectPool().back() );
METHOD_DEF& method = getMetaData().getMethod( ridMethod );
int32_t iLength = method.iNumArgments;
assert( iLength >= 0 );
CVariable varInt( iLength, OPERAND_FLAG_DONTENUM );
var.refObject->setProperty( STRING_INTERNAL_LENGTH,
varInt );
//Store the ObjectRef to a static field
setStaticField( rid, var );
return true;
}
/***************************************************************************
* bindBuiltinMethod
***************************************************************************/
bool CCilVm::bindBuiltinMethod( const wstring& strQualifiedName,
PMETHOD const pMethod,
const int32_t iLength )
{
bool bReturn = true;
RID ridMethod = getMetaData().queryBuiltinMethodRid( strQualifiedName );
if( ridMethod == RID_NULL )
return false;
//Bind the API
METHOD_DEF& method = getMetaData().getMethod( ridMethod );
if( method.MethodType != METHOD_NATIVE )
return false;
method.lpFunction = pMethod;
if( strQualifiedName.find( STRING_INTERNAL_SCOPEDELIMITER ) != wstring::npos )
{
wstring strRoot = strQualifiedName.substr( 0, strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) );
assert( strRoot.find( STRING_INTERNAL_SCOPEDELIMITER ) == wstring::npos );
wstring strLeaf = strQualifiedName.substr( strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) + 1,
strQualifiedName.length() );
RID ridObject = getMetaData().queryBuiltinObjectRid( strRoot );
if( ridObject == RID_NOTDEFINED )
return false;
//Create property
getPrototypeObject( ridObject ).setProperty( this,
strLeaf,
ridMethod,
iLength );
}
else
{
//Global method
//e.g. print, eval etc
//Those one need to have correspond static field to keep properties
CG_SYMBOL_INFORMATION& info = querySymbolInformation( strQualifiedName + STRING_OBJECTNAME_POSTFIX );
assert( info.Flags == CG_SYMBOL_FLAG_GLOBAL );
RID rid = info.rid;
assert( rid != RID_NOTDEFINED );
if( rid )
setStaticFieldFunctionObject( rid, ridMethod );
}
return bReturn;
}
std::vector<DetectionList> parseMRMData(const std::string& fileName) {
std::vector<DetectionList> data; data.reserve(DATA_POINTS);
std::string rowText, colText;
unsigned int lineNumber = 0;
for (GetLines row (fileName, &rowText); row.hasNext(); row.next()) {
// Setup
++lineNumber;
std::string rowAboveText;
GetElements col (rowText, &colText);
// Begin parsing line
if (isdigit(colText[0])) {
DetectionList line; line.lineNumber = lineNumber;
col.skip(1); // throw away first element
std::string type;
type = colText; col.next(); // second element is always message type
if (type == "MrmFullScanInfo") {
rowAboveText = rowText;
} else if (type == "MrmDetectionListInfo") {
getMetaData(rowText, line);
getDetectionList(rowText, line);
getMotionData(rowAboveText, line);
data.push_back(line);
}
}
}
return data;
}
void MprisPlugin::tuneUpdated(Tune *tune)
{
if(player_->state() == Qomp::StatePlaying) {
getMetaData(tune);
sendMetadata(PLAYING);
}
}
QString MetaDataExtractor::getLanguage(const QString &filename)
{
qDebug() << Q_FUNC_INFO << filename;
QFileInfo info = QFileInfo(filename);
QString format = info.suffix().toLower();
QString language;
// eBook language only applicable to some formats
if (format == "epub" ||
format == "fb2" ||
format == "mobi" )
{
QString dummy;
QDateTime dummyDate;
bool dummyBool;
getMetaData(filename,dummy,dummy,dummy,dummyDate,dummy,dummy,dummyBool,dummy,language);
if(language.isEmpty())
language = UNDEFINED_LANGUAGE;
}
// format not supporting language metadata
else
{
language = UNDEFINED_LANGUAGE;
}
qDebug() << Q_FUNC_INFO << language;
return language;
}
/***************************************************************************
* bindBuiltinVariable
***************************************************************************/
bool CCilVm::bindBuiltinVariable( const wstring& strQualifiedName,
CVariable* const pvar )
{
bool bReturn = true;
//Bind the var
if( strQualifiedName.find( STRING_INTERNAL_SCOPEDELIMITER ) != wstring::npos )
{
wstring strRoot = strQualifiedName.substr( 0, strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) );
assert( strRoot.find( STRING_INTERNAL_SCOPEDELIMITER ) == wstring::npos );
wstring strLeaf = strQualifiedName.substr( strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) + 1,
strQualifiedName.length() );
RID ridObject = getMetaData().queryBuiltinObjectRid( strRoot );
if( ridObject == RID_NOTDEFINED )
return false;
//Create property
getPrototypeObject( ridObject ).setProperty( strLeaf,
*pvar );
}
return bReturn;
}
bool SqlStorage::verifyDatabase()
{
// if the database is empty, it is not ok :-)
if( database().tables().isEmpty() )
return false;
// check database metadata, throw an exception in case the version does not match:
int version = 1;
QString versionString = getMetaData(CHARM_DATABASE_VERSION_DESCRIPTOR);
if (versionString != QString::null )
{
int value;
bool ok;
value = versionString.toInt( &ok );
if (ok)
{
version = value;
}
}
if ( version == CHARM_DATABASE_VERSION )
return true;
if( version > CHARM_DATABASE_VERSION )
throw UnsupportedDatabaseVersionException( QObject::tr( "Database version is too new." ) );
if ( version == CHARM_DATABASE_VERSION_BEFORE_TRACKABLE ) {
return migrateDB( QStringLiteral("ALTER TABLE Tasks ADD trackable INTEGER"), CHARM_DATABASE_VERSION_BEFORE_TRACKABLE );
} else if ( version == CHARM_DATABASE_VERSION_BEFORE_COMMENT ) {
return migrateDB( QStringLiteral("ALTER TABLE Tasks ADD comment varchar(256)"), CHARM_DATABASE_VERSION_BEFORE_COMMENT );
}
throw UnsupportedDatabaseVersionException( QObject::tr( "Database version is not supported." ) );
return true;
}
QVariant XAPlaySessionImpl::metaData( QtMultimediaKit::MetaData key ) const
{
QVariant ret;
if(keyMap.contains(key))
ret = getMetaData(keyMap[key]);
return ret;
}
AudioFileReaderArray AudioFileReader::regionsFromMetaData (const int metaDataOption, const int bufferSize) throw()
{
AudioFileReaderArray regionReaderArray;
AudioFileMetaData metaData = getMetaData();
if (metaData.isNotNull())
{
if (metaDataOption & AudioFile::ConvertCuePointsToRegions)
metaData.convertCuePointsToRegions (getNumFrames(), metaDataOption & AudioFile::RemoveCuePoints);
AudioFileRegionArray regions = metaData.getRegions();
const Long numRegions = regions.length();
if (numRegions > 0)
{
regionReaderArray.setSize (int (numRegions), false);
regionReaderArray.clear();
for (Long i = 0; i < numRegions; ++i)
{
const AudioFileReader reader = AudioFileReader (*this, regions[i], bufferSize);
regionReaderArray.add (reader);
}
}
}
return regionReaderArray;
}
QVariant XAPlaySessionImpl::extendedMetaData(const QString & key ) const
{
QVariant ret;
if(extendedKeyMap.contains(key))
ret = getMetaData(extendedKeyMap[key]);
return ret;
}
size_t FrTextSpan::wordCountInitial() const
{
const FrObject *txt = getMetaData(init_text_tag) ;
if (txt && txt->consp() && ((FrList*)txt)->first() &&
((FrList*)txt)->first()->stringp())
txt = ((FrList*)txt)->first() ;
const char *printed = FrPrintableName(txt) ;
return printed ? word_count(printed) : wordCountOriginal() ;
}
void
Stream :: setLanguage(const char* aNewValue)
{
com::xuggle::ferry::RefPointer<IMetaData> metaData = getMetaData();
if (metaData) {
metaData->setValue("language", aNewValue);
}
return;
}
void Genome::copyMetadata(Genome *dest) const
{
const map<string, string>& meta = getMetaData()->getMap();
map<string, string>::const_iterator i = meta.begin();
for (; i != meta.end(); ++i)
{
dest->getMetaData()->set(i->first, i->second);
}
}
char *FrTextSpan::initialText() const
{
const FrObject *txt = getMetaData(init_text_tag) ;
if (txt && txt->consp() && ((FrList*)txt)->first() &&
((FrList*)txt)->first()->stringp())
txt = ((FrList*)txt)->first() ;
const char *printed = FrPrintableName(txt) ;
return printed ? FrDupString(printed) : originalText() ;
}
void StreamLines::process() {
auto mesh = std::make_shared<BasicMesh>();
mesh->setModelMatrix(sampler_.getData()->getModelMatrix());
mesh->setWorldMatrix(sampler_.getData()->getWorldMatrix());
auto m = streamLineProperties_.getSeedPointTransformationMatrix(
sampler_.getData()->getCoordinateTransformer());
ImageSampler tf(tf_.get().getData());
float maxVelocity = 0;
StreamLineTracer tracer(sampler_.getData(), streamLineProperties_);
std::vector<BasicMesh::Vertex> vertices;
for (const auto &seeds : seedPoints_) {
for (auto &p : (*seeds)) {
vec4 P = m * vec4(p, 1.0f);
auto line = tracer.traceFrom(P.xyz());
auto position = line.getPositions().begin();
auto velocity = line.getMetaData("velocity").begin();
auto size = line.getPositions().size();
if (size == 0) continue;
auto indexBuffer =
mesh->addIndexBuffer(DrawType::Lines, ConnectivityType::StripAdjacency);
indexBuffer->add(0);
for (size_t i = 0; i < size; i++) {
vec3 pos(*position);
vec3 v(*velocity);
float l = glm::length(vec3(*velocity));
float d = glm::clamp(l / velocityScale_.get(), 0.0f, 1.0f);
maxVelocity = std::max(maxVelocity, l);
auto c = vec4(tf.sample(dvec2(d, 0.0)));
indexBuffer->add(static_cast<std::uint32_t>(vertices.size()));
vertices.push_back({pos, glm::normalize(v), pos, c});
position++;
velocity++;
}
indexBuffer->add(static_cast<std::uint32_t>(vertices.size() - 1));
}
}
mesh->addVertices(vertices);
linesStripsMesh_.setData(mesh);
maxVelocity_.set(toString(maxVelocity));
}
const char*
Stream :: getLanguage()
{
const char*retval = 0;
com::xuggle::ferry::RefPointer<IMetaData> metaData = getMetaData();
if (metaData) {
retval = metaData->getValue("language", IMetaData::METADATA_NONE);
}
return retval;
}
void
Stream :: setMetaData(IMetaData * copy)
{
MetaData* data = dynamic_cast<MetaData*>(getMetaData());
if (data) {
data->copy(copy);
// release for the get above
data->release();
}
return;
}
/*first step creates the sorted runs from input file*/
void genSortedRuns(char* infile, char* outfile, int numAttributes, int sortAttributes[], int totalBufferSize)
{
struct stat st = {0};
runs_path = (char*)malloc(sizeof(char)*64);
if (stat("SortedRuns", &st) == -1) {
int failure = mkdir("SortedRuns", 0777);
if(failure)runs_path="";
else runs_path="SortedRuns";
}
FILE *inPtr;
inPtr = fopen(infile, "rb");
getMetaData(inPtr);
BUFFER_SIZE = recordSize*LOGCONSTANT;
NUMBUFFERS = totalBufferSize/BUFFER_SIZE;
int returnval = 1;
char path[256];
int logSize = BUFFER_SIZE*NUMBUFFERS;
int numRecords = logSize/recordSize;
tempfile = 0;
FILE *runPtr;
while(1)
{
char* logBlock;
logBlock = (char*)malloc(sizeof(char)*logSize);
returnval = fread(logBlock, sizeof(char)*1, logSize, inPtr);
if (returnval == logSize)
{
sprintf(path, "%s/run_0_out%d.bin", runs_path, tempfile);
runPtr = fopen(path, "wb");
qsort (logBlock, numRecords, sizeof(char)*recordSize, compare);
fwrite(logBlock, sizeof(char)*logSize, 1, runPtr);
fclose (runPtr);
}
else if (returnval != 0)
{
sprintf(path, "%s/run_0_out%d.bin", runs_path, tempfile);
runPtr = fopen(path, "wb");
qsort (logBlock, returnval/recordSize, sizeof(char)*recordSize, compare);
fwrite(logBlock, sizeof(char)*returnval, 1, runPtr);
fclose (runPtr);
}
else if (returnval == 0)
break;
tempfile++;
}
}
void FrTextSpan::updateText(char *new_text, bool copy_text)
{
FrSymbol *symINIT = FrSymbolTable::add(init_text_tag) ;
if (!getMetaData(symINIT))
{
char *txt = getText() ;
setMetaData(symINIT,new FrString(txt,strlen(txt),1,false),false) ;
}
FrFree(m_text) ;
m_text = copy_text ? FrDupString(new_text) : new_text ;
return ;
}
/***************************************************************************
* Convert var and store to type constraint var
* Src is on the top of eval stack
***************************************************************************/
void CCilVm::storeAsRestrictedType( CVariable& varDest )
{
assert( varDest.getFlag() & OPERAND_FLAG_STRICT );
switch( varDest.iOperandType )
{
case OPERAND_UNDEFINED:
case OPERAND_NULL:
case OPERAND_NAN:
//Throw TypeError
ThrowExceptionFromVm( &wstring( ERRORSTRING_TYPEERROR_STORESTATICFIELD ),
&wstring( NAME_BUILTIN_ERROR_OBJECT ),
ERROR_TYPEERROR_STORESTATICFIELD );
break;
case OPERAND_INT:
varDest.iValue = getEvalStackFirstEntry().toInt();
break;
case OPERAND_INT64:
varDest.i64Value = getEvalStackFirstEntry().toInt64();
break;
case OPERAND_FLOAT:
varDest.fValue = getEvalStackFirstEntry().toFloat();
break;
case OPERAND_DOUBLE:
varDest.dValue = getEvalStackFirstEntry().toDouble();
break;
case OPERAND_BOOLEAN:
varDest.bValue = getEvalStackFirstEntry().toBoolean();
break;
case OPERAND_STRING:
varDest.pString = getEvalStackFirstEntry().toString( this );
break;
case OPERAND_OBJECTREF:
{
//Try object conversion
CObjectTypeInfo& info = getMetaData().getObject( varDest.GetConstraintRid() );
RID ridCtor = info.getConstructor();
CVariable vars[ 2 ];
vars[ 0 ] = varDest;
vars[ 1 ] = getEvalStackFirstEntry();
CVariable* pVar = invokeMethod( ridCtor, 2, vars );
delete( pVar );
}
break;
case OPERAND_UNSIGNEDINT:
case OPERAND_UNSIGNEDINT64:
case OPERAND_SYSTEM_DELETION:
default:
Debug_Fatal( "Unhandled type constraint");
break;
}
}
/*!
* Uses VTK::getMetaData() interface to retrieve missing information
*/
void VTK::getMissingMetaData(){
for( auto & field : geometry ){
if( field->usesInterface() ){
VTKFieldMetaData const & metaData = getMetaData( field->getName() ) ;
field->importMetaData( metaData ) ;
}
};
for( auto & field : data ){
if( field->usesInterface() ){
VTKFieldMetaData const & metaData = getMetaData( field->getName() ) ;
field->importMetaData( metaData ) ;
}
};
setMissingGlobalData();
return ;
};
void
Consistency::write(Variable &dataVar, std::string& entryID)
{
// store meta data info
std::string md;
getMetaData(dataVar, entryID, md);
std::string pFile = projectTableFile.getFile();
lockFile(pFile);
// open the file for appending.
std::fstream oifs;
oifs.open(pFile.c_str(),
std::ios::in | std::ios::out );
if( !oifs) // does not exist
oifs.open(pFile.c_str(),
std::ios::out | std::ios::trunc | std::ios::in);
if (! oifs.is_open() )
{
std::string key("8_1");
if( notes->inq( key, "PT") )
{
std::string capt("could not create a consistency-check table") ;
if( notes->operate(capt) )
{
notes->setCheckMetaStr( qa->fail );
qa->setExit( notes->getExitValue() ) ;
}
}
}
else
{
// append
oifs.seekp(0, std::ios::end);
oifs << md << std::flush;
oifs.close();
}
unlockFile(pFile);
return;
}
/***************************************************************************
* BindBuiltinMethodWithWrapper
***************************************************************************/
bool CCilVm::bindBuiltinMethod( const wstring& strQualifiedName,
PMETHOD const pMethod,
PMETHOD const pMethodBody )
{
bool bReturn = true;
RID ridMethod = getMetaData().queryBuiltinMethodRid( strQualifiedName );
if( ridMethod == RID_NULL )
return false;
//Bind the API
METHOD_DEF& method = getMetaData().getMethod( ridMethod );
if( method.MethodType != METHOD_WRAPPED )
return false;
method.lpFunction = pMethod;
method.lpFunctionBody = pMethodBody;
if( strQualifiedName.find( STRING_INTERNAL_SCOPEDELIMITER ) != wstring::npos )
{
wstring strRoot = strQualifiedName.substr( 0, strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) );
assert( strRoot.find( STRING_INTERNAL_SCOPEDELIMITER ) == wstring::npos );
wstring strLeaf = strQualifiedName.substr( strQualifiedName.rfind( STRING_INTERNAL_SCOPEDELIMITER ) + 1,
strQualifiedName.length() );
RID ridObject = getMetaData().queryBuiltinObjectRid( strRoot );
if( ridObject == RID_NOTDEFINED )
return false;
//Create property
getPrototypeObject( ridObject ).setProperty( this,
strLeaf,
ridMethod,
method.iNumArgments );
}
return bReturn;
}
static void refSeqGet(char *db, char *aligns, char *geneAnns, char *rnaSeqs, char *protSeqs,
char *metaData, boolean getNM, boolean getNR, char *accList)
/* refSeqGet - retrieve refseq data from the database. */
{
struct sqlConnection *conn = sqlConnect(db);
struct hash *refSeqVerInfoTbl = (accList == NULL)
? refSeqVerInfoFromDb(conn, getNM, getNR)
: refSeqVerInfoFromFile(conn, accList);
if (aligns != NULL)
getAligns(conn, refSeqVerInfoTbl, aligns);
if (geneAnns != NULL)
getGeneAnns(conn, refSeqVerInfoTbl, geneAnns);
if (rnaSeqs != NULL)
getRnaSeqs(conn, refSeqVerInfoTbl, rnaSeqs);
if (protSeqs != NULL)
getProtSeqs(conn, refSeqVerInfoTbl, protSeqs);
if (metaData != NULL)
getMetaData(conn, refSeqVerInfoTbl, metaData);
}
bool SqlStorage::verifyDatabase()
{
// if the database is empty, it is not ok :-)
if( database().tables().isEmpty() )
return false;
// check database metadata, throw an exception in case the version does not match:
int version = 1;
QString versionString = getMetaData(CHARM_DATABASE_VERSION_DESCRIPTOR);
if (versionString != QString::null )
{
int value;
bool ok;
value = versionString.toInt( &ok );
if( ok)
{
version = value;
}
}
if ( version == CHARM_DATABASE_VERSION )
return true;
if( version > CHARM_DATABASE_VERSION )
throw UnsupportedDatabaseVersionException( QObject::tr( "Database version is too new." ) );
if ( version == CHARM_DATABASE_VERSION_BEFORE_TRACKABLE ) {
SqlRaiiTransactor transactor( database() );
QSqlQuery query( database() );
query.prepare( QLatin1String("ALTER TABLE Tasks ADD trackable INTEGER") );
if ( !runQuery( query ) )
throw UnsupportedDatabaseVersionException( QObject::tr("Could not upgrade database from version %1 to version %2: %3").arg( QString::number( CHARM_DATABASE_VERSION_BEFORE_TRACKABLE ),
QString::number( CHARM_DATABASE_VERSION ),
query.lastError().text() ) );
version = CHARM_DATABASE_VERSION;
setMetaData( CHARM_DATABASE_VERSION_DESCRIPTOR, QString::number ( version ), transactor );
transactor.commit();
return true;
}
throw UnsupportedDatabaseVersionException( QObject::tr( "Database version is not supported." ) );
return true;
}
void MprisPlugin::playerStatusChanged(Qomp::State state)
{
if(!enabled_ || !mpris_ || !player_)
return;
switch(state) {
case Qomp::StatePlaying:
getMetaData(player_->currentTune());
sendMetadata(PLAYING);
break;
case Qomp::StateStopped:
sendMetadata(STOPPED);
break;
case Qomp::StatePaused:
sendMetadata(PAUSED);
break;
default:
break;
}
}
void CMsnProto::processMailData(char* mailData)
{
if (mir_strcmp(mailData, "too-large") == 0) {
getMetaData();
}
else {
ezxml_t xmli = ezxml_parse_str(mailData, mir_strlen(mailData));
ezxml_t toke = ezxml_child(xmli, "E");
const char* szIU = ezxml_txt(ezxml_child(toke, "IU"));
if (*szIU) mUnreadMessages = atol(szIU);
const char* szOU = ezxml_txt(ezxml_child(toke, "OU"));
if (*szOU) mUnreadJunkEmails = atol(szOU);
getOIMs(xmli);
ezxml_free(xmli);
}
}
std::string ABST::toPrettyString(uint32_t indent) {
std::stringstream r;
r << std::string(indent, ' ') << "[abst] Bootstrap Info (" << boxedSize() << ")" << std::endl;
r << std::string(indent + 1, ' ') << "Version " << (int)getVersion() << std::endl;
r << std::string(indent + 1, ' ') << "BootstrapinfoVersion " << getBootstrapinfoVersion() << std::endl;
r << std::string(indent + 1, ' ') << "Profile " << (int)getProfile() << std::endl;
if (getLive()) {
r << std::string(indent + 1, ' ') << "Live" << std::endl;
} else {
r << std::string(indent + 1, ' ') << "Recorded" << std::endl;
}
if (getUpdate()) {
r << std::string(indent + 1, ' ') << "Update" << std::endl;
} else {
r << std::string(indent + 1, ' ') << "Replacement or new table" << std::endl;
}
r << std::string(indent + 1, ' ') << "Timescale " << getTimeScale() << std::endl;
r << std::string(indent + 1, ' ') << "CurrMediaTime " << getCurrentMediaTime() << std::endl;
r << std::string(indent + 1, ' ') << "SmpteTimeCodeOffset " << getSmpteTimeCodeOffset() << std::endl;
r << std::string(indent + 1, ' ') << "MovieIdentifier " << getMovieIdentifier() << std::endl;
r << std::string(indent + 1, ' ') << "ServerEntryTable (" << getServerEntryCount() << ")" << std::endl;
for (unsigned int i = 0; i < getServerEntryCount(); i++) {
r << std::string(indent + 2, ' ') << i << ": " << getServerEntry(i) << std::endl;
}
r << std::string(indent + 1, ' ') << "QualityEntryTable (" << getQualityEntryCount() << ")" << std::endl;
for (unsigned int i = 0; i < getQualityEntryCount(); i++) {
r << std::string(indent + 2, ' ') << i << ": " << getQualityEntry(i) << std::endl;
}
r << std::string(indent + 1, ' ') << "DrmData " << getDrmData() << std::endl;
r << std::string(indent + 1, ' ') << "MetaData " << getMetaData() << std::endl;
r << std::string(indent + 1, ' ') << "SegmentRunTableEntries (" << getSegmentRunTableCount() << ")" << std::endl;
for (uint32_t i = 0; i < getSegmentRunTableCount(); i++) {
r << ((Box)getSegmentRunTable(i)).toPrettyString(indent + 2);
}
r << std::string(indent + 1, ' ') + "FragmentRunTableEntries (" << getFragmentRunTableCount() << ")" << std::endl;
for (uint32_t i = 0; i < getFragmentRunTableCount(); i++) {
r << ((Box)getFragmentRunTable(i)).toPrettyString(indent + 2);
}
return r.str();
}
void FrTextSpan::updateText(FrTextSpanUpdateFn *fn)
{
if (fn)
{
FrSymbol *symINIT = FrSymbolTable::add(init_text_tag) ;
if (!getMetaData(symINIT))
{
char *txt = getText() ;
setMetaData(symINIT,new FrString(txt,strlen(txt),1,false),false) ;
}
if (m_text)
{
char *new_text = fn(m_text) ;
if (!new_text)
return ;
if (new_text != m_text)
{
FrFree(m_text) ;
m_text = new_text ;
}
return ;
}
else
{
char *old_text = getText() ;
char *new_text = fn(old_text) ;
if (!new_text)
{
FrFree(old_text) ;
return ;
}
if (new_text != old_text)
FrFree(old_text) ;
m_text = new_text ;
}
}
return ;
}
/** Set value of a TimeSeriesProperty from input workspace
* @brief AddSampleLog::setTimeSeriesData
* @param run_obj
* @param property_name
* @param value_is_int
*/
void AddSampleLog::setTimeSeriesData(Run &run_obj,
const std::string &property_name,
bool value_is_int) {
// get input and
MatrixWorkspace_sptr data_ws = getProperty("TimeSeriesWorkspace");
int ws_index = getProperty("WorkspaceIndex");
if (ws_index < 0 ||
ws_index > static_cast<int>(data_ws->getNumberHistograms()))
throw std::runtime_error("Input workspace index is out of range");
// get meta data
bool epochtime(false);
std::string timeunit;
getMetaData(data_ws, epochtime, timeunit);
bool is_second = timeunit == "Second";
// convert the data in workspace to time series property value
std::vector<DateAndTime> time_vec =
getTimes(data_ws, ws_index, epochtime, is_second, run_obj);
if (value_is_int) {
// integer property
TimeSeriesProperty<int> *int_prop = dynamic_cast<TimeSeriesProperty<int> *>(
run_obj.getProperty(property_name));
std::vector<int> value_vec = getIntValues(data_ws, ws_index);
int_prop->addValues(time_vec, value_vec);
} else {
// double property
TimeSeriesProperty<double> *int_prop =
dynamic_cast<TimeSeriesProperty<double> *>(
run_obj.getProperty(property_name));
std::vector<double> value_vec = getDblValues(data_ws, ws_index);
int_prop->addValues(time_vec, value_vec);
}
return;
}
