SM_CycleLoader.h

#ifndef SM_CycleLoader_H
#define SM_CycleLoader_H
 
//include the base class of the package
#include "CORE_Object.h"
 
//cycle headers
#include "SM_BeamTemperatureRange.h"
#include "SM_BeamHysteresis.h"
#include "SM_BeamTimeStepRange.h"
 
#include "SM_BeamRandomJRange.h"
 
 
class SM_CycleLoader : public CORE_Object  { // class
 
  
    // ASSOCIATION
 
 
    
    // ATTRIBUTES
  
private:
  
  
    // ASSOCIATIONS
  
   
    
    // METHODS
  
  
public:
    // CONSTRUCTORS
    SM_CycleLoader() {
    }
  
  
  
  
    // DESTRUCTORS
    virtual ~SM_CycleLoader(void) {
    }
 
  
  
  
  
public:
 
    
    //MEMORY
    
    virtual tMemSize getMemorySize() const override {
        return sizeof(*this)+getContentsMemorySize();
    }
    
  
    
public:
    
    
   
    // OTHERS
    template<class T>
    static tBoolean LoadCycleFromOptions(SM_BeamCycle<T>& cycle,
                                         const CORE_OptionsList& options) {
        tBoolean isSeedUpdated;
        if (options.getOptionValue("is-step-cycle-seed-updated",isSeedUpdated)) {
            cycle.setIsSeedUpdatedPerCycleStep(isSeedUpdated);
        }
        
        tLLInt seed=0;
        if (options.getOptionValue("seed",seed)) {
            if (seed>=0) {
                cycle.setSeedPerCycleStep((tULLInt)seed);
            }
        }
        
      
        tBoolean isRestoring=false;
        options.getOptionValue("is-cycle-restoring",isRestoring);
        cycle.setIsRestoring(isRestoring);
        
        tBoolean isStochasticOutputSavedAtCStep=true;
        options.getOptionValue("is-stochastic-output-saved-at-each-cycle-step",isStochasticOutputSavedAtCStep);
        cycle.setIsStochasticOutputSavedAtEachStep(isStochasticOutputSavedAtCStep);
        
        SM_BeamHysteresis* hys=dynamic_cast<SM_BeamHysteresis*>(&cycle);
        if (hys!=null) {
            return LoadHysteresisCycleFromOptions(*hys,options);
        }
        SM_BeamTemperatureRange* temps=dynamic_cast<SM_BeamTemperatureRange*>(&cycle);
        if (temps!=null) {
            return LoadTemperatureCycleFromOptions(*temps,options);
        }
        SM_BeamRandomJRange* js=dynamic_cast<SM_BeamRandomJRange*>(&cycle);
        if (js!=null) {
            return LoadRandomJCycleFromOptions(*js,options);
        }
        SM_BeamTimeStepRange* dts=dynamic_cast<SM_BeamTimeStepRange*>(&cycle);
        if (dts!=null) {
            return LoadTimeStepCycleFromOptions(*dts,options);
        }
        return false;
    }
private:
    static tBoolean LoadHysteresisCycleFromOptions(SM_BeamHysteresis& cycle,
                                                   const CORE_OptionsList& options);
    
    static tBoolean LoadTemperatureCycleFromOptions(SM_BeamTemperatureRange& cycle,
                                                    const CORE_OptionsList& options);
 
    static tBoolean LoadRandomJCycleFromOptions(SM_BeamRandomJRange& cycle,
                                                const CORE_OptionsList& options);
    
    static tBoolean LoadTimeStepCycleFromOptions(SM_BeamTimeStepRange& cycle,
                                                 const CORE_OptionsList& options);
 
 
    
 
   
 
  
   
    
 
 
    
};
    
#endif