#include <metadata_base.h>

Inheritance diagram for MetaData:

Collaboration diagram for MetaData:

Classes
struct	idIterator

struct	IdIteratorProxy

struct	rowIterator

Public Member Functions
virtual void	fillConstant (MDLabel label, const String &value)=0

virtual void	fillRandom (MDLabel label, const String &mode, double op1, double op2, double op3=0.)=0

virtual void	fillLinear (MDLabel label, double initial, double step)=0

virtual void	copyColumn (MDLabel labelDest, MDLabel labelSrc)=0

virtual void	copyColumnTo (MetaData &md, MDLabel labelDest, MDLabel labelSrc)=0

virtual void	renameColumn (MDLabel oldLabel, MDLabel newLabel)=0

virtual void	renameColumn (const std::vector< MDLabel > &oldLabel, const std::vector< MDLabel > &newLabel)=0

virtual bool	nextBlock (mdBuffer &buffer, mdBlock &block)

Constructors
	MetaData ()=default

virtual	~MetaData ()

virtual void	clear ()

Getters and setters
virtual bool	isColumnFormat () const

virtual void	setMaxRows (size_t maxRows=0)

virtual size_t	getParsedLines ()

virtual void	setPrecission (int _precision)

virtual void	setColumnFormat (bool column)

virtual void	writeXML (const FileName fn, const FileName blockname, WriteModeMetaData mode) const =0

virtual void	writeText (const FileName fn, const std::vector< MDLabel > *desiredLabels) const =0

virtual void	writeStar (const FileName &outFile, const String &blockName, WriteModeMetaData mode) const

virtual String	getComment () const

virtual void	setComment (const String &newComment="No comment")

virtual FileName	getFilename () const

virtual void	setFilename (const FileName &_filename)

virtual std::vector< MDLabel >	getActiveLabels () const =0

virtual int	getMaxStringLength (const MDLabel thisLabel) const =0

MetaData Manipulation
virtual bool	setValueCol (const MDObject &mdValueIn)=0

template<class T >
bool	setValueCol (const MDLabel label, const T &valueIn)

template<class T >
bool	setValue (const MDLabel label, const T &valueIn, size_t id)

virtual size_t	addRow (const MDRow &row)=0

MetaData &	operator= (const MetaData &md)

virtual bool	setValue (const MDObject &mdValueIn, size_t id)=0

virtual bool	getValue (MDObject &mdValueOut, size_t id) const =0

template<class T >
T	getValue (const MDLabel label, size_t id) const

template<class T >
bool	getValue (const MDLabel label, T &valueOut, size_t id) const

template<class T >
const T &	getValueOrAbort (const MDLabel label, size_t id) const

template<class T >
T &	getValueOrAbort (const MDLabel label, size_t id)

template<class T >
void	getValueOrAbort (const MDLabel label, T &valueOut, size_t id) const

template<typename T >
const T	getValueOrDefault (const MDLabel label, size_t id, const T &_default) const

template<typename T >
T	getValueOrDefault (const MDLabel label, size_t id, T &_default)

template<typename T , typename T1 >
void	getValueOrDefault (const MDLabel label, T &valueOut, size_t id, const T1 &_default) const

template<class T >
std::vector< T >	getColumnValues (const MDLabel label) const

template<class T >
void	getColumnValues (const MDLabel label, std::vector< T > &out) const

virtual bool	getRowValues (size_t id, std::vector< MDObject > &values) const =0

virtual void	getColumnValues (const MDLabel label, std::vector< MDObject > &valuesOut) const =0

template<class T >
void	setColumnValues (const MDLabel label, const std::vector< T > &valuesIn)

virtual void	setColumnValues (const std::vector< MDObject > &valuesIn)=0

virtual std::unique_ptr< MDRow >	getRow (size_t id)=0

virtual std::unique_ptr< const MDRow >	getRow (size_t id) const =0

virtual bool	setValueFromStr (const MDLabel label, const String &value, size_t id)

virtual bool	getStrFromValue (const MDLabel label, String &strOut, size_t id) const

virtual bool	isEmpty () const

virtual size_t	size () const =0

virtual bool	containsLabel (const MDLabel label) const =0

virtual bool	addLabel (const MDLabel label, int pos=-1)=0

virtual bool	removeLabel (const MDLabel label)=0

void	keepLabels (const std::vector< MDLabel > &labels)

virtual size_t	addObject ()=0

virtual void	importObject (const MetaData &md, const size_t id, bool doClear=true)=0

virtual void	importObjects (const MetaData &md, const std::vector< size_t > &objectsToAdd, bool doClear=true)=0

virtual void	importObjects (const MetaData &md, const MDQuery &query, bool doClear=true)=0

virtual bool	removeObject (size_t id)=0

virtual void	removeObjects (const std::vector< size_t > &toRemove)=0

virtual int	removeObjects (const MDQuery &)=0

virtual int	removeObjects ()=0

Iteration functions
virtual size_t	firstRowId () const =0

virtual size_t	firstObject (const MDQuery &) const =0

virtual size_t	lastRowId () const =0

Search operations
virtual void	findObjects (std::vector< size_t > &objectsOut, const MDQuery &query) const =0

virtual void	findObjects (std::vector< size_t > &objectsOut, int limit=-1) const =0

virtual size_t	countObjects (const MDQuery &) const =0

virtual bool	containsObject (size_t objectId) const =0

virtual bool	containsObject (const MDQuery &) const =0

I/O functions
virtual void	_writeRows (std::ostream &os) const =0

virtual void	write (const FileName &outFile, WriteModeMetaData mode=MD_OVERWRITE) const =0

virtual void	write (std::ostream &os, const String &blockName="", WriteModeMetaData mode=MD_OVERWRITE) const =0

virtual void	print () const

void	append (const FileName &outFile) const

virtual void	read (const FileName &inFile, const std::vector< MDLabel > *desiredLabels=nullptr, bool decomposeStack=true)=0

Set Operations
virtual void	removeDisabled ()

virtual void	selectRandomSubset (const MetaData &mdIn, size_t numberOfObjects, const MDLabel sortLabel=MDL_OBJID)=0

virtual void	selectPart (const MetaData &mdIn, size_t startPosition, size_t numberOfObjects, const MDLabel sortLabel=MDL_OBJID)=0

Public Attributes
bool	isMetadataFile

Protected Member Functions
void	copyInfo (const MetaData &md)

double	precision () const

virtual void	readStar (const FileName &filename, const std::vector< MDLabel > *desiredLabels, const String &blockRegExp, bool decomposeStack)

virtual void	_readColumns (std::istream &is, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels=nullptr)

virtual void	_readColumnsStar (mdBlock &block, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels, bool addColumns=true, size_t id=BAD_OBJID)

virtual void	_parseObject (std::istream &is, MDObject &object, size_t id=BAD_OBJID)

virtual void	_parseObjects (std::istream &is, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels, bool firstTime)=0

virtual void	_readRows (std::istream &is, std::vector< MDObject *> &columnValues, bool useCommentAsImage)

virtual void	_readRowsStar (mdBlock &block, std::vector< MDObject > &columnValues, const std::vector< MDLabel > desiredLabels)

