Matrix.h

/* 
 *  Copyright 2012 Matthias Fuchs
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

#ifndef STROMX_RUNTIME_MATRIX_H
#define STROMX_RUNTIME_MATRIX_H

#include <stdint.h>
#include "stromx/runtime/Data.h"

namespace stromx
{
    namespace runtime
    {
        class STROMX_RUNTIME_API Matrix : public Data
        {
        public:
            enum ValueType
            {
                NONE,
                INT_8,
                UINT_8,
                INT_16,
                UINT_16,
                INT_32,
                UINT_32,
                FLOAT_32,
                FLOAT_64
            };
            
            virtual ~Matrix() {}

            virtual uint8_t* buffer() = 0;
            
            virtual unsigned int bufferSize() const = 0;
            
            virtual unsigned int rows() const = 0;
            
            virtual unsigned int cols() const = 0;
            
            virtual unsigned int stride() const = 0;
            
            virtual ValueType valueType() const = 0;
            
            virtual unsigned int valueSize() const;
            
            virtual uint8_t* data() = 0;
            
            virtual const uint8_t* data() const = 0;
            
            virtual void initializeMatrix(const unsigned int rows, 
                                          const unsigned int cols, 
                                          const unsigned int stride, 
                                          uint8_t* data, 
                                          const ValueType valueType) = 0;
                                     
            static unsigned int valueSize(const ValueType valueType);
            
            template <class T>
            T & at(const unsigned row, const unsigned col)
            {
                const Matrix & mat = const_cast<const Matrix &>(*this);
                
                return const_cast<T &>(mat.at<T>(row, col));
            }
            
            template <class T>
            const T & at(const unsigned int row, const unsigned col) const
            {
                if(sizeof(T) != valueSize())
                    throw WrongArgument("Size of access type does not match value size.");
                
                if(row >= rows())
                    throw WrongArgument("Row index out of bounds.");
                
                if(col >= cols())
                    throw WrongArgument("Column index out of bounds.");
                
                unsigned int byteOffset = row * stride() + col * valueSize();
                
                return *(reinterpret_cast<const T*>(data() + byteOffset));
            }
            
            template <class T>
            const T value(const unsigned int row, const unsigned int col) const
            {
                switch(valueType())
                {
                case UINT_8:
                    return static_cast<T>(at<uint8_t>(row, col));
                case INT_8:
                    return static_cast<T>(at<int8_t>(row, col));
                case UINT_16:
                    return static_cast<T>(at<uint16_t>(row, col));
                case INT_16:
                    return static_cast<T>(at<int16_t>(row, col));
                case UINT_32:
                    return static_cast<T>(at<uint32_t>(row, col));
                case INT_32:
                    return static_cast<T>(at<int32_t>(row, col));
                case FLOAT_32:
                    return static_cast<T>(at<float>(row, col));
                case FLOAT_64:
                    return static_cast<T>(at<double>(row, col));
                default:
                    throw InternalError("Unknown value type.");
                };
            }
            
        protected:
            
            static const runtime::VariantHandle dataVariantFromValueType(const ValueType valueType);
        };
        
        STROMX_RUNTIME_API bool operator==(const Matrix & rhs, const Matrix & lhs);
        
        STROMX_RUNTIME_API bool operator!=(const Matrix & rhs, const Matrix & lhs);
        
        template <>
        class STROMX_RUNTIME_API data_traits<Matrix>
        {
        public:
            static const VariantHandle & variant();
        };
    }
}

#endif // STROMX_RUNTIME_MATRIX_H