Storage.cpp

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
 */

#include "Storage.h"
#include "EVCStateMachine.h"




namespace oETCS {

namespace DF {


CStorage::CStorage(oETCS::DF::CEVCStateMachine * const pStateMachine, const bool& bDebug, const std::string& DebugName)  throw()  
:CFunctionBlock(pStateMachine),
 m_bBoolInput(false),
 m_dDoubleInput(0.0),
 m_DoubleArrayInput(::std::vector< double >(0)),
 m_iIntInput(0),
 m_StringInput("0"),
 m_BitValue(0),
 m_eLastInputType(::oETCS::DF::BOOL),
 m_bDebug(bDebug),
 m_DebugName(DebugName)
{
  // Bouml preserved body begin 00061682
    // empty constructor
  // Bouml preserved body end 00061682

} //  CStorage::CStorage()  throw() 




CStorage::~CStorage()  throw()  
{
  // Bouml preserved body begin 00061702
    // empty destructor
  // Bouml preserved body end 00061702

} // CStorage::~CStorage()  throw() 




void CStorage::Calculate()  throw(::oETCS::DF::Error::CException)  
{
  // Bouml preserved body begin 00061782
    unsigned int                    x(0);
    const unsigned int              NUMBER_BOOL_OUTPUT(m_BoolValue.size());
    const unsigned int              NUMBER_DOUBLE_OUTPUT(m_DoubleValue.size());
    const unsigned int              NUMBER_DOUBLE_ARRAY_OUTPUT(m_DoubleArrayValue.size());
    const unsigned int              NUMBER_INT_OUTPUT(m_IntValue.size());
    const unsigned int              NUMBER_STRING_OUTPUT(m_StringValue.size());
    const unsigned int              NUMBER_BIT_OUTPUT(m_BitValue.size());
    double                          dConversion(0);
    float                           fConversion(0);
    int                             iConversion(0);
    ::std::stringstream             ConversionStream;
    
    
    // check, if any input type value was changed
    if (m_bBoolInput.IsModified())
    {
        // convert new boolean input to all other data types
        m_dDoubleInput.m_Value        = m_bBoolInput() ? 1.0 : 0.0;
        m_DoubleArrayInput.m_Value.clear();
        m_DoubleArrayInput.m_Value.push_back(m_bBoolInput() ? 1.0 : 0.0);
        m_iIntInput.m_Value         = m_bBoolInput() ? 1 : 0;
        m_StringInput.m_Value       = m_bBoolInput() ? "true" : "false";
        
        // set last input type to boolean
        m_eLastInputType = ::oETCS::DF::BOOL;
        
    } // if (m_bBoolInput.IsModified())
    else if (m_dDoubleInput.IsModified())
    {
        // convert new double value to all other data types
        m_bBoolInput.m_Value        = m_dDoubleInput();
        m_DoubleArrayInput.m_Value.clear();
        m_DoubleArrayInput.m_Value.push_back(m_dDoubleInput());
        m_iIntInput.m_Value         = m_dDoubleInput();
        ConversionStream << m_dDoubleInput();
        m_StringInput.m_Value = ConversionStream.str();
        
        // set last input type to double
        m_eLastInputType = ::oETCS::DF::DOUBLE;
        
    } // else if (m_dDoubleInput.IsModified())
    else if (m_DoubleArrayInput.IsModified())
    {
        // check, if new array is not empty
        if (!m_DoubleArrayInput.m_Value.empty())
        {
            // convert new double array to all other data types
            m_bBoolInput.m_Value        = m_DoubleArrayInput()[0];
            m_dDoubleInput.m_Value      = m_DoubleArrayInput()[0];
            m_iIntInput.m_Value         = m_DoubleArrayInput()[0];
            ConversionStream << m_DoubleArrayInput()[0];
            m_StringInput.m_Value = ConversionStream.str();
            
            // set last input type to double array
            m_eLastInputType = ::oETCS::DF::DOUBLE_ARRAY;
            
        } // if (!m_DoubleArrayInput.m_Value.empty())
        
    } // else if (m_DoubleArrayInput.IsModified())
    else if (m_iIntInput.IsModified())
    {
        // convert new integer value to all other data types
        m_bBoolInput.m_Value        = m_iIntInput();
        m_dDoubleInput.m_Value      = m_iIntInput();
        m_DoubleArrayInput.m_Value.clear();
        m_DoubleArrayInput.m_Value.push_back(m_iIntInput());
        ConversionStream << m_iIntInput();
        m_StringInput.m_Value       = ConversionStream.str();
        
        // set last input type to integer
        m_eLastInputType = ::oETCS::DF::INT;
        
    } // else if (m_iIntInput.IsModified())
    else if (m_StringInput.IsModified())
    {
        // convert new string value to boolean
        ConversionStream.str(m_StringInput.m_Value);
        ConversionStream >> m_bBoolInput.m_Value;
        ConversionStream.clear();
        
        // again store string in stream
        ConversionStream.str(m_StringInput());
        
        // check, to which number type string can be converted
        if (ConversionStream >> dConversion)
        {
            // set all number members from double
            m_dDoubleInput.m_Value        = dConversion;
            m_DoubleArrayInput.m_Value.resize(1);
            m_DoubleArrayInput.m_Value[0] = dConversion;
            m_iIntInput.m_Value           = dConversion;
            
        } // if (ConversionStream >> dConversion)
        else if (ConversionStream >> fConversion)
        {
            // set all number members from float
            m_dDoubleInput.m_Value        = fConversion;
            m_DoubleArrayInput.m_Value.resize(1);
            m_DoubleArrayInput.m_Value[0] = fConversion;
            m_iIntInput.m_Value           = fConversion;

        } // else if (ConversionStream >> fConversion)
        else if (ConversionStream >> iConversion)
        {
            // set all number members from integer
            m_dDoubleInput.m_Value        = iConversion;
            m_DoubleArrayInput.m_Value.resize(1);
            m_DoubleArrayInput.m_Value[0] = iConversion;
            m_iIntInput.m_Value           = iConversion;

        } // else if (ConversionStream >> fConversion)
        else
        {
            // set default value for all numbers
            m_dDoubleInput.m_Value        = 0.0;
            m_DoubleArrayInput.m_Value.resize(1);
            m_DoubleArrayInput.m_Value[0] = 0.0;
            m_iIntInput.m_Value           = 0.0;
            
        } // else
        
        // set last input type to string
        m_eLastInputType = ::oETCS::DF::STRING;
                
    } // else if (m_StringInput.IsModified())
    
      
    // set all boolean outputs
    for (x = 0; x < NUMBER_BOOL_OUTPUT; x++)
    {
        *(m_BoolValue[x]) = m_bBoolInput();
        
    } // for (x = 0; x < NUMBER_BOOL_OUTPUT; x++)
    
    // set all double outputs
    for (x = 0; x < NUMBER_DOUBLE_OUTPUT; x++)
    {
        *(m_DoubleValue[x]) = m_dDoubleInput();

    } // for (x = 0; x < NUMBER_DOUBLE_OUTPUT; x++)
    
    // set all double outputs
    for (x = 0; x < NUMBER_DOUBLE_ARRAY_OUTPUT; x++)
    {
        *(m_DoubleArrayValue[x]) = m_DoubleArrayInput();

    } // for (x = 0; x < NUMBER_DOUBLE_ARRAY_OUTPUT; x++)
    
    // set all integer outputs
    for (x = 0; x < NUMBER_INT_OUTPUT; x++)
    {
        *(m_IntValue[x]) = m_iIntInput();

    } // for (x = 0; x < NUMBER_INT_OUTPUT; x++)
    
    // set all string outputs
    for (x = 0; x < NUMBER_STRING_OUTPUT; x++)
    {
        *(m_StringValue[x]) = m_StringInput();

    } // for (x = 0; x < NUMBER_STRING_OUTPUT; x++)
    
    // set all bit outputs
    for (x = 0; x < NUMBER_BIT_OUTPUT; x++)
    {
        // set current bit output as this instance
        *(m_BitValue[x]) = *this;
        
    } // for (x = 0; x < NUMBER_BIT_OUTPUT; x++)
    
    // check, if this instance uses debug output
    if (m_bDebug)
    {
        
        // print prefix of output
        ::std::cout << "DEBUG: CStrorage \"" << m_DebugName << "\" -> ";
        
        // switch the last used input type
        switch (m_eLastInputType)
        {
            case ::oETCS::DF::BOOL:
                // print boolean value
                ::std::cout << "boolean " << m_bBoolInput();
                
                break;
                
                
            case ::oETCS::DF::DOUBLE:
                // print double value
                ::std::cout << "double " << m_dDoubleInput();

                break;
                
                
            case ::oETCS::DF::INT:
                // print integer value
                ::std::cout << "integer " << m_iIntInput();

                break;
                
            case ::oETCS::DF::STRING:
                // print string value
                ::std::cout << "string " << m_StringInput();

                break;
                
                
            case ::oETCS::DF::DOUBLE_ARRAY:
                // print double array value
                ::std::cout << "double array " << m_DoubleArrayInput();

                break;
            
        } // switch (m_eLastInputType)
        
        // append newline to output
        ::std::cout << ::std::endl;
        
    } // if (m_bDebug)
    
  // Bouml preserved body end 00061782

} // void CStorage::Calculate()  throw(::oETCS::DF::Error::CException) 




::std::vector< bool > CStorage::GetBitVector(const unsigned long& lSize)  const throw()  
{
  // Bouml preserved body begin 000ABC82
    unsigned int                x(0);
    unsigned int                y(0);
    unsigned int                z(0);
    const unsigned char*        pByte(0);
    unsigned long               lIntSize(0);
    unsigned long               lArraySize(0);
    unsigned long               lStringSize(0);
    int                         iIntInput(m_iIntInput());
    ::std::vector< bool >       Bits(0);
    
    
    // check, if size is greater than zero, otherwise ignore
    if (lSize > 0)
    {
        // resize bit vector
        Bits.resize(lSize);
    
        // check, which input type was used the last time
        switch(m_eLastInputType)
        {
            case ::oETCS::DF::BOOL:
                // set one and only bit in vector
                Bits[0] = m_bBoolInput();

                break;


            case ::oETCS::DF::DOUBLE:
                // convert double into integer
                iIntInput = m_dDoubleInput();

            case ::oETCS::DF::INT:
                // calculate real integer size 
                lIntSize = lSize < sizeof (int) * 8 ? lSize : sizeof (int) * 8;
                
                // initialise byte pointer at last byte of integer (little endian)
                pByte = reinterpret_cast< const unsigned char* >(iIntInput) + lIntSize - 1;

                // copy bytes of integer into vector
                for (x = 0; x < lIntSize; x++)
                {
                    // copy all bits of current byte
                    for (y = 0; y < 8; y++)
                    {
                        // copy current bit
                        Bits[(x * 8) + y] = ((1 << (7 - y)) & (*pByte)); 

                    } // for (y = 0; y < 8; y++)

                    // decrease byte pointer
                    pByte--;

                } // for (x = 0; x < lIntSize; x++)

                break;


            case ::oETCS::DF::DOUBLE_ARRAY:
                // calculate real array size
                lArraySize = lSize < sizeof (int) * 8 * m_DoubleArrayInput().size() ? lSize : sizeof (int) * 8 *  m_DoubleArrayInput().size();
                
                // re-calculate real integer size 
                lIntSize = lArraySize / m_DoubleArrayInput().size();

                // process all elements of double array
                for (z = 0; z < m_DoubleArrayInput().size(); z++)
                {
                    // convert current double element to integer
                    iIntInput = m_DoubleArrayInput()[z];

                    // initialise byte pointer at last byte of integer (little endian)
                    pByte = reinterpret_cast< const unsigned char* >(iIntInput) + lIntSize - 1;

                    // copy bytes of integer into vector
                    for (x = 0; x < lIntSize; x++)
                    {
                        // copy all bits of current byte
                        for (y = 0; y < 8; y++)
                        {
                            // copy current bit
                            Bits[(x * 8) + y + (z * sizeof(int) * 8)] = ((1 << (7 - y)) & (*pByte)); 

                        } // for (y = 0; y < 8; y++)

                        // decrease byte pointer
                        pByte--;

                    } // for (x = 0; x < lIntSize; x++)

                } // for (z = 0; z < m_DoubleArrayInput().size(); z++)

                break;


            case ::oETCS::DF::STRING:
                // calculate real string size
                lStringSize = lSize < m_StringInput().size() * sizeof (char) * 8 ? lSize / 8 : m_StringInput().size();

                // process all chars/bytes of string
                for (x = 0; x < lStringSize; x++)
                {
                    // copy current byte/char bit-wise
                    for (y = 0; y < 8; y++)
                    {
                        // copy current bit
                        Bits[(x * 8) + y] = ((1 << (7 - y)) & m_StringInput()[x]); 

                    } // for (y = 0; y < 8; y++)

                } // for (x = 0; x < lStringSize; x++)

                break;

        } // switch(m_eLastInputType)
    
    } // if (lSize > 0)
    
       
    // return bit vector
    return (Bits);
  // Bouml preserved body end 000ABC82

} // bool CStorage::GetBitVector()  const throw() 




oETCS::DF::DATA_T CStorage::GetLastInputType()  const throw()  
{
  // Bouml preserved body begin 000CBE82
    // return member value
    return (m_eLastInputType);
  // Bouml preserved body end 000CBE82

} // oETCS::DF::DATA_T CStorage::GetLastInputType()  const throw() 






} // namespace oETCS::DF

} // namespace oETCS