MatrixWrapper.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_MATRIXWRAPPER_H
#define STROMX_RUNTIME_MATRIXWRAPPER_H

#include "stromx/runtime/Matrix.h"

namespace stromx
{
        namespace runtime
    {
        class STROMX_RUNTIME_API MatrixWrapper : public Matrix
        {
        public:
            static void save(const std::string& filename, const runtime::Matrix & matrix);
            
            MatrixWrapper(const unsigned int bufferSize, uint8_t* const buffer);
            
            MatrixWrapper();
            
            // Implementation of stromx::runtime::Matrix
            virtual const VariantHandle & variant() const { return m_variant; }
            virtual uint8_t* buffer() { return m_buffer; }
            virtual unsigned int bufferSize() const { return m_bufferSize; }
            virtual unsigned int rows() const { return m_rows; }
            virtual unsigned int cols() const { return m_cols; }
            virtual unsigned int stride() const { return m_stride; }
            virtual ValueType valueType() const { return m_valueType; }
            virtual uint8_t* data() { return m_data; }
            virtual const uint8_t* data() const { return m_data; }
            virtual void initializeMatrix(const unsigned int rows, 
                                          const unsigned int cols, 
                                          const unsigned int stride, 
                                          uint8_t* data, 
                                          const ValueType valueType);
            virtual void serialize(OutputProvider & output) const;
            virtual void deserialize(InputProvider & input, const Version & version);
            
            void resize(const unsigned int rows, const unsigned int cols, const ValueType valueType);
            
            void resize(const unsigned int size);
            
            void open(const std::string& filename);
            
            void save(const std::string& filename) const;
            
        protected:
            void setBuffer(uint8_t* const buffer, const unsigned int bufferSize);
            
            virtual void allocate(const unsigned int rows, const unsigned int cols, const runtime::Matrix::ValueType valueType) = 0;
            
            
            
        private:
            static const char NUMPY_MAGIC_BYTE = char(0x93);
            
            static void doSerialize(std::ostream & out, const runtime::Matrix & matrix);
            static void doDeserialize(std::istream & in, MatrixWrapper & matrix);
            static bool isLittleEndian();
            static char npyTypeSymbol(const runtime::Matrix::ValueType valueType);
            static Matrix::ValueType valueTypeFromNpyHeader(const char valueType, const int wordSize);
            
            void validate(const unsigned int rows,
                        const unsigned int cols,
                        const unsigned int stride,
                        const uint8_t* data,
                        const ValueType valueType) const;
                       
            unsigned int m_rows;
            unsigned int m_cols;
            unsigned int m_stride;
            unsigned int m_bufferSize;
            ValueType m_valueType;
            uint8_t* m_data;
            uint8_t* m_buffer;
            VariantHandle m_variant;
        };
    }
}

#endif // STROMX_RUNTIME_MATRIXWRAPPER_H