Protected Attributes
std::map< String, size_t >	_fastStringSearch

MDLabel	_fastStringSearchLabel

String	_comment

int	_precision = 1000

FileName	_inFile

size_t	_maxRows = 0

size_t	_parsedLines = 0

Iterators
using	iterator = rowIterator< false >

using	const_iterator = rowIterator< true >

using	id_iterator = idIterator< false >

using	id_const_iterator = idIterator< true >

struct	MDBaseRowIterator< false >

struct	MDBaseRowIterator< true >

virtual iterator	begin ()=0

virtual iterator	end ()=0

virtual const_iterator	begin () const =0

virtual const_iterator	end () const =0

virtual id_iterator	id_begin ()=0

virtual id_iterator	id_end ()=0

virtual id_const_iterator	id_begin () const =0

virtual id_const_iterator	id_end () const =0

virtual IdIteratorProxy< false >	ids ()

virtual IdIteratorProxy< true >	ids () const

Detailed Description

Definition of API of all MetaDatas.

General information about metadata

MetaData* class(es) implement a way to store metadata in xmipp programs.

MetaData is represented as as a database-like table.
Each intersection of row and column contains MDObject instance.
Each row has its label MDLabel.
Columns of all rows are same.
Metadata could be loaded from file, stored to file, iterated over, rows can be added, removed, changed etc.

There was a single original database (MetaDataDb) implementation of MetaData till 2021, when MetaData were split into MetaDataDb & MetaDataVec with aim to achive higner speeds via saving metadata in std::vectors instead of sql database.

Current MetaData implementation:

metadata_base.(h|cpp): common MetaData API definition
metadata_vec.(h|cpp): vector MetaData implementation
metadata_db.(h|cpp): old datababse MetaData implementation

MetaDataBase

MetaData class cannot be instantiated however it could be passed to functions as reference or pointer where only common MetaData functions are required:

void foo(MetaData&);
void boo(MetaData*);

This code doesn't compile: void roo(MetaData& md) { md.someDbSpeficicOperation(); }

This code compiles: void roo(MetaDataDb& md) { md.someDbSpeficicOperation(); }

Iterating over MetaData

You can iterate directly over abstract MetaData as well as over specific MetaData*. You can iterate over:

Ids of rows (arbitrary size_t): for (size_t id : md.ids())
Rows: for (const MDRow& row : md)

Useful information

See metadata.h file for general info about Metadata.
Never rely on any properties of IDs! That is, do NOT assume that IDs are e.g. continuous or that they are ascending.
There is a hierarchy of MDRow classes copying MetaData hierarchy: MDRow, MDRowVec, MDRowSql. If you need row-specific function, do a dynamic cast: for (const MDRow& row : md) { const MDRowVec& rowv = dynamic_cast<MDRowVec&>(row); } You need to make sure type of md is MetaDataVec (otherwise exception is thrown).

Definition at line 176 of file metadata_base.h.

Member Typedef Documentation

◆ const_iterator

using MetaData::const_iterator = rowIterator<true>

Definition at line 706 of file metadata_base.h.

◆ id_const_iterator

using MetaData::id_const_iterator = idIterator<true>

Definition at line 736 of file metadata_base.h.

◆ id_iterator

using MetaData::id_iterator = idIterator<false>

Definition at line 735 of file metadata_base.h.

◆ iterator

using MetaData::iterator = rowIterator<false>

Definition at line 705 of file metadata_base.h.

Constructor & Destructor Documentation

◆ MetaData()

MetaData::MetaData ( )

default

Empty Constructor.

The MetaData is created with no data stored on it. You can fill in it programmatically or by a later reading from a MetaData file or old Xmipp formatted type. if labels vectors is passed this labels are created on metadata

◆ ~MetaData()

MetaData::~MetaData ( )

virtual

Definition at line 105 of file metadata_base.cpp.

105 {}

Member Function Documentation

◆ _parseObject()

void MetaData::_parseObject	(	std::istream &	is,
		MDObject &	object,
		size_t	id = `BAD_OBJID`
	)

protectedvirtual

Definition at line 325 of file metadata_base.cpp.

                                                                        {
     object.fromStream(is);
     if (is.fail()) {
        String errorMsg = formatString("MetaData: Error parsing column '%s' value.", MDL::label2Str(object.label).c_str());
        object.failed = true;
        std::cerr << "WARNING: " << errorMsg << std::endl;
        //REPORT_ERROR(ERR_MD_BADLABEL, (String)"read: Error parsing data column, expecting " + MDL::label2Str(object.label));
     } else {
         if (object.label != MDL_UNDEFINED)
             setValue(object, id);
     }
 }

◆ _parseObjects()

virtual void MetaData::_parseObjects	(	std::istream &	is,
		std::vector< MDObject *> &	columnValues,
		const std::vector< MDLabel > *	desiredLabels,
		bool	firstTime
	)

protectedpure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ _readColumns()

void MetaData::_readColumns	(	std::istream &	is,
		std::vector< MDObject *> &	columnValues,
		const std::vector< MDLabel > *	desiredLabels = `nullptr`
	)

protectedvirtual

Definition at line 223 of file metadata_base.cpp.

                                                                      {
     String token;
     MDLabel label;
 
     while (is >> token)
         if (token.find('(') == String::npos)
         {
             //label is not recognized, the MDValue will be created
             //with MDL_UNDEFINED, which will be ignored while reading data
             label = MDL::str2Label(token);
 
             // Try to read undefined labels as String using the buffer approach
             if (label == MDL_UNDEFINED)
                 label = MDL::getNewAlias(token);
 
             if (desiredLabels != NULL && !vectorContainsLabel(*desiredLabels, label))
                 label = MDL_UNDEFINED; //ignore if not present in desiredLabels
             columnValues.emplace_back(new MDObject(label));
             if (label != MDL_UNDEFINED)
                 addLabel(label);
 
         }
 }

◆ _readColumnsStar()

void MetaData::_readColumnsStar	(	mdBlock &	block,
		std::vector< MDObject *> &	columnValues,
		const std::vector< MDLabel > *	desiredLabels,
		bool	addColumns = `true`,
		size_t	id = `BAD_OBJID`
	)

protectedvirtual

Definition at line 253 of file metadata_base.cpp.

                                            {
     char * end = block.end;
     char * newline = NULL;
     bool found_column;
     MDLabel label;
     char * iter = block.loop;
     if (!_isColumnFormat)
     {
         iter = block.begin;
         iter = END_OF_LINE() + 1; //this should point at first label, after data_XXX
     }
 
     do
     {
         found_column = false;
         while (iter[0] == '#') //Skip comment
             iter = END_OF_LINE() + 1;
 
         //trim spaces and newlines at the beginning
         while ( isspace(iter[0]))
             ++iter;
 
         if (iter < end && iter[0] == '_')
         {
             found_column = true;
             ++iter; //shift _
             std::stringstream ss;
             newline = END_OF_LINE();
             //Last label and no data needs this check
             if (newline == NULL)
                 newline = end;
             String s(iter, newline - iter);//get current line
             ss.str(s);//set the string of the stream
             //Take the first token which is the label
             //if the label contain spaces will fail
             ss >> s; //get the first token, the label
             label = MDL::str2Label(s);
             if (label == MDL_UNDEFINED)
                 label = MDL::getNewAlias(s);
             if (desiredLabels != NULL && !vectorContainsLabel(*desiredLabels, label))
                 label = MDL_UNDEFINED; //ignore if not present in desiredLabels
 
             if (label != MDL_UNDEFINED)
                 addLabel(label);
 
             if (addColumns)
             {
                 MDObject * _mdObject = new MDObject(label);
                 columnValues.emplace_back(_mdObject);//add the value here with a char
                 if(!_isColumnFormat)
                     _parseObject(ss, *_mdObject, id);
             }
             iter = newline + 1;//go to next line character
         }
     }
     while (found_column)
         ;
 
     // This condition fails for empty blocks
     // if (iter < block.end)
     if (iter <= block.end +1)
         block.loop = iter; //Move loop pointer to position of last found column
 }

