fairport/ltp/object.h

Go to the documentation of this file.

#ifndef FAIRPORT_LTP_OBJECT_H
#define FAIRPORT_LTP_OBJECT_H

#include <functional>
#ifdef __GNUC__
#include <tr1/type_traits>
#include <tr1/functional>
#else
#include <type_traits>
#endif
#include <algorithm>
#define BOOST_ALL_NO_LIB 1
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable:4244 6328)
#endif
#include <boost/iostreams/concepts.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/iostreams/stream.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif

#include "fairport/util/primitives.h"
#include "fairport/util/errors.h"

#include "fairport/ltp/heap.h"

#include "fairport/ndb/node.h"

namespace fairport
{


class hnid_stream_device : public boost::iostreams::device<boost::iostreams::input_seekable>
{
public:
    std::streamsize read(char* pbuffer, std::streamsize n)
        { if(m_is_hid) return m_hid_device.read(pbuffer, n); else return m_node_device.read(pbuffer, n); }
    std::streampos seek(boost::iostreams::stream_offset off, std::ios_base::seekdir way)
        { if(m_is_hid) return m_hid_device.seek(off, way); else return m_node_device.seek(off, way); }

    hnid_stream_device(const hid_stream_device& hid_device) : m_hid_device(hid_device), m_is_hid(true) { }
    hnid_stream_device(const node_stream_device& node_device) : m_node_device(node_device), m_is_hid(false) { }

private:
    hid_stream_device m_hid_device;
    node_stream_device m_node_device;
    bool m_is_hid;

    std::streamsize m_pos;
};

typedef boost::iostreams::stream<hnid_stream_device> prop_stream;

class const_property_object
{
public:
    virtual ~const_property_object() { }
    virtual std::vector<prop_id> get_prop_list() const = 0;
    virtual prop_type get_prop_type(prop_id id) const = 0;
    virtual bool prop_exists(prop_id id) const = 0;
    virtual size_t size(prop_id id) const = 0;

    template<typename T>
    T read_prop(prop_id id) const;

    template<typename T>
    std::vector<T> read_prop_array(prop_id id) const;

    virtual hnid_stream_device open_prop_stream(prop_id id) = 0;

protected:
    virtual byte get_value_1(prop_id id) const = 0;
    virtual ushort get_value_2(prop_id id) const = 0;
    virtual ulong get_value_4(prop_id id) const = 0;
    virtual ulonglong get_value_8(prop_id id) const = 0;
    virtual std::vector<byte> get_value_variable(prop_id id) const = 0;
};

} // end fairport namespace

template<typename T>
inline T fairport::const_property_object::read_prop(prop_id id) const
{
#ifdef _MSC_VER
#pragma warning(suppress:4127)
#endif
    if(!std::tr1::is_pod<T>::value)
        throw std::invalid_argument("T must be a POD or one of the specialized classes");

    if(sizeof(T) == sizeof(ulonglong))
    {
        ulonglong t = get_value_8(id);
        return *(reinterpret_cast<T*>(&t));
    }
    else if(sizeof(T) == sizeof(ulong))
    {
        ulong t = get_value_4(id);
        return *(reinterpret_cast<T*>(&t));
    }
    else if(sizeof(T) == sizeof(ushort))
    {
        ushort t = get_value_2(id);
        return *(reinterpret_cast<T*>(&t));
    }
    else if(sizeof(T) == sizeof(byte))
    {
        byte t = get_value_1(id);
        return *(reinterpret_cast<T*>(&t));
    }
    else
    {
        std::vector<byte> buffer = get_value_variable(id);
        return *(reinterpret_cast<T*>(&buffer[0]));
    }
}

template<typename T>
inline std::vector<T> fairport::const_property_object::read_prop_array(prop_id id) const
{
#ifdef _MSC_VER
#pragma warning(suppress:4127)
#endif
    if(!std::tr1::is_pod<T>::value)
        throw std::invalid_argument("T must be a POD or one of the specialized classes");

    std::vector<byte> buffer = get_value_variable(id); 
    return std::vector<T>(reinterpret_cast<T*>(&buffer[0]), reinterpret_cast<T*>(&buffer[0] + buffer.size()));
}

