FloatArrayStore.h File Reference

#include <vector>
#include <map>
#include <string>
#include <functional>
#include <iosfwd>
#include <cmath>
#include "Identifier/Identifier.h"
#include "AthenaKernel/CLASS_DEF.h"

Include dependency graph for FloatArrayStore.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	FloatArrayStore
	class FloatArrayStore Access and manipulate an indexed storage of float vectors More...

Functions
std::ostream &	operator<< (std::ostream &os, const FloatArrayStore &store)
std::istream &	operator>> (std::istream &is, FloatArrayStore &store)

Function Documentation

operator<<()

std::ostream & operator<<	(	std::ostream &	os,
		const FloatArrayStore &	store )

Definition at line 39 of file FloatArrayStore.cxx.

                                                                    {
  os << store.tag() << std::endl ;
  // it is a bit of a heck, but the FloatArrayStore doesn't allow for more.
  // first make an inverse map
  std::map<int, std::vector<Identifier> > indextoidentmap ;
  for(auto it : store)
    indextoidentmap[it.second].push_back(it.first) ;
  // store the number of lines
  os << indextoidentmap.size() << std::endl ;
  // now store all elements, as follows
  // each line is: #idents ident1 ident2 ...indentN vectorsize element1 element2 ... elementN
  for( std::map<int, std::vector<Identifier> >::const_iterator it = indextoidentmap.begin() ;
       it != indextoidentmap.end(); ++it) {
    os << it->second.size() << " " ;
    for(auto vit : it->second)
      os << vit << " " ;
    const std::vector<float>& data = store[it->second.front()] ;
    os << data.size() << " " ;
    for(float vit : data)
      os << vit << " " ;
    os << std::endl ;
  }
  return os ;
}

operator>>()

std::istream & operator>>	(	std::istream &	is,
		FloatArrayStore &	store )

Definition at line 64 of file FloatArrayStore.cxx.

                                                              {
  store.clear() ;
  std::string tag ;
  is >> tag ;
  store = FloatArrayStore(tag) ;
  std::vector<int> identifiers(0) ;
  std::vector<float> data(0) ;
  constexpr int maxLines=2000000;//max 2 million lines
  constexpr int maxSize=2000000; //max size 2 million
  int nlines ;
  is >> nlines ;
  if ((nlines>=0) and (nlines<maxLines)) {
    for(int iline = 0; iline <nlines; ++iline) {
            int size ;
            is >> size ;
                if ((size>=0) and (size<maxSize)){
                identifiers.resize(size) ;
                for(int i=0; i<size; ++i) is >> (identifiers[i]) ;
                }
                else {
                  MsgStream log(Athena::getMessageSvc(), "FloatArrayStore");
                  log << MSG::ERROR << "size of identifier is incorrect" << endmsg;
                  return is;
                }
            is >> size ;
                if ((size>=0) and (size<maxSize)){
                data.resize(size) ;
                for(int i=0; i<size; ++i) is >> (data[i]) ;
                }
                else {
                  MsgStream log(Athena::getMessageSvc(), "FloatArrayStore");
                  log << MSG::ERROR << "size of data is incorrect" << endmsg;
                  return is;
                }
            Identifier reference(identifiers.front()) ;
            store.push_back( reference, data ) ;
            std::vector<int>::const_iterator it = identifiers.begin() ;
            for( ++it; it!= identifiers.end(); ++it) store.share(Identifier(*it),reference) ;
    }
  }
  return is ;
}