◆ _readRows()

void MetaData::_readRows	(	std::istream &	is,
		std::vector< MDObject *> &	columnValues,
		bool	useCommentAsImage
	)

protectedvirtual

Definition at line 379 of file metadata_base.cpp.

                                                                                                    {
     String line = "";
     while (!is.eof() && !is.fail()) {
         // Move until the ';' or the first alphanumeric character
         while (is.peek() != ';' && isspace(is.peek()) && !is.eof())
             is.ignore(1);
         if (!is.eof()) {
             if (is.peek() == ';') { //is a comment
                 is.ignore(1); //ignore the ';'
                 getline(is, line);
                 trim(line);
             } else if (!isspace(is.peek())) {
                 size_t id = addObject();
                 if (line != "") { //this is for old format files
                     if (!useCommentAsImage)
                         this->setValue(MDObject(MDL_STAR_COMMENT, line), id);
                     else
                         this->setValue(MDObject(MDL_IMAGE, line), id);
                 }
                 int nCol = columnValues.size();
                 for (int i = 0; i < nCol; ++i)
                     this->_parseObject(is, *(columnValues[i]), id);
             }
         }
     }
 }

◆ _readRowsStar()

void MetaData::_readRowsStar	(	mdBlock &	block,
		std::vector< MDObject *> &	columnValues,
		const std::vector< MDLabel > *	desiredLabels
	)

protectedvirtual

This function will be used to parse the rows data in START format

Parameters

[out]	columnValues	MDRow with values to fill in
	pchStart	pointer to the position of '_loop' in memory
	pEnd	pointer to the position of the next '_data' in memory
	maxRows	if this number if greater than 0, only this number of rows will be parsed.

Reimplemented in MetaDataDb.

Definition at line 340 of file metadata_base.cpp.

                                                                       {
     String line;
     std::stringstream ss;
     size_t n = block.end - block.loop;
     bool firstTime = true;
 
     if (n == 0)
         return;
 
     char * buffer = new char[n];
     memcpy(buffer, block.loop, n);
     char *iter = buffer, *end = iter + n, * newline = NULL;
     _parsedLines = 0; //Check how many lines the md have
 
     while (iter < end) { //while there are data lines
         //Adding \n position and check if NULL at the same time
         if (!(newline = END_OF_LINE()))
             newline = end;
         line.assign(iter, newline - iter);
         trim(line);
 
         if (!line.empty() && line[0] != '#') {
             //_maxRows would be > 0 if we only want to read some
             // rows from the md for performance reasons...
             // anyway the number of lines will be counted in _parsedLines
             if (_maxRows == 0 || _parsedLines < _maxRows) {
                 std::stringstream ss(line);
                 this->_parseObjects(ss, columnValues, desiredLabels, firstTime);
                 firstTime = false;
             }
             _parsedLines++;
         }
         iter = newline + 1; //go to next line
     }
 
     delete[] buffer;
 }

◆ _writeRows()

