Storage.h

Go to the documentation of this file.

/*
    Copyright (C) 2010-2012
    Johannes Feuser <feuser@uni-bremen.de>
    This file is part of the openETCS library.

    The openETCS library is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    any later version.

    The openETCS library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with the openETCS library.  If not, see <http://www.gnu.org/licenses/>.
*/

/*!
 *  \author Johannes Feuser <feuser@uni-bremen.de>
 *  \brief storage class
 */

#ifndef __OETCS_DF_STORAGE_H__
#define __OETCS_DF_STORAGE_H__


#include <sstream>

#include <string>
#include "Error/ExceptionTypes.h"
#include <vector>
#include "Configuration.h"
#include "EVCStateMachine.h"




namespace oETCS { namespace DF { class CEVCStateMachine; }  } 
namespace oETCS { namespace DF { class CBitFlow; }  } 


namespace oETCS {

namespace DF {


/*!
 *  \brief storage class for holding any available meta model data type
 */
class CStorage : public oETCS::DF::CFunctionBlock 
{
  public:
    /*!
     *  \brief general constructor
     *
     *  \param[in] pStateMachine   pointer to the parent EVC state machine object
     *  \param[in] bDebug          optinal flag for using debug ouput of value
     *  \param[in] DebugName       optional name for the debug output
     */
    explicit CStorage(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool & bDebug = false, const std::string & DebugName = "") throw();
    
    

    /*!
     *  \brief destructor
     */
    virtual ~CStorage() throw();
    
    

    /*!
     *  \brief virtual method for computing all outputs and setting the all referenced outputs
     *
     *  \remark must be implemented by any inheriting class
     */
    virtual void Calculate() throw(::oETCS::DF::Error::CException);
    
    

    /*!
     *  \brief gets a bit vector corresponding to the value
     *
     *  If the required size is smaller than the calculated needed size,
     *  the vector is truncated. In case of an array, the vector is truncated+
     *  element-wise.
     *  
     *  \param[in] lSize required size of the bit vector
     *  \return               vector of boolean holding the bit raw data in little endian format
     */
    ::std::vector< bool > GetBitVector(const unsigned long& lSize) const throw();
    
    

    /*!
     *  \brief gets the type of the last used input during Calculate()
     *
     *  \return type of the input
     */
    oETCS::DF::DATA_T GetLastInputType() const throw();
    
    

    /*!
     *  \brief container of the boolean input
     */
    oETCS::DF::BOOL_CONTAINER_T m_bBoolInput;
    
    

    /*!
     *  \brief container of the double input
     */
    oETCS::DF::DOUBLE_CONTAINER_T m_dDoubleInput;
    
    

    /*!
     *  \brief container of the double array input
     */
    oETCS::DF::DOUBLE_ARRAY_CONTAINER_T m_DoubleArrayInput;
    
    

    /*!
     *  \brief container of the integer input
     */
    oETCS::DF::INT_CONTAINER_T m_iIntInput;
    
    

    /*!
     *  \brief container of the string input
     */
    oETCS::DF::STRING_CONTAINER_T m_StringInput;
    
    

    /*!
     *  \brief pointers to boolean storages 
     */
    ::std::vector< oETCS::DF::BOOL_OUTPUT_T > m_BoolValue;
    
    

    /*!
     *  \brief pointers to double storages  
     */
    ::std::vector< oETCS::DF::DOUBLE_OUTPUT_T > m_DoubleValue;
    
    

    /*!
     *  \brief pointers to double array storages  
     */
    ::std::vector< oETCS::DF::DOUBLE_ARRAY_OUTPUT_T > m_DoubleArrayValue;
    
    

    /*!
     *  \brief pointers to interger storages  
     */
    ::std::vector< oETCS::DF::INT_OUTPUT_T > m_IntValue;
    
    

    /*!
     *  \brief pointers to string storages  
     */
    ::std::vector< oETCS::DF::STRING_OUTPUT_T > m_StringValue;
    
    

    /*!
     *  \brief vector of pointers to bit flows
     */
    ::std::vector< oETCS::DF::CBitFlow* > m_BitValue;
    
    


  private:
    /*!
     *  \brief type of the input within the last cycle (call of Calculate())
     */
    oETCS::DF::DATA_T m_eLastInputType;
    
    

    /*!
     *  \brief flag for debug output
     */
    const bool m_bDebug;
    
    

    /*!
     *  \brief name of instance for debug output
     */
    const std::string m_DebugName;
    
    


}; // class CStorage : public oETCS::DF::CFunctionBlock





} // namespace oETCS::DF

} // namespace oETCS

#endif // __ OETCS_DF_STORAGE_H__