SM_StochasticOutputList.h

#ifndef SM_StochasticOutputList_H
#define SM_StochasticOutputList_H
 
//inherited class
#include "SM_StochasticOutput.h"
 
//components of the list
#include "SM_StochasticOutputComponent.h"
 
class SM_StochasticOutputList  : public SM_StochasticOutput<SM_StochasticOutputList>  {
  
    // ATTRIBUTES
  
public:
   
  
   
private:
    typedef SM_StochasticOutputList SelfClass;
    typedef  SM_StochasticOutput<SelfClass> SuperClass;
 
    
    std::vector<CORE_UniquePointer<SM_StochasticOutputComponent>> mStochasticOutputList;
   
   
 
  
    
public:
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_StochasticOutputList(void) {
      
    }
 
 
    // DESTRUCTORS 
    
    virtual ~SM_StochasticOutputList(void) {
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
    
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SuperClass::getContentsMemorySize();
        for(const auto& sd : mStochasticOutputList) {
            mem+=sd->getContentsMemorySize();
        }
        return mem;
    }
 
    inline static CORE_UniquePointer<SelfClass> New() {
        return CORE_UniquePointer<SelfClass>(new SelfClass(),
                                             SelfClass::Delete());
    }
 
    //SET & GET Methods
    //=================
    inline void clear()  {
        mStochasticOutputList.resize(0);
    }
    
    inline tIndex getSize() const {
        return mStochasticOutputList.size();
    }
 
    inline const std::vector<CORE_UniquePointer<SM_StochasticOutputComponent>>& getStochasticOutputList() const {
        return mStochasticOutputList;
    }
    inline std::vector<CORE_UniquePointer<SM_StochasticOutputComponent>>& getStochasticOutputList() {
        return mStochasticOutputList;
    }
    inline void add(CORE_UniquePointer<SM_StochasticOutputComponent> data) {
        mStochasticOutputList.push_back(std::move(data));
    }
    inline const SM_StochasticOutputComponent*  get(const tIndex& i) {
        return mStochasticOutputList[i].get();
    }
 
    
    virtual void setOutputPath(const tString& path) override {
        SuperClass::setOutputPath(path);
        for(auto& SOutput:mStochasticOutputList) SOutput->setOutputPath(path);
    }
  
    virtual void setPrefix(const tString& prefix) override {
        SuperClass::setPrefix(prefix);
         for(auto& SOutput:mStochasticOutputList) SOutput->setPrefix(prefix);
    }
    
    virtual void adimensionize(const SM_Material& material) override {
        for(auto& SOutput:mStochasticOutputList) SOutput->adimensionize(material);
    }
    virtual void setIndex(const int& index,
                          const int& rootIndex,
                          const int& n) final {
        SuperClass::setIndex(index,rootIndex,n);
        for(auto& SOutput:mStochasticOutputList) SOutput->setIndex(index,rootIndex,n);
    }
    //implemented templated methods
    //===================
    
    inline tBoolean open(const SM_Beam& beam) {
        tBoolean ok=true;
        for(auto& p : mStochasticOutputList) {
            ok=p->openComponent(beam) && ok;
        }
        return ok;
    }
    
    inline tBoolean open(const tIndex& s,const SM_System& system) {
        tBoolean ok=true;
        for(auto& p : mStochasticOutputList) {
            ok=ok && p->openComponent(s,system);
        }
        return ok;
    }
   
 
 
    inline tBoolean  store(const SM_System& system) {
        tBoolean ok=true;
        for(auto& p : mStochasticOutputList) {
            ok=p->storeComponent(system) && ok;
        }
        return ok;
      
    }
    inline tBoolean close(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded) {
        tBoolean ok=true;
        for(auto& p : mStochasticOutputList) {
            ok=p->closeComponent(s,system,hasSucceeded) && ok;
        }
        return ok;
    }
    
    inline tBoolean close(const SM_Beam& beam) {
        tBoolean ok=true;
        for(auto& p : mStochasticOutputList) {
            ok=p->closeComponent(beam) && ok;
        }
        //set the packed raw values 
        auto iP=mStochasticOutputList.begin();
        if (iP!=mStochasticOutputList.end()) {
            getPackedRawValues()=(*iP)->getPackedRawValues();
            getPackedRawValuesNumber()=(*iP)->getPackedRawValuesNumber();
        }
        return ok;
    }
    virtual void closePackedSimulations(const SM_Beam& beam,
                                        const tIndex& rawValuesNumber,
                                        const std::valarray<tReal>& rawValues) override {
       
        auto iP=mStochasticOutputList.begin();
        if (iP!=mStochasticOutputList.end()) {
            (*iP)->closePackedSimulations(beam,rawValuesNumber,rawValues);
        }
    }
    
    
    
public:
 
   
public:
    // OTHERS methods
   
    virtual tString toString() const override {
        tString routineName="SM_StochasticOutputList::toString()";
        CORE_Profiler::StartCallRoutine(routineName);
        std::stringstream ret;
        ret<<SM_StochasticOutput<SM_StochasticOutputList>::toString()<<"\n";
        for(auto& p : mStochasticOutputList) {
            ret<<"\t"<<p->toString()<<"\n";
        }
        CORE_Profiler::EndCallRoutine(routineName);
        return ret.str();
    }
    
 
 
};
 
#endif