namespace fairport
{

template<>
inline bool const_property_object::read_prop<bool>(prop_id id) const
{
    return get_value_4(id) != 0;
}

template<>
inline std::vector<bool> fairport::const_property_object::read_prop_array<bool>(prop_id id) const
{
    std::vector<ulong> values = read_prop_array<ulong>(id);
    std::vector<bool> results(values.size());
    std::transform(values.begin(), values.end(), results.begin(), std::tr1::bind(std::not_equal_to<ulong>(), 0, std::tr1::placeholders::_1));
    return results;
}

template<>
inline boost::posix_time::ptime const_property_object::read_prop<boost::posix_time::ptime>(prop_id id) const
{
    if(get_prop_type(id) == prop_type_apptime)
    {
        double time_value = read_prop<double>(id);
        return boost::posix_time::from_time_t(vt_date_to_time_t(time_value));
    }
    else
    {
        ulonglong time_value = read_prop<ulonglong>(id);
        return boost::posix_time::from_time_t(filetime_to_time_t(time_value)); 
    }
}

template<>
inline std::vector<boost::posix_time::ptime> const_property_object::read_prop_array<boost::posix_time::ptime>(prop_id id) const
{
    if(get_prop_type(id) == prop_type_mv_apptime)
    {
        std::vector<double> time_values = read_prop_array<double>(id);
        std::vector<time_t> result(time_values.size());
        std::vector<boost::posix_time::ptime> ptime_result(time_values.size());
        std::transform(time_values.begin(), time_values.end(), result.begin(), vt_date_to_time_t);
        std::transform(result.begin(), result.end(), ptime_result.begin(), boost::posix_time::from_time_t);
        return ptime_result;
    }
    else
    {
        std::vector<ulonglong> time_values = read_prop_array<ulonglong>(id);
        std::vector<time_t> result(time_values.size());
        std::vector<boost::posix_time::ptime> ptime_result(time_values.size());
        std::transform(time_values.begin(), time_values.end(), result.begin(), filetime_to_time_t);
        std::transform(result.begin(), result.end(), ptime_result.begin(), boost::posix_time::from_time_t);
        return ptime_result;
    }

}

template<>
inline std::vector<byte> const_property_object::read_prop<std::vector<byte> >(prop_id id) const
{
    return get_value_variable(id); 
}

template<>
inline std::vector<std::vector<byte> > const_property_object::read_prop_array<std::vector<byte> >(prop_id id) const
{
    std::vector<byte> buffer = get_value_variable(id);
#ifdef FAIRPORT_VALIDATION_LEVEL_WEAK
    if(buffer.size() < sizeof(ulong))
        throw std::length_error("mv prop too short");
#endif
    disk::mv_toc* ptoc = reinterpret_cast<disk::mv_toc*>(&buffer[0]);
    std::vector<std::vector<byte> > results;

#ifdef FAIRPORT_VALIDATION_LEVEL_WEAK
    if(buffer.size() < (sizeof(ulong) + ptoc->count * sizeof(ulong)))
        throw std::length_error("mv prop too short");
#endif

    for(ulong i = 0; i < ptoc->count; ++i)
    {
        ulong start = ptoc->offsets[i];
        ulong end = (i == (ptoc->count - 1)) ? buffer.size() : ptoc->offsets[i+1];
#ifdef FAIRPORT_VALIDATION_LEVEL_WEAK
        if(end < start)
            throw std::length_error("inconsistent mv prop toc");
#endif
        results.push_back(std::vector<byte>(&buffer[start], &buffer[start] + (end-start)));
    }

    return results;
}

template<>
inline std::wstring const_property_object::read_prop<std::wstring>(prop_id id) const
{
    std::vector<byte> buffer = get_value_variable(id); 

    if(get_prop_type(id) == prop_type_string)
    {
        std::string s(buffer.begin(), buffer.end());
        return codepage_1252_to_wstring(s);
    }
    else
    {
        return bytes_to_wstring(buffer);
    }
}

template<>
inline std::vector<std::wstring> const_property_object::read_prop_array<std::wstring>(prop_id id) const
{
    std::vector<std::vector<byte> > buffer = read_prop_array<std::vector<byte> >(id);
    std::vector<std::wstring> results;

    for(size_t i = 0; i < buffer.size(); ++i)
    {
        if(get_prop_type(id) == prop_type_mv_string)
        {
            std::string s(buffer[i].begin(), buffer[i].end());
            results.push_back(codepage_1252_to_wstring(s));
        }
        else
        {
            results.push_back(bytes_to_wstring(buffer[i]));
        }
    }

    return results;
}

template<>
inline std::string const_property_object::read_prop<std::string>(prop_id id) const
{
    std::vector<byte> buffer = get_value_variable(id); 

    if(get_prop_type(id) == prop_type_string)
    {
        return std::string(buffer.begin(), buffer.end());
    }
    else
    {
        if(buffer.size())
        {
            // Note that this code does the wrong thing for non-Latin-1
            // characters.  Use with caution.
            std::wstring s(bytes_to_wstring(buffer));
            return std::string(s.begin(), s.end());
        }
        return std::string();
    }
}

template<>
inline std::vector<std::string> const_property_object::read_prop_array<std::string>(prop_id id) const
{
    std::vector<std::vector<byte> > buffer = read_prop_array<std::vector<byte> >(id);
    std::vector<std::string> results;

    for(size_t i = 0; i < buffer.size(); ++i)
    {
        if(get_prop_type(id) == prop_type_mv_string)
        {
            results.push_back(std::string(buffer[i].begin(), buffer[i].end()));
        }
        else
        {
            if(buffer[i].size())
            {
                std::wstring s(bytes_to_wstring(buffer[i]));
                results.push_back(std::string(s.begin(), s.end()));
            }
            results.push_back(std::string());
        }
    }

    return results;
}

} // end fairport namespace

#endif