fairport/pst/message.h

Go to the documentation of this file.

#ifndef FAIRPORT_PST_MESSAGE_H
#define FAIRPORT_PST_MESSAGE_H

#include <functional>
#include <ostream>
#include <boost/iterator/transform_iterator.hpp>

#include "fairport/ndb/database_iface.h"
#include "fairport/ndb/node.h"

#include "fairport/ltp/propbag.h"
#include "fairport/ltp/table.h"

#include "fairport/pst/pstutil.h"

namespace fairport
{


class message;
class contact;
class attachment
{
public:
    // property access
    std::wstring get_filename() const;
    std::vector<byte> get_bytes() const
        { return m_bag.read_prop<std::vector<byte> >(0x3701); }
    hnid_stream_device open_byte_stream()
        { return m_bag.open_prop_stream(0x3701); }
    size_t size() const
        { return m_bag.read_prop<uint>(0xe20); }
    size_t content_size() const
        { return m_bag.size(0x3701); }
    bool is_message() const
        { return m_bag.read_prop<uint>(0x3705) == 5; }
    message open_as_message() const;

    // lower layer access
    property_bag& get_property_bag()
        { return m_bag; }
    const property_bag& get_property_bag() const
        { return m_bag; }

private:
    attachment& operator=(const attachment&); // = delete
    friend class message;
    friend class contact;
    friend class attachment_transform;

    explicit attachment(const property_bag& attachment)
        : m_bag(attachment) { }

    property_bag m_bag;
};

inline std::ostream& operator<<(std::ostream& out, const attachment& attach)
{
    std::vector<byte> data = attach.get_bytes();
    out.write(reinterpret_cast<char*>(&data[0]), data.size());
    return out;
}

class attachment_transform : public std::unary_function<const_table_row, attachment>
{
public:
    explicit attachment_transform(const node& n) 
        : m_node(n) { }

    attachment operator()(const const_table_row& row) const
        { return attachment(property_bag(m_node.lookup(row.get_row_id()))); }

private:
    node m_node;
};

class recipient
{
public:
    // property access
    std::wstring get_name() const
        { return m_row.read_prop<std::wstring>(0x3001); }
    recipient_type get_type() const
        { return static_cast<recipient_type>(m_row.read_prop<ulong>(0xc15)); }
    std::wstring get_address_type() const
        { return m_row.read_prop<std::wstring>(0x3002); }
    std::wstring get_email_address() const
        { return m_row.read_prop<std::wstring>(0x39fe); }
    bool has_email_address() const
        { return m_row.prop_exists(0x39fe); }
    std::wstring get_account_name() const
        { return m_row.read_prop<std::wstring>(0x3a00); }
    bool has_account_name() const
        { return m_row.prop_exists(0x3a00); }

    // lower layer access
    const_table_row& get_property_row()
        { return m_row; }
    const const_table_row& get_property_row() const
        { return m_row; }

private:
    recipient& operator=(const recipient&); // = delete
    friend struct recipient_transform;

    explicit recipient(const const_table_row& row)
        : m_row(row) { }
    const_table_row m_row;
};

struct recipient_transform : public std::unary_function<const_table_row, recipient>
{
    recipient operator()(const_table_row row) const
        { return recipient(row); }
};

class message : public detail::itembase
{
public:
    typedef boost::transform_iterator<attachment_transform, const_table_row_iter> attachment_iterator;
    typedef boost::transform_iterator<recipient_transform, const_table_row_iter> recipient_iterator;

    explicit message(const node& n)
        : detail::itembase(n) { }
    message(const message& other);

    // subobject discovery/enumeration
    attachment_iterator attachment_begin() const
        { return boost::make_transform_iterator(get_attachment_table().begin(), attachment_transform(get_property_bag().get_node())); }
    attachment_iterator attachment_end() const
        { return boost::make_transform_iterator(get_attachment_table().end(), attachment_transform(get_property_bag().get_node())); }
    recipient_iterator recipient_begin() const
        { return boost::make_transform_iterator(get_recipient_table().begin(), recipient_transform()); }
    recipient_iterator recipient_end() const
        { return boost::make_transform_iterator(get_recipient_table().end(), recipient_transform()); }

