folder.h

Go to the documentation of this file.

 
 
#ifndef PSTSDK_PST_FOLDER_H
#define PSTSDK_PST_FOLDER_H
 
#include <algorithm>
#include <boost/iterator/filter_iterator.hpp>
#include <boost/iterator/transform_iterator.hpp>
 
#include "pstsdk/util/primitives.h"
#include "pstsdk/util/errors.h"
 
#include "pstsdk/ndb/database_iface.h"
 
#include "pstsdk/ltp/propbag.h"
#include "pstsdk/ltp/table.h"
 
#include "pstsdk/pst/message.h"
#include "pstsdk/mapitags.h"
 
namespace pstsdk
{
 
 
template<node_id Type>
struct is_nid_type
{
    bool operator()(const node_info& info)
        { return get_nid_type(info.id) == Type; }
    bool operator()(const const_table_row& row)
        { return get_nid_type(row.get_row_id()) == Type; }
};
 
class search_folder
{
public:
    typedef boost::transform_iterator<message_transform_row, const_table_row_iter> message_iterator;
 
    search_folder(const shared_db_ptr& db, const node& n)
        : m_db(db), m_bag(n) { }
    search_folder(const search_folder& other);
 
#ifndef BOOST_NO_RVALUE_REFERENCES
    search_folder(search_folder&& other)
        : m_db(std::move(other.m_db)), m_bag(std::move(other.m_bag)), m_contents_table(std::move(other.m_contents_table)) { }
#endif
 
    // subobject discovery/enumeration
    message_iterator message_begin() const
        { return boost::make_transform_iterator(get_contents_table().begin(), message_transform_row(m_db)); }
    message_iterator message_end() const
        { return boost::make_transform_iterator(get_contents_table().end(), message_transform_row(m_db)); }
 
    // property access
    std::wstring get_name() const
        { return m_bag.read_prop<std::wstring>(PR_DISPLAY_NAME_W); }
    size_t get_unread_message_count() const
        { return m_bag.read_prop<slong>(PR_CONTENT_UNREAD); }
    size_t get_message_count() const
        { return m_bag.read_prop<slong>(PR_CONTENT_COUNT); }
 
    // lower layer access
    property_bag& get_property_bag()
        { return m_bag; }
    const property_bag& get_property_bag() const
        { return m_bag; }
    shared_db_ptr get_db() const 
        { return m_db; }
    table& get_contents_table();
    const table& get_contents_table() const;
 
    node_id get_id() const
        { return m_bag.get_node().get_id(); }
 
private:
    shared_db_ptr m_db;
    property_bag m_bag;
    mutable std::shared_ptr<table> m_contents_table;
};
 
class search_folder_transform_row
{
public:
    search_folder_transform_row(const shared_db_ptr& db) 
        : m_db(db) { }
    search_folder operator()(const const_table_row& row) const
        { return search_folder(m_db, m_db->lookup_node(row.get_row_id())); }
 
private:
    shared_db_ptr m_db;
};
 
class folder;
class folder_transform_row
{
public:
    folder_transform_row(const shared_db_ptr& db) 
        : m_db(db) { }
    folder operator()(const const_table_row& row) const;
 
private:
    shared_db_ptr m_db;
};
 
class folder
{
    typedef boost::filter_iterator<is_nid_type<nid_type_search_folder>, const_table_row_iter> search_folder_filter_iterator;
    typedef boost::filter_iterator<is_nid_type<nid_type_folder>, const_table_row_iter> folder_filter_iterator;
 
public:
    typedef boost::transform_iterator<message_transform_row, const_table_row_iter> message_iterator;
    typedef boost::transform_iterator<folder_transform_row, folder_filter_iterator> folder_iterator;
    typedef boost::transform_iterator<search_folder_transform_row, search_folder_filter_iterator> search_folder_iterator;
 
    folder(const shared_db_ptr& db, const node& n)
        : m_db(db), m_bag(n) { }
    folder(const folder& other);
 
#ifndef BOOST_NO_RVALUE_REFERENCES
    folder(folder&& other)
        : m_db(std::move(other.m_db)), m_bag(std::move(other.m_bag)), m_contents_table(std::move(other.m_contents_table)), m_associated_contents_table(std::move(other.m_associated_contents_table)), m_hierarchy_table(std::move(other.m_hierarchy_table)) { }
#endif
 
