SM_StochasticOutput.h

#ifndef SM_StochasticOutput_H
#define SM_StochasticOutput_H
 
//bas class header
#include "SM_StochasticOutputComponent.h"
 
 
template<class StochOutputImplement>
class SM_StochasticOutput  : public SM_StochasticOutputComponent {
  
    // ATTRIBUTES
  
private:
 
    typedef SM_StochasticOutput<StochOutputImplement> Self;
  
    
protected: 
    // METHODS
  
    // CONSTRUCTORS 
  
    SM_StochasticOutput(void) {
      
    }
 
  
  
    // DESTRUCTORS 
protected:
    
    virtual ~SM_StochasticOutput(void) {
    }
 
 
 
public:
    //MEMORY
    
    virtual tMemSize getMemorySize() const {
        return sizeof(*this)+getContentsMemorySize();
    }
 
    virtual tMemSize getContentsMemorySize() const {
        tMemSize mem=SM_StochasticOutputComponent::getContentsMemorySize();
        return mem;
    }
  
public:
 
    virtual void copy(const SM_StochasticOutputComponent& c) {
        SM_StochasticOutputComponent::copy(c);
    }
    
  
    
    //virtual methods
    //================
    virtual tBoolean openComponent(const SM_Beam& beam) final {
        return this->open(beam);
    };
        
    virtual tBoolean openComponent(const tIndex& s,const SM_System& system) final {
        return this->open(s,system);
    }
 
 
    virtual  tBoolean  storeComponent(const SM_System& system) final {
        return this->store(system);
    }
    
    virtual tBoolean closeComponent(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded) final {
        return this->close(s,system,hasSucceeded);
    }
    
    virtual tBoolean closeComponent(const SM_Beam& beam) final {
        return this->close(beam);
    }
 
    //templated methods to specialized
    //=================================
    
    inline tBoolean open(const SM_Beam& beam) {
        return static_cast<StochOutputImplement*>(this)->open(beam);
    }
    
    inline tBoolean open(const tIndex& s,const SM_System& system) {
        return static_cast<StochOutputImplement*>(this)->open(s,system);
    }
   
 
 
    inline tBoolean  store(const SM_System& system) {
        return static_cast<StochOutputImplement*>(this)->store(system);
    }
    inline tBoolean close(const tIndex& s,const SM_System& system,const tBoolean& hasSucceeded) {
        return static_cast<StochOutputImplement*>(this)->close(s,system,hasSucceeded);
    }
    inline tBoolean close(const SM_Beam& beam) {
        return static_cast<StochOutputImplement*>(this)->close(beam);
    }
    
 
};
 
#endif