FFrExtractor.H

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 SAP SE
//
// SPDX-License-Identifier: Apache-2.0
//
// This file is part of FEDEM - https://openfedem.org
 
#ifndef FFR_EXTRACTOR_H
#define FFR_EXTRACTOR_H
 
#include "FFrLib/FFrVariable.H"
#include "FFrLib/FFrItemGroup.H"
#include <string>
#include <vector>
#include <set>
#include <map>
 
class FFrEntryBase;
class FFrObjectGroup;
class FFrSuperObjectGroup;
class FFrResultContainer;
class FFaResultDescription;
 
 
class FFrExtractor
{
public:
  FFrExtractor(const char* xname = NULL);
  virtual ~FFrExtractor();
 
  static void releaseMemoryBlocks(bool readOps = false);
 
  const std::string& getName() const { return myName; }
 
  bool addFiles(const std::set<std::string>& fileNames,
                bool showProgress = false, bool doMemPoll = false);
  virtual bool addFiles(const std::vector<std::string>& fileNames,
                        bool showProgress = false, bool mustExist = false,
                        bool doMemPoll = false);
  bool addFile(const std::string& fileName, bool mustExist = false,
               bool doMemPoll = false);
 
  void closeFiles();
 
  std::set<std::string> getAllResultContainerFiles() const;
 
  FFrResultContainer* getResultContainer(const std::string& fileName) const;
 
  virtual bool removeFiles(const std::set<std::string>& fileNames);
 
  virtual void doResultFilesUpdate(bool doMemPoll = true);
 
  VariableSet*  getVariables()  { return &myVariables; }
  ItemGroupSet* getItemGroups() { return &myItemGroups; }
 
  bool empty() const { return myTopLevelOGs.empty(); }
 
  FFrEntryBase* getTopLevelVar(const std::string& key) const;
  FFrObjectGroup* getObjectGroup(int id) const;
  FFrSuperObjectGroup* getSuperGroup(const std::string& key) const;
 
  void printContainerInfo() const;
  void printHierarchy() const;
 
  FFrEntryBase* search(const FFaResultDescription& descr);
  void search(std::vector<FFrEntryBase*>& entries,
              const FFaResultDescription& descr);
  FFrEntryBase* findVar(const std::string& oType, int baseId,
                        const std::string& vName);
 
 
  // RDB Positioning:
 
  bool resetRDBPositioning();
 
  bool positionRDB(double wantedTime, double& foundTime,
                   bool getNextHigher = false);
 
  bool incrementRDB();
 
 
  // RDB Time info access:
 
  void getValidKeys(std::set<double>& resKeys,
                    const std::set<std::string>& files) const;
 
  void enableTimeStepPreRead(const std::set<std::string>& files);
  void disableTimeStepPreRead();
  void clearPreReadTimeStep();
 
  double getLastTimeStep() const;
  double getFirstTimeStep() const;
  double getLastWrittenTime() const;
 
  double getCurrentRDBPhysTime() const { return myCurrentPhysTime; }
 
  int getSingleTimeStepData(const FFrEntryBase* entryRef,
                            const double* values, int nval);
  int getSingleTimeStepData(const FFrEntryBase* entryRef,
                            const int* values, int nval);
 
  std::set<std::string>* getDictionary() { return &myDict; }
 
protected:
  virtual int doResultFileUpdate(FFrResultContainer* container, bool memPoll);
  bool updateExtractorHeader(FFrResultContainer* container, bool memPoll);
 
private:
  std::string myName;       
  double myCurrentPhysTime; 
 
  std::set<std::string> myDict;
 
  using ContainerMap = std::map<std::string,FFrResultContainer*>;
 
  ContainerMap myContainers; 
  VariableSet  myVariables;  
  ItemGroupSet myItemGroups; 
 
protected:
  std::map<std::string,FFrSuperObjectGroup*> myTopLevelSOGs;
  std::map<int,FFrObjectGroup*>              myTopLevelOGs;
  std::map<std::string,FFrEntryBase*>        myTopLevelVars;
};
 
#endif