    // property access
    std::wstring get_subject() const;
    bool has_subject() const
        { return get_property_bag().prop_exists(0x37); }
    std::wstring get_body() const
        { return get_property_bag().read_prop<std::wstring>(0x1000); }
    hnid_stream_device open_body_stream()
        { return get_property_bag().open_prop_stream(0x1000); }
    size_t body_size() const
        { return get_property_bag().size(0x1000); }
    bool has_body() const
        { return get_property_bag().prop_exists(0x1000); }
    std::wstring get_html_body() const
        { return get_property_bag().read_prop<std::wstring>(0x1013); }
    hnid_stream_device open_html_body_stream()
        { return get_property_bag().open_prop_stream(0x1013); }
    size_t html_body_size() const
        { return get_property_bag().size(0x1013); }
    bool has_html_body() const
        { return get_property_bag().prop_exists(0x1013); }
    // \brief Get the total size of this message
    size_t size() const
        { return get_property_bag().read_prop<slong>(0xe08); }
    size_t get_attachment_count() const
        { return get_attachment_table().size(); }
    boost::posix_time::ptime get_delivery_time() const
        { return get_property_bag().read_prop<boost::posix_time::ptime>(0x0e06); }
    boost::posix_time::ptime get_last_modification_time() const
        { return get_property_bag().read_prop<boost::posix_time::ptime>(0x3008); }

    size_t get_recipient_count() const
        { return get_recipient_table().size(); }

    // lower layer access
    table& get_attachment_table()
        { return const_cast<table&>(const_cast<const message*>(this)->get_attachment_table()); }
    table& get_recipient_table()
        { return const_cast<table&>(const_cast<const message*>(this)->get_recipient_table()); }
    const table& get_attachment_table() const;
    const table& get_recipient_table() const;

private:
    mutable std::tr1::shared_ptr<table> m_attachment_table;
    mutable std::tr1::shared_ptr<table> m_recipient_table;
};

typedef detail::item_transform_row<message> message_transform_row;
typedef detail::item_transform_info<message> message_transform_info;
} // end namespace fairport

inline std::wstring fairport::attachment::get_filename() const
{
    try
    {
        return m_bag.read_prop<std::wstring>(0x3707);
    } 
    catch(key_not_found<prop_id>&)
    {
        return m_bag.read_prop<std::wstring>(0x3704);
    }
}

inline fairport::message fairport::attachment::open_as_message() const
{
    if(!is_message()) 
        throw std::bad_cast();

    std::vector<byte> buffer = get_bytes();
    disk::sub_object* psubo = (disk::sub_object*)&buffer[0];

    return message(m_bag.get_node().lookup(psubo->nid));
}

inline fairport::message::message(const fairport::message& other)
: detail::itembase(other)
{
    if(other.m_attachment_table)
        m_attachment_table.reset(new table(*other.m_attachment_table));
    if(other.m_recipient_table)
        m_recipient_table.reset(new table(*other.m_recipient_table));
}

inline const fairport::table& fairport::message::get_attachment_table() const
{
    if(!m_attachment_table)
    {
        try
        {
            m_attachment_table.reset(new table(get_property_bag().get_node().lookup(nid_attachment_table)));
        }
        catch (const key_not_found<node_id>&) 
        {
            m_attachment_table.reset(new table());
        }
    }

    return *m_attachment_table;
}

inline const fairport::table& fairport::message::get_recipient_table() const
{
    if(!m_recipient_table)
    {
        try
        {
            m_recipient_table.reset(new table(get_property_bag().get_node().lookup(nid_recipient_table)));
        }
        catch (const key_not_found<node_id>&)
        {
            m_recipient_table.reset(new table());
        }
    }

    return *m_recipient_table;
}

inline std::wstring fairport::message::get_subject() const
{
    std::wstring buffer = get_property_bag().read_prop<std::wstring>(0x37);

    if(buffer.size() && buffer[0] == message_subject_prefix_lead_byte)
    {
        // Skip the second chracter as well
        return buffer.substr(2);
    }
    else
    {
        return buffer;
    }
}
#endif