    // subobject discovery/enumeration
    folder_iterator sub_folder_begin() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_folder> >(get_hierarchy_table().begin(), get_hierarchy_table().end()), folder_transform_row(m_db)); }
    folder_iterator sub_folder_end() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_folder> >(get_hierarchy_table().end(), get_hierarchy_table().end()), folder_transform_row(m_db)); }
 
    search_folder_iterator sub_search_folder_begin() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_search_folder> >(get_hierarchy_table().begin(), get_hierarchy_table().end()), search_folder_transform_row(m_db)); }
    search_folder_iterator sub_search_folder_end() const
        { return boost::make_transform_iterator(boost::make_filter_iterator<is_nid_type<nid_type_search_folder> >(get_hierarchy_table().begin(), get_hierarchy_table().end()), search_folder_transform_row(m_db)); }
 
    folder open_sub_folder(const std::wstring& name);
 
    message_iterator message_begin() const
        { return boost::make_transform_iterator(get_contents_table().begin(), message_transform_row(m_db)); }
    message_iterator message_end() const
        { return boost::make_transform_iterator(get_contents_table().end(), message_transform_row(m_db)); }
 
    message_iterator associated_message_begin() const
        { return boost::make_transform_iterator(get_associated_contents_table().begin(), message_transform_row(m_db)); }
    message_iterator associated_message_end() const
        { return boost::make_transform_iterator(get_associated_contents_table().end(), message_transform_row(m_db)); }
 
    // property access
    std::wstring get_name() const
        { return m_bag.read_prop<std::wstring>(PR_DISPLAY_NAME_W); }
    size_t get_subfolder_count() const
        { return get_hierarchy_table().size(); } 
    size_t get_unread_message_count() const
        { return m_bag.read_prop<slong>(PR_CONTENT_UNREAD); }
    size_t get_message_count() const
        { return m_bag.read_prop<slong>(PR_CONTENT_COUNT); }
    size_t get_associated_message_count() const
        { return m_bag.read_prop<slong>(PR_ASSOC_CONTENT_COUNT); }
 
    // lower layer access
    property_bag& get_property_bag()
        { return m_bag; }
    const property_bag& get_property_bag() const
        { return m_bag; }
    shared_db_ptr get_db() const 
        { return m_db; }
    table& get_hierarchy_table();
    table& get_contents_table();
    table& get_associated_contents_table();
    const table& get_hierarchy_table() const;
    const table& get_contents_table() const;
    const table& get_associated_contents_table() const;
 
    node_id get_id() const
        { return m_bag.get_node().get_id(); }
 
private:
    shared_db_ptr m_db;
    property_bag m_bag;
    mutable std::shared_ptr<table> m_contents_table;
    mutable std::shared_ptr<table> m_associated_contents_table;
    mutable std::shared_ptr<table> m_hierarchy_table;
};
 
class folder_transform_info
{
public:
    folder_transform_info(const shared_db_ptr& db) 
        : m_db(db) { }
    folder operator()(const node_info& info) const
        { return folder(m_db, node(m_db, info)); }
 
private:
    shared_db_ptr m_db;
};
 
} // end namespace pstsdk
 
inline pstsdk::search_folder::search_folder(const pstsdk::search_folder& other)
: m_db(other.m_db), m_bag(other.m_bag) 
{ 
    if(other.m_contents_table)
        m_contents_table.reset(new table(*other.m_contents_table));
}
 
inline pstsdk::folder::folder(const pstsdk::folder& other)
: m_db(other.m_db), m_bag(other.m_bag) 
{ 
    if(other.m_contents_table)
        m_contents_table.reset(new table(*other.m_contents_table));
    if(other.m_associated_contents_table)
        m_contents_table.reset(new table(*other.m_associated_contents_table));
    if(other.m_hierarchy_table)
        m_contents_table.reset(new table(*other.m_hierarchy_table));
}
 
inline pstsdk::folder pstsdk::folder_transform_row::operator()(const pstsdk::const_table_row& row) const
{ 
    return folder(m_db, m_db->lookup_node(row.get_row_id()));
}
 
inline const pstsdk::table& pstsdk::search_folder::get_contents_table() const
{
    if(!m_contents_table)
        m_contents_table.reset(new table(m_db->lookup_node(make_nid(nid_type_search_contents_table, get_nid_index(m_bag.get_node().get_id())))));
 
    return *m_contents_table;
}
 
inline pstsdk::table& pstsdk::search_folder::get_contents_table()
{
    return const_cast<table&>(const_cast<const search_folder*>(this)->get_contents_table());
}
 
 
namespace compiler_workarounds
{
 
struct folder_name_equal
{
    folder_name_equal(const std::wstring& name) : m_name(name) { }
    bool operator()(const pstsdk::folder& f) const { return f.get_name() == m_name; }
    std::wstring m_name;
};
 
} // end namespace compiler_workarounds
 
inline pstsdk::folder pstsdk::folder::open_sub_folder(const std::wstring& name)
{
    folder_iterator iter = std::find_if(sub_folder_begin(), sub_folder_end(), compiler_workarounds::folder_name_equal(name));
 
    if(iter != sub_folder_end())
        return *iter;
 
    throw key_not_found<std::wstring>(name);
}
 
inline const pstsdk::table& pstsdk::folder::get_contents_table() const
{
    if(!m_contents_table)
        m_contents_table.reset(new table(m_db->lookup_node(make_nid(nid_type_contents_table, get_nid_index(m_bag.get_node().get_id())))));
 
    return *m_contents_table;
}
 
inline pstsdk::table& pstsdk::folder::get_contents_table()
{
    return const_cast<table&>(const_cast<const folder*>(this)->get_contents_table());
}
 
inline const pstsdk::table& pstsdk::folder::get_hierarchy_table() const
{
    if(!m_hierarchy_table)
        m_hierarchy_table.reset(new table(m_db->lookup_node(make_nid(nid_type_hierarchy_table, get_nid_index(m_bag.get_node().get_id())))));
 
    return *m_hierarchy_table;
}
 
inline pstsdk::table& pstsdk::folder::get_hierarchy_table()
{
    return const_cast<table&>(const_cast<const folder*>(this)->get_hierarchy_table());
}
 
inline const pstsdk::table& pstsdk::folder::get_associated_contents_table() const
{
    if(!m_associated_contents_table)
        m_associated_contents_table.reset(new table(m_db->lookup_node(make_nid(nid_type_associated_contents_table, get_nid_index(m_bag.get_node().get_id())))));
 
    return *m_associated_contents_table;
}
 
inline pstsdk::table& pstsdk::folder::get_associated_contents_table()
{
    return const_cast<table&>(const_cast<const folder*>(this)->get_associated_contents_table());
}
 
#endif