virtual void MetaData::_writeRows ( std::ostream & os ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ addLabel()

virtual bool MetaData::addLabel	(	const MDLabel	label,
		int	pos = `-1`
	)

pure virtual

Add a new label to the metadata. By default the label is added at the end, if the position is specified and is between 0 and n-1 the new label is inserted at that position.

Implemented in MetaDataDb, and MetaDataVec.

◆ addObject()

virtual size_t MetaData::addObject ( )

pure virtual

Adds a new, empty object to the objects map. If objectId == -1 the new ID will be that for the last object inserted + 1, else the given objectId is used. If there is already an object whose objectId == input objectId, just removes it and creates an empty one

Implemented in MetaDataDb, and MetaDataVec.

◆ addRow()

virtual size_t MetaData::addRow ( const MDRow & row )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ append()

void MetaData::append ( const FileName & outFile ) const

Append data lines to file. This function can be used to add new data to an existing metadata. Now should be used with files with only one metadata, maybe can be extended later. For now it will not check any compatibility beetween the existent metadata and the new data to append.

Definition at line 647 of file metadata_base.cpp.

 {
     if (outFile.exists())
     {
         std::ofstream ofs(outFile.c_str(), std::ios_base::app);
         _writeRows(ofs);
         ofs.close();
     }
     else
         write(outFile);
 }

◆ begin() [1/2]

virtual iterator MetaData::begin ( )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ begin() [2/2]

virtual const_iterator MetaData::begin ( ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ clear()

void MetaData::clear ( )

virtual

Clear all data

Reimplemented in MetaDataDb, and MetaDataVec.

Definition at line 152 of file metadata_base.cpp.

                      {
     _comment.clear();
     _fastStringSearch.clear();
     _fastStringSearchLabel = MDL_UNDEFINED;
 
     _isColumnFormat = true;
     _inFile = FileName();
     _precision = 1000;
     _parsedLines = 0;
 }

◆ containsLabel()

virtual bool MetaData::containsLabel ( const MDLabel label ) const

pure virtual

Check whether a label is contained in metadata.

Implemented in MetaDataDb, and MetaDataVec.

◆ containsObject() [1/2]

virtual bool MetaData::containsObject ( size_t objectId ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ containsObject() [2/2]

virtual bool MetaData::containsObject ( const MDQuery & ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ copyColumn()

virtual void MetaData::copyColumn	(	MDLabel	labelDest,
		MDLabel	labelSrc
	)

pure virtual

Copy all values from one column to another. Source column should exist

Implemented in MetaDataDb, and MetaDataVec.

◆ copyColumnTo()

virtual void MetaData::copyColumnTo	(	MetaData &	md,
		MDLabel	labelDest,
		MDLabel	labelSrc
	)

pure virtual

Same as previous, but copy to another metadata

Implemented in MetaDataDb, and MetaDataVec.

◆ copyInfo()

void MetaData::copyInfo ( const MetaData & md )

protected

Definition at line 163 of file metadata_base.cpp.

                                           {
     _comment = md._comment;
     _fastStringSearch = md._fastStringSearch;
     _fastStringSearchLabel = md._fastStringSearchLabel;
 
     _isColumnFormat = md._isColumnFormat;
     _inFile = md._inFile;
 }

◆ countObjects()

virtual size_t MetaData::countObjects ( const MDQuery & ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ end() [1/2]

virtual iterator MetaData::end ( )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ end() [2/2]

virtual const_iterator MetaData::end ( ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ fillConstant()

virtual void MetaData::fillConstant	(	MDLabel	label,
		const String &	value
	)

pure virtual

Fill column with constant value

Implemented in MetaDataDb, and MetaDataVec.

◆ fillLinear()

virtual void MetaData::fillLinear	(	MDLabel	label,
		double	initial,
		double	step
	)

pure virtual

Fill lineal, starting at some value and with some step

Implemented in MetaDataDb, and MetaDataVec.

◆ fillRandom()

virtual void MetaData::fillRandom	(	MDLabel	label,
		const String &	mode,
		double	op1,
		double	op2,
		double	op3 = `0.`
	)

pure virtual

Fill column with random value mode should be: uniform, gaussian or student op1, op2 and op2 are interpreted for each mode: uniform: op1 and op2 are the limits of the interval gaussian: op1 and op2 are mean and std student: same as gaussian and use op3

Implemented in MetaDataDb, and MetaDataVec.

◆ findObjects() [1/2]

virtual void MetaData::findObjects	(	std::vector< size_t > &	objectsOut,
		const MDQuery &	query
	)		const

pure virtual

Find all objects that match a query. if called without query, all objects are returned if limit is provided only return a maximun of 'limit'

Implemented in MetaDataDb, and MetaDataVec.

◆ findObjects() [2/2]

virtual void MetaData::findObjects	(	std::vector< size_t > &	objectsOut,
		int	limit = `-1`
	)		const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ firstObject()

virtual size_t MetaData::firstObject ( const MDQuery & ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ firstRowId()

virtual size_t MetaData::firstRowId ( ) const

pure virtual

Return the object id of the first element in metadata.

Implemented in MetaDataDb, and MetaDataVec.

◆ getActiveLabels()

virtual std::vector<MDLabel> MetaData::getActiveLabels ( ) const

pure virtual

Get safe access to active labels.

Implemented in MetaDataDb, and MetaDataVec.

◆ getColumnValues() [1/3]

template<class T >

std::vector<T> MetaData::getColumnValues ( const MDLabel label ) const

inline

Get all values of a column as a vector.

Definition at line 466 of file metadata_base.h.

                                                             {
         std::vector<T> result;
         MDObject mdValueOut(label);
         std::vector<size_t> objectsId;
         findObjects(objectsId);
         size_t n = objectsId.size();
         result.reserve(n);
         for (size_t i = 0; i < n; ++i) {
             if (!getValue(mdValueOut, objectsId[i]))
                 throw std::logic_error("Column does not exist!");
             result.emplace_back(mdValueOut.getValue2(T()));
         }
         return result;
     }

◆ getColumnValues() [2/3]

template<class T >

void MetaData::getColumnValues	(	const MDLabel	label,
		std::vector< T > &	out
	)		const

inline

Definition at line 483 of file metadata_base.h.

                                                                        {
         out = this->getColumnValues<T>(label);
     }

◆ getColumnValues() [3/3]

virtual void MetaData::getColumnValues	(	const MDLabel	label,
		std::vector< MDObject > &	valuesOut
	)		const

pure virtual

Get all values of a column as a vector.

Implemented in MetaDataDb, and MetaDataVec.

◆ getComment()

virtual String MetaData::getComment ( ) const

inlinevirtual

Get Header Comment. the comment will appear in second line.

Definition at line 310 of file metadata_base.h.

310 { return this->_comment; }

MetaData::_comment

String _comment

Definition: metadata_base.h:185

◆ getFilename()

virtual FileName MetaData::getFilename ( ) const

inlinevirtual

Get metadata filename.

Definition at line 319 of file metadata_base.h.

319 { return this->_inFile; }

MetaData::_inFile

FileName _inFile

Definition: metadata_base.h:195

◆ getMaxStringLength()

virtual int MetaData::getMaxStringLength ( const MDLabel thisLabel ) const

pure virtual

Get maximum string length of column values.

Implemented in MetaDataDb, and MetaDataVec.

◆ getParsedLines()

virtual size_t MetaData::getParsedLines ( )

inlinevirtual

Return the number of lines in the metadata file. Serves to know the number of items even is read with maxRows != 0

Definition at line 283 of file metadata_base.h.

283 { return _parsedLines; }

MetaData::_parsedLines

size_t _parsedLines

Definition: metadata_base.h:200

◆ getRow() [1/2]

virtual std::unique_ptr<MDRow> MetaData::getRow ( size_t id )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ getRow() [2/2]

virtual std::unique_ptr<const MDRow> MetaData::getRow ( size_t id ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ getRowValues()

virtual bool MetaData::getRowValues	(	size_t	id,
		std::vector< MDObject > &	values
	)		const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ getStrFromValue()

bool MetaData::getStrFromValue	(	const MDLabel	label,
		String &	strOut,
		size_t	id
	)		const

virtual

Get string representation from label value.

Definition at line 115 of file metadata_base.cpp.

                                                                                    {
     MDObject mdValueOut(label);
     if (!getValue(mdValueOut, id))
         return false;
     strOut = mdValueOut.toString();
     return true;
 }

◆ getValue() [1/3]

virtual bool MetaData::getValue	(	MDObject &	mdValueOut,
		size_t	id
	)		const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ getValue() [2/3]

template<class T >

T MetaData::getValue	(	const MDLabel	label,
		size_t	id
	)		const

inline

Get the value of some label. from the object that has id 'objectId' or from 'activeObject' if objectId=-1.

MetaData md;
md.read("images.xmd");
FileName imageFn;     *
FOR_ALL_OBJECTS_IN_METADATA(md)
{
     md.getValue(MDL_IMAGE, imageFn);
     std::out << "Image: " << imageFn);
}

Definition at line 409 of file metadata_base.h.

                                                      {
         MDObject mdValueOut(label);
         if (!getValue(mdValueOut, id))
             throw ObjectDoesNotExist(label, id);
         return mdValueOut.getValue2(T());
     }

◆ getValue() [3/3]

template<class T >

bool MetaData::getValue	(	const MDLabel	label,
		T &	valueOut,
		size_t	id
	)		const

inline

Definition at line 417 of file metadata_base.h.

                                                                      {
         MDObject mdValueOut(label);
         if (!getValue(mdValueOut, id))
             return false;
         valueOut = mdValueOut.getValue2(T());
         return true;
     }

◆ getValueOrAbort() [1/3]

template<class T >

const T& MetaData::getValueOrAbort	(	const MDLabel	label,
		size_t	id
	)		const

inline

Definition at line 426 of file metadata_base.h.

                                                                    {
         return getValue<T>(label, id);
     }

◆ getValueOrAbort() [2/3]

template<class T >

T& MetaData::getValueOrAbort	(	const MDLabel	label,
		size_t	id
	)

inline

Definition at line 431 of file metadata_base.h.

                                                        {
         return getValue<T>(label, id);
     }

◆ getValueOrAbort() [3/3]

template<class T >

void MetaData::getValueOrAbort	(	const MDLabel	label,
		T &	valueOut,
		size_t	id
	)		const

inline

Definition at line 436 of file metadata_base.h.

                                                                             { // FIXME: deprecated
         if (!getValue(label, valueOut,id))
             REPORT_ERROR(ERR_ARG_MISSING,(String)"Cannot find label: " + MDL::label2Str(label));
     }

◆ getValueOrDefault() [1/3]

template<typename T >

const T MetaData::getValueOrDefault	(	const MDLabel	label,
		size_t	id,
		const T &	_default
	)		const

inline

Definition at line 442 of file metadata_base.h.

                                                                                        {
         MDObject mdValueOut(label);
         if (!getValue(mdValueOut, id))
             return _default;
         return mdValueOut.getValue2(T());
     }

◆ getValueOrDefault() [2/3]

template<typename T >

T MetaData::getValueOrDefault	(	const MDLabel	label,
		size_t	id,
		T &	_default
	)

inline

Definition at line 450 of file metadata_base.h.

                                                                      {
         MDObject mdValueOut(label);
         if (!getValue(mdValueOut, id))
             return _default;
         return mdValueOut.getValue2(T());
     }

◆ getValueOrDefault() [3/3]

template<typename T , typename T1 >

void MetaData::getValueOrDefault	(	const MDLabel	label,
		T &	valueOut,
		size_t	id,
		const T1 &	_default
	)		const

inline

Definition at line 458 of file metadata_base.h.

                                                                                                   { // FIXME: deprecated
         if (!getValue(label, valueOut,id))
             valueOut = (T) _default;
     }

◆ id_begin() [1/2]

virtual id_iterator MetaData::id_begin ( )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ id_begin() [2/2]

virtual id_const_iterator MetaData::id_begin ( ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ id_end() [1/2]

virtual id_iterator MetaData::id_end ( )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ id_end() [2/2]

virtual id_const_iterator MetaData::id_end ( ) const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ ids() [1/2]

virtual IdIteratorProxy<false> MetaData::ids ( )

inlinevirtual

Definition at line 754 of file metadata_base.h.

754 { return IdIteratorProxy<false>(*this); };

◆ ids() [2/2]

virtual IdIteratorProxy<true> MetaData::ids ( ) const

inlinevirtual

Definition at line 755 of file metadata_base.h.

755 { return IdIteratorProxy<true>(*this); };

◆ importObject()

virtual void MetaData::importObject	(	const MetaData &	md,
		const size_t	id,
		bool	doClear = `true`
	)

pure virtual

Import objects from another metadata.

//Import object 1000 from metadata B into metadata A
A.importObject(B, 1000);
//Import all objects with rotational angle greater that 60
A.importObjects(B, MDValuesGT(MDL_ANGLE_ROT, 60));
//Import all objects
A.importObjects(B);

Implemented in MetaDataDb, and MetaDataVec.

◆ importObjects() [1/2]

virtual void MetaData::importObjects	(	const MetaData &	md,
		const std::vector< size_t > &	objectsToAdd,
		bool	doClear = `true`
	)

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ importObjects() [2/2]

virtual void MetaData::importObjects	(	const MetaData &	md,
		const MDQuery &	query,
		bool	doClear = `true`
	)

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ isColumnFormat()

virtual bool MetaData::isColumnFormat ( ) const

inlinevirtual

Return true if the metadata is in column format.

Definition at line 272 of file metadata_base.h.

272 { return _isColumnFormat; }

◆ isEmpty()

virtual bool MetaData::isEmpty ( ) const

inlinevirtual

Check whether the metadata is empty.

Reimplemented in MetaDataVec.

Definition at line 522 of file metadata_base.h.

522 { return size() == 0; }

MetaData::size

virtual size_t size() const =0

◆ keepLabels()

void MetaData::keepLabels ( const std::vector< MDLabel > & labels )

Remove all the labels from the metadata but the ones given in labels vector.

Definition at line 143 of file metadata_base.cpp.

                                                           {
     auto active = this->getActiveLabels();
     for (const auto &l : active) {
         if (!vectorContainsLabel(labels, l)) {
             this->removeLabel(l);
         }
     }
 }

◆ lastRowId()

virtual size_t MetaData::lastRowId ( ) const

pure virtual

Goto last metadata object.

Implemented in MetaDataDb, and MetaDataVec.

◆ nextBlock()

bool MetaData::nextBlock	(	mdBuffer &	buffer,
		mdBlock &	block
	)

virtual

Definition at line 176 of file metadata_base.cpp.

                                                          {
     BLOCK_INIT(block);
     if (buffer.size == 0)
         return false;
     // Search for data_ after a newline
     block.begin = BUFFER_FIND(buffer, "data_", 5);
 
     if (block.begin) // data_ FOUND!!!
     {
         block.begin += 5; //Shift data_
         size_t n = block.begin - buffer.begin;
         BUFFER_MOVE(buffer, n);
         //Search for the end of line
         char *newLine = BUFFER_FIND(buffer, "\n", 1);
         //Calculate length of block name, counting after data_
         block.nameSize = newLine - buffer.begin;
         //Search for next block if exists one
         //use assign and check if not NULL at same time
         if (!(block.end = BUFFER_FIND(buffer, "\ndata_", 6))) {
             block.end = block.begin + buffer.size; }
         else {
             block.end += 1; // to include terminal \n
         }
         block.loop = BUFFER_FIND(buffer, "\nloop_", 6);
         //If loop_ is not found or is found outside block
         //scope, the block is in column format
         if (block.loop)
         {
             if (block.loop < block.end)
                 block.loop += 6; // Shift \nloop_
             else
                 block.loop = NULL;
         }
         //Move buffer to end of block
         n = block.end - buffer.begin;
         BUFFER_MOVE(buffer, n);
         return true;
     }
 
     return false;
 }

◆ operator=()

MetaData& MetaData::operator= ( const MetaData & md )

inline

Definition at line 373 of file metadata_base.h.

                                             {
         if (&md == this) {
             return *this;
         }
         this->clear();
         this->copyInfo(md);
         for (const auto& row : md)
             this->addRow(row);
         return *this;
     };

◆ precision()

double MetaData::precision ( ) const

protected

Definition at line 172 of file metadata_base.cpp.

                                  {
     return 1./this->_precision;
 }

◆ print()

virtual void MetaData::print ( ) const

inlinevirtual

Definition at line 631 of file metadata_base.h.

631 { this->write(std::cout); }

MetaData::write

virtual void write(const FileName &outFile, WriteModeMetaData mode=MD_OVERWRITE) const =0

◆ read()

virtual void MetaData::read	(	const FileName &	inFile,
		const std::vector< MDLabel > *	desiredLabels = `nullptr`,
		bool	decomposeStack = `true`
	)

pure virtual

Read data from file. Guess the blockname from the filename

inFilename="first@md1.doc" -> filename = md1.doc, blockname = first

Implemented in MetaDataDb, and MetaDataVec.

◆ readStar()

void MetaData::readStar	(	const FileName &	filename,
		const std::vector< MDLabel > *	desiredLabels,
		const String &	blockRegExp,
		bool	decomposeStack
	)

protectedvirtual

Definition at line 406 of file metadata_base.cpp.

                                                                         {
     // First try to open the file as a metadata
     size_t id;
     FileName inFile = filename.removeBlockName();
 
     if (!(isMetadataFile = inFile.isMetaData())) { //if not a metadata, try to read as image or stack
         Image<char> image;
         if (decomposeStack) // If not decomposeStack it is no necessary to read the image header
             image.read(filename, HEADER);
         if (!decomposeStack || image().ndim == 1) { // single image; !decomposeStack must be first
             id = this->addObject();
             MetaData::setValue(MDL_IMAGE, filename, id);
             MetaData::setValue(MDL_ENABLED, 1, id);
         } else { // stack
             FileName fnTemp;
             for (size_t i = 1; i <= image().ndim; ++i) {
                 fnTemp.compose(i, filename);
                 id = addObject();
                 MetaData::setValue(MDL_IMAGE, fnTemp, id);
                 MetaData::setValue(MDL_ENABLED, 1, id);
             }
         }
         return;
     }
 
     std::ifstream is(inFile.c_str(), std::ios_base::in);
     std::stringstream ss;
     String line, token,_comment;
     std::vector<MDObject*> columnValues;
 
     getline(is, line); //get first line to identify the type of file
 
     if (is.fail())
         REPORT_ERROR(ERR_IO_NOTEXIST, formatString("MetaDataDb::read: File doesn't exists: %s", inFile.c_str()) );
 
     bool useCommentAsImage = false;
     this->_inFile = inFile;
     bool oldFormat = true;
 
     is.seekg(0, std::ios::beg);//reset the stream position to the beginning to start parsing
 
     if (line.find(FileNameVersion) != String::npos ||
         filename.getExtension() == "xmd" || filename.getExtension() == "star") {
         oldFormat = false;
         _comment.clear();
 
         // Skip comment parsing if we found the data key in the first line
         if (line.find("data_") != 0) {
             // Read comment
             //        is.ignore(256,'#');//format line
             is.ignore(256, '\n');//skip first line
             bool addspace = false;
             while (1) {
                 getline(is, line);
                 trim(line);
                 if (line[0] == '#')
                 {
                     line[0] = ' ';
                     trim(line);
                     if (addspace)
                         _comment += " " + line;
                     else
                         _comment += line;
                     addspace = true;
                 } else
                     break;
             }
             this->setComment(_comment);
         }
 
         //map file
         int fd;
         BUFFER_CREATE(bufferMap);
         mapFile(inFile, bufferMap.begin, bufferMap.size, fd);
 
         BLOCK_CREATE(block);
         regex_t re;
         int rc = regcomp(&re, (blockRegExp+"$").c_str(), REG_EXTENDED|REG_NOSUB);
         if (blockRegExp.size() && rc != 0)
             REPORT_ERROR(ERR_ARG_INCORRECT, formatString("Pattern '%s' cannot be parsed: %s",
                          blockRegExp.c_str(), inFile.c_str()));
         BUFFER_COPY(bufferMap, buffer);
         bool firstBlock = true;
         bool singleBlock = blockRegExp.find_first_of(".[*+")==String::npos;
 
         String blockName;
 
         while (nextBlock(buffer, block)) {
             //startingPoint, remainingSize, firstData, secondData, firstloop))
             BLOCK_NAME(block, blockName);
             if (blockRegExp.size() == 0 || regexec(&re, blockName.c_str(), (size_t) 0, NULL, 0) == 0) {
                 //Read column labels from the datablock that starts at firstData
                 //Label ends at firstloop
                 if ((_isColumnFormat = (block.loop != NULL))) {
                     _readColumnsStar(block, columnValues, desiredLabels, firstBlock);
                     // If block is empty, makes block.loop and block.end equal
                     if (block.loop == (block.end + 1))
                         block.loop--;
                     _readRowsStar(block, columnValues, desiredLabels);
                 } else {
                     id = this->addObject();
                     _parsedLines = 1;
                     this->_readColumnsStar(block, columnValues, desiredLabels, firstBlock, id);
                 }
                 firstBlock = false;
 
                 if (singleBlock)
                     break;
             }
         }
 
         unmapFile(bufferMap.begin, bufferMap.size, fd);
         regfree(&re);
         if (firstBlock)
             REPORT_ERROR(ERR_MD_BADBLOCK, formatString("Block: '%s': %s",
                          blockRegExp.c_str(), inFile.c_str()));
 
     } else if (line.find("Headerinfo columns:") != String::npos) {
         // This looks like an old DocFile, parse header
         std::cerr << "WARNING: ** You are using an old file format (DOCFILE) which is going "
         << "to be deprecated in next Xmipp release **" << std::endl;
         is.ignore(256, ':'); //ignore all until ':' to start parsing column labels
         getline(is, line);
         ss.str(line);
         columnValues.emplace_back(new MDObject(MDL_UNDEFINED));
         columnValues.emplace_back(new MDObject(MDL_UNDEFINED));
 
         this->addLabel(MDL_IMAGE);
         this->_readColumns(ss, columnValues, desiredLabels);
         useCommentAsImage = true;
 
     } else {
         std::cerr << "WARNING: ** You are using an old file format (SELFILE) which is going "
         << "to be deprecated in next Xmipp release **" << std::endl;
         // I will assume that is an old SelFile, so only need to add two columns
         columnValues.emplace_back(new MDObject(MDL_IMAGE));//addLabel(MDL_IMAGE);
         columnValues.emplace_back(new MDObject(MDL_ENABLED));//addLabel(MDL_ENABLED);
     }
 
     if (oldFormat)
         this->_readRows(is, columnValues, useCommentAsImage);
 
     //free memory of column values
     int nCols = columnValues.size();
     for (int i = 0; i < nCols; ++i)
         delete columnValues[i];
 
     is.close();
 }

◆ removeDisabled()

void MetaData::removeDisabled ( )

virtual

Remove rows with MDL_ENABLED = -1 if this label is present

Definition at line 123 of file metadata_base.cpp.

                               {
     if (containsLabel(MDL_ENABLED))
         removeObjects(MDValueLE(MDL_ENABLED, 0)); // Remove values -1 and 0 on MDL_ENABLED label
 }

◆ removeLabel()

virtual bool MetaData::removeLabel ( const MDLabel label )

pure virtual

Remove a label from the metadata. The data is still in the table. If you want to remove the data, make a copy of the MetaData.

Implemented in MetaDataDb, and MetaDataVec.

◆ removeObject()

virtual bool MetaData::removeObject ( size_t id )

pure virtual

Remove the object with this id. Returns true if the object was removed or false if the object did not exist

Implemented in MetaDataDb, and MetaDataVec.

◆ removeObjects() [1/3]

virtual void MetaData::removeObjects ( const std::vector< size_t > & toRemove )

pure virtual

Removes the collection of objects of given vector id's NOTE: The iterator will point to the first object after any of these operations

Implemented in MetaDataDb, and MetaDataVec.

◆ removeObjects() [2/3]

virtual int MetaData::removeObjects ( const MDQuery & )

pure virtual

Removes objects from metadata. return the number of deleted rows if not query, all objectes are removed Queries can be used in the same way as in the importObjects function

Implemented in MetaDataDb, and MetaDataVec.

◆ removeObjects() [3/3]

virtual int MetaData::removeObjects ( )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ renameColumn() [1/2]

virtual void MetaData::renameColumn	(	MDLabel	oldLabel,
		MDLabel	newLabel
	)

pure virtual

Rename column.

Implemented in MetaDataDb, and MetaDataVec.

◆ renameColumn() [2/2]

virtual void MetaData::renameColumn	(	const std::vector< MDLabel > &	oldLabel,
		const std::vector< MDLabel > &	newLabel
	)

pure virtual

Rename several columns. This is an expensive operations so if several columns need to be changed do it using this function instead one by one

Implemented in MetaDataDb, and MetaDataVec.

◆ selectPart()

virtual void MetaData::selectPart	(	const MetaData &	mdIn,
		size_t	startPosition,
		size_t	numberOfObjects,
		const MDLabel	sortLabel = `MDL_OBJID`
	)

pure virtual

Select some part from Metadata. Select elements from input Metadata at some starting position if the numberOfObjects is -1, all objects will be returned from startPosition to the end.

Implemented in MetaDataDb, and MetaDataVec.

◆ selectRandomSubset()

virtual void MetaData::selectRandomSubset	(	const MetaData &	mdIn,
		size_t	numberOfObjects,
		const MDLabel	sortLabel = `MDL_OBJID`
	)

pure virtual

Select random subset

Implemented in MetaDataDb, and MetaDataVec.

◆ setColumnFormat()

virtual void MetaData::setColumnFormat ( bool column )

inlinevirtual

Set to false for row format (parameter files). set to true for column format (this is the default) (docfiles)

Definition at line 293 of file metadata_base.h.

293 { _isColumnFormat = column; }

◆ setColumnValues() [1/2]

template<class T >

void MetaData::setColumnValues	(	const MDLabel	label,
		const std::vector< T > &	valuesIn
	)

inline

Set all values of a column as a vector. The input vector must have the same size as the Metadata.

Definition at line 499 of file metadata_base.h.

                                                                             {
         if (valuesIn.size() != size())
             REPORT_ERROR(ERR_MD_OBJECTNUMBER, "Input vector must be of the same size as the metadata");
         size_t n = 0;
         for (size_t objId : this->ids())
             this->setValue(label, valuesIn[n++], objId);
     }

◆ setColumnValues() [2/2]

virtual void MetaData::setColumnValues ( const std::vector< MDObject > & valuesIn )

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ setComment()

virtual void MetaData::setComment ( const String & newComment = "No comment" )

inlinevirtual

Set Header Comment. the comment will appear in second line

Definition at line 315 of file metadata_base.h.

315 { this->_comment = newComment; }

MetaData::_comment

String _comment

Definition: metadata_base.h:185

◆ setFilename()

virtual void MetaData::setFilename ( const FileName & _filename )

inlinevirtual

Set metadata filename.

Definition at line 323 of file metadata_base.h.

323 { this->_inFile = _filename; }

MetaData::_inFile

FileName _inFile

Definition: metadata_base.h:195

◆ setMaxRows()

virtual void MetaData::setMaxRows ( size_t maxRows = 0 )

inlinevirtual

Prevent from parsing all rows from the metadata. When reading from file, only maxRows will be read.

Definition at line 277 of file metadata_base.h.

277 { _maxRows = maxRows; }

MetaData::_maxRows

size_t _maxRows

Definition: metadata_base.h:200

◆ setPrecission()

virtual void MetaData::setPrecission ( int _precision )

inlinevirtual

Set precision (number of decimal digits) use by operator == when comparing metadatas with double data. "2" is a good value for angles

Definition at line 288 of file metadata_base.h.

288 { this->_precision = (int)pow (10,_precision); }

MetaData::_precision

int _precision

Definition: metadata_base.h:190

◆ setValue() [1/2]

template<class T >

bool MetaData::setValue	(	const MDLabel	label,
		const T &	valueIn,
		size_t	id
	)

inline

Set the value for some label. to the object that has id 'objectId' or to 'activeObject' if is objectId=-1. This is one of the most used functions to programatically fill a metadata.

MetaData md;
size_t id = md.addObject();
md.setValue(MDL_IMAGE, "images/image00011.xmp",id);
md.setValue(MDL_ANGLE_ROT, 0.,id);

Definition at line 367 of file metadata_base.h.

                                                                     {
         return setValue(MDObject(label, valueIn), id);
     }

◆ setValue() [2/2]

virtual bool MetaData::setValue	(	const MDObject &	mdValueIn,
		size_t	id
	)

pure virtual

This functions are using MDObject for set real values there is an explicit function signature foreach type supported in Metadata. This is done for some type checking of Metadata labels and values

Implemented in MetaDataDb, and MetaDataVec.

◆ setValueCol() [1/2]

virtual bool MetaData::setValueCol ( const MDObject & mdValueIn )

pure virtual

Set the value of all objects in an specified column (both value and column are specified in mdValueIn)

Implemented in MetaDataDb, and MetaDataVec.

◆ setValueCol() [2/2]

template<class T >

bool MetaData::setValueCol	(	const MDLabel	label,
		const T &	valueIn
	)

inline

Set the value of all objects in an specified column.

MetaData md;

md.setValueCol(MDL_IMAGE, "images/image00011.xmp");

Definition at line 350 of file metadata_base.h.

                                                             {
         return setValueCol(MDObject(label, valueIn));
     }

◆ setValueFromStr()

bool MetaData::setValueFromStr	(	const MDLabel	label,
		const String &	value,
		size_t	id
	)

virtual

Set label values from string representation.

Definition at line 107 of file metadata_base.cpp.

                                                                                   {
     addLabel(label);
     MDObject mdValue(label);
     mdValue.fromString(value);
     this->setValue(mdValue, id);
     return true;
 }

◆ size()

virtual size_t MetaData::size ( ) const

pure virtual

Number of objects contained in the metadata.

Implemented in MetaDataDb, and MetaDataVec.

◆ write() [1/2]

virtual void MetaData::write	(	const FileName &	outFile,
		WriteModeMetaData	mode = `MD_OVERWRITE`
	)		const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ write() [2/2]

virtual void MetaData::write	(	std::ostream &	os,
		const String &	blockName = `""`,
		WriteModeMetaData	mode = `MD_OVERWRITE`
	)		const

pure virtual

Implemented in MetaDataDb, and MetaDataVec.

◆ writeStar()

void MetaData::writeStar	(	const FileName &	outFile,
		const String &	blockName,
		WriteModeMetaData	mode
	)		const

virtual

Definition at line 557 of file metadata_base.cpp.

                                                                                                         {
     // Move to MetaData?
 #ifdef XMIPP_MMAP
     if (outFile.hasImageExtension())
         REPORT_ERROR(ERR_IO,"MetaData:writeStar Trying to write metadata with image extension");
 
     struct stat file_status;
     int fd;
     char *map = NULL;
     char *tailMetadataFile = NULL; // auxiliary variable to keep metadata file tail in memory
     size_t size=-1;
     char *target, * target2 = NULL;
 
     //check if file exists or not block name has been given
     //in our format no two identical data_xxx strings may exists
     if (mode == MD_APPEND) {
         if (blockName.empty() || !outFile.exists())
             mode = MD_OVERWRITE;
         else {
             //does blockname exists?
             //remove it from file in this case
             // get length of file:
             if(stat(outFile.c_str(), &file_status) != 0)
                 REPORT_ERROR(ERR_IO_NOPATH,"MetaData:writeStar can not get filesize for file "+outFile);
             size = file_status.st_size;
             if (size == 0)
                 mode = MD_OVERWRITE;
         }
 
         if (mode == MD_APPEND) { //size=0 for /dev/stderr
             fd = open(outFile.c_str(),  O_RDWR, S_IREAD | S_IWRITE);
             if (fd == -1)
                 REPORT_ERROR(ERR_IO_NOPATH,"MetaData:writeStar can not read file named "+outFile);
 
             map = (char *) mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
             if (map == MAP_FAILED)
                 REPORT_ERROR(ERR_MEM_BADREQUEST,"MetaData:writeStar can not map memory ");
 
             // Is this a metadata formatted FILE
             if(strncmp(map,FileNameVersion.c_str(),FileNameVersion.length()) != 0) {
                 mode = MD_OVERWRITE;
             } else {
                 //block name
                 String _szBlockName = formatString("\ndata_%s\n", blockName.c_str());
                 size_t blockNameSize = _szBlockName.size();
 
                 //search for the string
                 target = (char *) _memmem(map, size, _szBlockName.c_str(), blockNameSize);
 
                 if (target != NULL)
                 {
                     target2 = (char *) _memmem(target+1, size - (target - map), "\ndata_", 6);
 
                     if (target2 != NULL)
                     {
                         //target block is not the last one, so we need to
                         //copy file from target2 to auxiliary memory and truncate
                         tailMetadataFile = (char *) malloc( ((map + size) - target2));
                         memmove(tailMetadataFile,target2, (map + size) - target2);
                     }
                     if (ftruncate(fd, target - map+1)==-1)  //truncate rest of the file
                         REPORT_ERROR(ERR_UNCLASSIFIED,"Cannot truncate file");
                 }
             }
             close(fd);
 
             if (munmap(map, size) == -1)
                 REPORT_ERROR(ERR_MEM_NOTDEALLOC, "MetaData:writeStar, Can not unmap memory");
         }
     }
 
     std::ios_base::openmode openMode = (mode == MD_OVERWRITE) ? std::ios_base::out : std::ios_base::app;
     std::ofstream ofs(outFile.c_str(), openMode);
 
     write(ofs, blockName, mode);
 
     if (tailMetadataFile != NULL) {
         //append memory buffer to file
         //may a cat a buffer to a ofstream
         ofs.write(tailMetadataFile,(map + size) - target2);
         free(tailMetadataFile);
     }
     ofs.close();
 
 #else
 
     REPORT_ERROR(ERR_MMAP,"Mapping not supported in Windows");
 #endif
 }

◆ writeText()

virtual void MetaData::writeText	(	const FileName	fn,
		const std::vector< MDLabel > *	desiredLabels
	)		const

pure virtual

Write metadata in text file as plain data without header.

Implemented in MetaDataDb, and MetaDataVec.

◆ writeXML()

virtual void MetaData::writeXML	(	const FileName	fn,
		const FileName	blockname,
		WriteModeMetaData	mode
	)		const

pure virtual

Export medatada to xml file.

Implemented in MetaDataDb, and MetaDataVec.

Friends And Related Function Documentation

◆ MDBaseRowIterator< false >

friend struct MDBaseRowIterator< false >

friend

Definition at line 676 of file metadata_base.h.

◆ MDBaseRowIterator< true >

friend struct MDBaseRowIterator< true >

friend

Definition at line 677 of file metadata_base.h.

Member Data Documentation

◆ _comment

String MetaData::_comment

protected

A general comment for the MetaData file

Definition at line 185 of file metadata_base.h.

◆ _fastStringSearch

std::map<String, size_t> MetaData::_fastStringSearch

protected

Definition at line 183 of file metadata_base.h.

◆ _fastStringSearchLabel

MDLabel MetaData::_fastStringSearchLabel

protected

Definition at line 184 of file metadata_base.h.

◆ _inFile

FileName MetaData::_inFile

protected

Input file name Where does this MetaData come from/go to be stored?

Definition at line 195 of file metadata_base.h.

◆ _maxRows

size_t MetaData::_maxRows = 0

protected

This two variables will be used to read the metadata information (labels and size) or maybe a few rows only

Definition at line 200 of file metadata_base.h.

◆ _parsedLines

size_t MetaData::_parsedLines = 0

protected

Definition at line 200 of file metadata_base.h.

◆ _precision

int MetaData::_precision = 1000

protected

Definition at line 190 of file metadata_base.h.

◆ isMetadataFile

bool MetaData::isMetadataFile

Filename used in the read command, useful to write Error messages

Definition at line 246 of file metadata_base.h.

The documentation for this class was generated from the following files:

xmippCore/core/metadata_base.h
xmippCore/core/metadata_base.cpp

Classes

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Iterators

Detailed Description

General information about metadata

MetaDataBase

Iterating over MetaData

Useful information

Member Typedef Documentation

◆ const_iterator

◆ id_const_iterator

◆ id_iterator

◆ iterator

Constructor & Destructor Documentation

◆ MetaData()

◆ ~MetaData()

Member Function Documentation

◆ _parseObject()

◆ _parseObjects()

◆ _readColumns()

◆ _readColumnsStar()

◆ _readRows()

◆ _readRowsStar()

◆ _writeRows()

◆ addLabel()

◆ addObject()

◆ addRow()

◆ append()

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ containsLabel()

◆ containsObject() [1/2]

◆ containsObject() [2/2]

◆ copyColumn()

◆ copyColumnTo()

◆ copyInfo()

◆ countObjects()

◆ end() [1/2]

◆ end() [2/2]

◆ fillConstant()

◆ fillLinear()

◆ fillRandom()

◆ findObjects() [1/2]

◆ findObjects() [2/2]

◆ firstObject()

◆ firstRowId()

◆ getActiveLabels()

◆ getColumnValues() [1/3]

◆ getColumnValues() [2/3]

◆ getColumnValues() [3/3]

◆ getComment()

◆ getFilename()

◆ getMaxStringLength()

◆ getParsedLines()

◆ getRow() [1/2]

◆ getRow() [2/2]

◆ getRowValues()

◆ getStrFromValue()

◆ getValue() [1/3]

◆ getValue() [2/3]

◆ getValue() [3/3]

◆ getValueOrAbort() [1/3]

◆ getValueOrAbort() [2/3]

◆ getValueOrAbort() [3/3]

◆ getValueOrDefault() [1/3]

◆ getValueOrDefault() [2/3]

◆ getValueOrDefault() [3/3]

◆ id_begin() [1/2]

◆ id_begin() [2/2]

◆ id_end() [1/2]

◆ id_end() [2/2]

◆ ids() [1/2]

◆ ids() [2/2]

◆ importObject()

◆ importObjects() [1/2]

◆ importObjects() [2/2]