pst.h

Go to the documentation of this file.

 
 
#ifndef PSTSDK_PST_PST_H
#define PSTSDK_PST_PST_H
 
#include <boost/noncopyable.hpp>
#include <boost/iterator/filter_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>
 
#include "pstsdk/ndb/database.h"
#include "pstsdk/ndb/database_iface.h"
#include "pstsdk/ndb/node.h"
 
#include "pstsdk/ltp/propbag.h"
#include "pstsdk/ltp/nameid.h"
 
#include "pstsdk/pst/folder.h"
#include "pstsdk/pst/message.h"
#include "pstsdk/util/primitives.h"
 
namespace pstsdk
{
 
 
class pst : private boost::noncopyable
{
public:
    typedef boost::filter_iterator<is_nid_type<nid_type_folder>, const_nodeinfo_iterator> folder_filter_iterator;
    typedef boost::filter_iterator<is_nid_type<nid_type_message>, const_nodeinfo_iterator> message_filter_iterator;
    typedef boost::transform_iterator<message_transform_info, message_filter_iterator> message_iterator;
    typedef boost::transform_iterator<folder_transform_info, folder_filter_iterator> folder_iterator;
 
    pst(const std::wstring& filename)
        : m_db(open_database(filename)) { }
 
    pst(std::shared_ptr<file> custom_file)
        : m_db(open_database(custom_file)) { }
 
    pst(const pstsdk::pst &other_pst)
        : m_db(open_database(other_pst.m_db)) { }
 
#ifndef BOOST_NO_RVALUE_REFERENCES
    pst(pst&& other)
        : m_db(std::move(other.m_db)), m_bag(std::move(other.m_bag)), m_map(std::move(other.m_map)) { }
#endif
 
    // subobject discovery/enumeration
    folder_iterator folder_begin() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_folder> >(m_db->read_nbt_root()->begin(), m_db->read_nbt_root()->end()), folder_transform_info(m_db) ); }
    folder_iterator folder_end() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_folder> >(m_db->read_nbt_root()->end(), m_db->read_nbt_root()->end()), folder_transform_info(m_db) ); }
 
    folder_filter_iterator folder_node_begin() const
        { return boost::make_filter_iterator<is_nid_type<nid_type_folder> >(m_db->read_nbt_root()->begin(), m_db->read_nbt_root()->end()); }
    folder_filter_iterator folder_node_end() const
        { return boost::make_filter_iterator<is_nid_type<nid_type_folder> >(m_db->read_nbt_root()->end(), m_db->read_nbt_root()->end()); }
 
    message_filter_iterator message_node_begin() const
        { return boost::make_filter_iterator<is_nid_type<nid_type_message> >(m_db->read_nbt_root()->begin(), m_db->read_nbt_root()->end()); }
    message_filter_iterator message_node_end() const
        { return boost::make_filter_iterator<is_nid_type<nid_type_message> >(m_db->read_nbt_root()->end(), m_db->read_nbt_root()->end()); }
 
    message_iterator message_begin() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_message> >(m_db->read_nbt_root()->begin(), m_db->read_nbt_root()->end()), message_transform_info(m_db) ); }
    message_iterator message_end() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_message> >(m_db->read_nbt_root()->end(), m_db->read_nbt_root()->end()), message_transform_info(m_db) ); }
 
    folder open_root_folder() const
        { return folder(m_db, m_db->lookup_node(nid_root_folder)); }
    folder open_folder(const std::wstring& name) const;
 
    folder open_folder(node_id id) const
        { return folder(m_db, m_db->lookup_node(id)); }
 
    search_folder open_search_folder(node_id id) const
        { return search_folder(m_db, m_db->lookup_node(id)); }
 
    message open_message(node_id id) const
        { return message(m_db->lookup_node(id)); }
 
    // property access
    std::wstring get_name() const
        { return get_property_bag().read_prop<std::wstring>(PR_DISPLAY_NAME_W); }
    prop_id lookup_prop_id(const guid& g, const std::wstring& name) const
        { return get_name_id_map().lookup(g, name); }
    prop_id lookup_prop_id(const guid& g, long id) const
        { return get_name_id_map().lookup(g, id); }
    prop_id lookup_prop_id(const named_prop& n)
        { return get_name_id_map().lookup(n); }
    named_prop lookup_name_prop(prop_id id) const
        { return get_name_id_map().lookup(id); }
 
    // lower layer access
    property_bag& get_property_bag();
    name_id_map& get_name_id_map();
    const property_bag& get_property_bag() const;
    const name_id_map& get_name_id_map() const;
    shared_db_ptr get_db() const
        { return m_db; }
 
private:
    shared_db_ptr m_db;                             
    mutable std::shared_ptr<property_bag> m_bag;    
    mutable std::shared_ptr<name_id_map> m_map;     
};
 
} // end pstsdk namespace
 
inline const pstsdk::property_bag& pstsdk::pst::get_property_bag() const
{
    if(!m_bag)
        m_bag.reset(new property_bag(m_db->lookup_node(nid_message_store)));
 
    return *m_bag;
}
 
inline pstsdk::property_bag& pstsdk::pst::get_property_bag()
{
    return const_cast<property_bag&>(const_cast<const pst*>(this)->get_property_bag());
}
 
inline const pstsdk::name_id_map& pstsdk::pst::get_name_id_map() const
{
    if(!m_map)
        m_map.reset(new name_id_map(m_db));
 
    return *m_map;
}
 
inline pstsdk::name_id_map& pstsdk::pst::get_name_id_map()
{
    return const_cast<name_id_map&>(const_cast<const pst*>(this)->get_name_id_map());
}
 
inline pstsdk::folder pstsdk::pst::open_folder(const std::wstring& name) const
{
    folder_iterator iter = std::find_if(folder_begin(), folder_end(), compiler_workarounds::folder_name_equal(name));
 
    if(iter != folder_end())
        return *iter;
 
    throw key_not_found<std::wstring>(name);
}
 
#endif