ifd_entry.hpp

Go to the documentation of this file.

//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpniio.
//
// libpniio 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 2 of the License, or
// (at your option) any later version.
//
// libpniio 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 libpniio.  If not, see <http://www.gnu.org/licenses/>.
// ===========================================================================
//
// Created on: Apr 24, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
//
#pragma once

#include <iostream>
#include <fstream>
#include <map>
#include <boost/current_function.hpp>

#include <pni/core/types.hpp>
#include <pni/core/error.hpp>
#include "rational.hpp"
#include "ifd_entry_reader.hpp"

using namespace pni::core;

namespace pni{
namespace io{
namespace tiff{
   
    //possible data values of an IFD entry according to the TIFF standard
    enum class ifd_entry_type_id 
    { 
        BYTE,  
        ASCII, 
        SHORT, 
        LONG,  
        RATIONAL,  
        SBYTE,     
        UNDEFINED, 
        SSHORT,    
        SLONG,     
        SRATIONAL, 
        FLOAT,     
        DOUBLE     
    };

#ifdef ENUMBUG
    bool operator<(ifd_entry_type_id a,ifd_entry_type_id b);
    bool operator>(ifd_entry_type_id a,ifd_entry_type_id b);
    bool operator<=(ifd_entry_type_id a,ifd_entry_type_id b);
    bool operator>=(ifd_entry_type_id a,ifd_entry_type_id b);
#endif

    class ifd_entry
    {
        private:
            uint16 _tag;            
            ifd_entry_type_id _tid;   
            size_t _size;          
            std::streampos _data;  

            //===============private methods===================================
            template<typename T> 
            void _read_entry_data(std::vector<T> &r,std::ifstream &stream);

            //----------------------------------------------------------------
            void _read_entry_data(std::vector<string> &r,std::ifstream &stream);
            
        public:
            //=============constructors and destructor=========================
            ifd_entry();

            //-----------------------------------------------------------------
            ifd_entry(const ifd_entry &e);

            //-----------------------------------------------------------------
            ifd_entry(ifd_entry &&e);

            //-----------------------------------------------------------------
            ifd_entry(uint16 tag,ifd_entry_type_id tid,size_t size,
                      std::streampos data);

            //-----------------------------------------------------------------
            ~ifd_entry();

            //=====================assignment operators========================
            ifd_entry &operator=(const ifd_entry &e);

            ifd_entry &operator=(ifd_entry &&e);

            //===============static methods====================================
            static ifd_entry create_from_stream(std::ifstream &stream);

            //==================class methods==================================
            size_t size() const;

            //-----------------------------------------------------------------
            string name() const;

            //-----------------------------------------------------------------
            type_id_t type_id() const;

            //-----------------------------------------------------------------
            template<typename T> std::vector<T> value(std::ifstream &stream);

            //-----------------------------------------------------------------
            friend std::ostream &operator<<(std::ostream &o,const ifd_entry &e);

    };


    //==============implementation of public template methods===================
    template<typename T> std::vector<T> ifd_entry::value(std::ifstream &stream)
    {
        //create a vector of appropriate length
        std::vector<T> result(this->size());
        //save the original stream position
        std::streampos orig_stream_pos = stream.tellg();

        //set the stream to the begining of the data section
        stream.seekg(this->_data,std::ios::beg);

        //here comes the tricky part. Though the user defines the type T he
        //wants to have the IFD entry not all entry types can be converted to T
        //without loss of information. Thus wee need a selection function that
        //picks for each T all acceptable types and throws an exception if the
        //entry is of an incompatible type. 
        //
        //This operation is carried out by the next function which cann choose
        //the proper version by argument type deduction.
        try{
            this->_read_entry_data(result,stream);
        }
        catch(type_error &e)
        {
            e.append(EXCEPTION_RECORD);
            //reset the stream to its original position
            stream.seekg(orig_stream_pos,std::ios::beg);
            throw e;
        }
            
       
        //reset stream to its original position
        stream.seekg(orig_stream_pos,std::ios::beg);

        return result;
    }

    //--------------------------------------------------------------------------
    template<typename T> void ifd_entry:: 
        _read_entry_data(std::vector<T> &r,std::ifstream &stream)
    {
        if(this->_tid == ifd_entry_type_id::BYTE) 
            ifd_entry_reader<T,uint8>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::SHORT)
            ifd_entry_reader<T,uint16>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::LONG)
            ifd_entry_reader<T,uint32>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::RATIONAL)
            ifd_entry_reader<T,rational<uint16> >::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::SBYTE)
            ifd_entry_reader<T,int8>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::SSHORT)
            ifd_entry_reader<T,int16>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::SLONG)
            ifd_entry_reader<T,int32>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::SRATIONAL)
            ifd_entry_reader<T,rational<int32> >::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::FLOAT)
            ifd_entry_reader<T,float32>::read(r,stream);
        else if(this->_tid == ifd_entry_type_id::DOUBLE)
            ifd_entry_reader<T,float64>::read(r,stream);
        else
            //reset stream position
            throw type_error(EXCEPTION_RECORD,"IFD entry ["+this->name()+
                    "] contains unknown data!");
    }


//end of namespace
}
}
}