GroupSessionDatabase.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 Savarese Software Research Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.savarese.com/software/ApacheLicense-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef __SSRC_WSPR_GROUP_SESSION_DATABASE_H
#define __SSRC_WSPR_GROUP_SESSION_DATABASE_H

#include <ssrc/wispers/utility/Properties.h>
#include <ssrc/wispers/utility/AppendToContainer.h>
#include <ssrc/wispers/group_session/types.h>
#include <ssrc/wispers/database/DatabaseTransaction.h>
#include <ssrc/wispers/database/RowOperations.h>

__BEGIN_NS_SSRC_WSPR_GROUP_SESSION

using namespace NS_SSRC_WSPR_DATABASE;
using NS_SSRC_WSPR_UTILITY::Properties;
using NS_SSRC_WSPR_UTILITY::AppendToContainer;

class GroupSessionDatabase : public DatabaseWrapper {

  prepared_statement_ptr _count_sessions;
  prepared_statement_ptr _count_reservations;
  prepared_statement_ptr _get_participant_sessions;
  prepared_statement_ptr _get_observer_sessions;
  prepared_statement_ptr _find_participants;
  prepared_statement_ptr _find_observers;
  prepared_statement_ptr _find_members_for_uid;
  prepared_statement_ptr _find_members_for_participant;
  prepared_statement_ptr _remove_observer_by_uid;
  prepared_statement_ptr _get_member_uids;
  prepared_statement_ptr _get_member_uids_discard;
  prepared_statement_ptr _find_expired_gsids;
  prepared_statement_ptr _get_sessions_by_type;
  prepared_statement_ptr _remove_reservation;
  prepared_statement_ptr _remove_expired_sessions;
  prepared_statement_ptr _get_reservation_participants;
  prepared_statement_ptr _remove_expired_reservations;
  prepared_statement_ptr _get_participant_reservations;
  prepared_statement_ptr _find_sessions;
  prepared_statement_ptr _is_member;
  prepared_statement_ptr _count_observers;
  prepared_statement_ptr _activate_reservation_participants;

public:
  typedef RowOperations<GroupSession> GroupSessionOperations;
  typedef RowOperations<Member> MemberOperations;
  typedef RowOperations<Reservation> ReservationOperations;

  GroupSessionOperations group_session_ops;
  MemberOperations participant_ops;
  MemberOperations observer_ops;
  ReservationOperations reservation_ops;
  MemberOperations reservation_participant_ops;

  GroupSessionDatabase(const string & db_file, const Properties & properties)
    SSRC_DECL_THROW(DatabaseException) :
    DatabaseWrapper(db_file),
  // TODO: figure out a better way...
#define GSDB_INIT_QUERY(key) \
    _ ## key(_database.prepare(*properties.get_ptr<string>( \
      "wspr","config", "group_session", "GroupSessionDatabase", "Query", #key)))

    GSDB_INIT_QUERY(count_sessions),
    GSDB_INIT_QUERY(count_reservations),
    GSDB_INIT_QUERY(get_participant_sessions),
    GSDB_INIT_QUERY(get_observer_sessions),
    GSDB_INIT_QUERY(find_participants),
    GSDB_INIT_QUERY(find_observers),
    GSDB_INIT_QUERY(find_members_for_uid),
    GSDB_INIT_QUERY(find_members_for_participant),
    GSDB_INIT_QUERY(remove_observer_by_uid),
    GSDB_INIT_QUERY(get_member_uids),
    GSDB_INIT_QUERY(get_member_uids_discard),
    GSDB_INIT_QUERY(find_expired_gsids),
    GSDB_INIT_QUERY(get_sessions_by_type),
    GSDB_INIT_QUERY(remove_reservation),
    GSDB_INIT_QUERY(remove_expired_sessions),
    GSDB_INIT_QUERY(get_reservation_participants),
    GSDB_INIT_QUERY(remove_expired_reservations),
    GSDB_INIT_QUERY(get_participant_reservations),
    GSDB_INIT_QUERY(find_sessions),
    GSDB_INIT_QUERY(is_member),
    GSDB_INIT_QUERY(count_observers),
    GSDB_INIT_QUERY(activate_reservation_participants),

#undef GSDB_INIT_QUERY
    group_session_ops(_database),
    participant_ops(_database, DefaultValueBinder(), DefaultValueLoader(),
                    MemberOperations::ImplicitColumns, "Participant"),
    observer_ops(_database,
                 DefaultValueBinder(), DefaultValueLoader(),
                 MemberOperations::ImplicitColumns, "Observer"),
    reservation_ops(_database,
                    DefaultValueBinder(), DefaultValueLoader(),
                    ReservationOperations::ExplicitColumns),
    reservation_participant_ops(_database,
                                DefaultValueBinder(), DefaultValueLoader(),
                                MemberOperations::ImplicitColumns,
                                "ReservationParticipant")
  { }

  virtual ~GroupSessionDatabase() { }

  static unsigned int remove_member_by_uid(PreparedStatement & query,
                                           const uid_type member)
    SSRC_DECL_THROW(DatabaseException)
  {
    return query.execute(member).changes;
  }

  template<typename iterator_type>
  static unsigned int remove_members_by_uid(PreparedStatement & query,
                                            const iterator_type & begin,
                                            const iterator_type & end)
    SSRC_DECL_THROW(DatabaseException)
  {
    iterator_type it = begin;
    unsigned int total = 0;

    while(it != end) {
      total+=remove_member_by_uid(query, *it);
      ++it;
    }

    return total;
  }

  unsigned int count_sessions() const SSRC_DECL_THROW(DatabaseException) {
    unsigned int result =
      _count_sessions->execute().result_set->value<unsigned int>();
    _count_sessions->reset();
    return result;
  }

  unsigned int count_reservations() const SSRC_DECL_THROW(DatabaseException) {
    unsigned int result =
      _count_reservations->execute().result_set->value<unsigned int>();
    _count_reservations->reset();
    return result;
  }

  template<typename functor>
  unsigned int
  for_each_participant(const functor & apply, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_participants->for_each(apply, gsid);
  }

  template<typename container_type>
  unsigned int
  find_participants(container_type & results, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_participant(AppendToContainer<container_type>(results), gsid);
  }

  template<typename functor>
  unsigned int
  for_each_participant_session(const functor & apply,
                               const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_participant_sessions->for_each(apply, uid);
  }

  template<typename container_type>
  unsigned int
  get_participant_sessions(container_type & results,
                           const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return for_each_participant_session(AppendToContainer<container_type>(results), uid);
  }

  template<typename functor>
  unsigned int
  for_each_observer_session(const functor & apply,
                            const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_observer_sessions->for_each(apply, uid);
  }

  template<typename container_type>
  unsigned int
  get_observer_sessions(container_type & results,
                        const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_observer_session(AppendToContainer<container_type>(results), uid);
  }

  template<typename functor>
  unsigned int
  for_each_member_for_uid(const functor & apply, const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_members_for_uid->for_each(apply, uid);
  }

  template<typename container_type>
  unsigned int
  find_members_for_uid(container_type & results, const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return for_each_member_for_uid(AppendToContainer<container_type>(results), uid);
  }

  template<typename functor>
  unsigned int for_each_member_for_participant(const functor & apply,
                                               const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_members_for_participant->for_each(apply, uid);
  }

  template<typename container_type>
  unsigned int find_members_for_participant(container_type & results,
                                            const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return for_each_member_for_participant(AppendToContainer<container_type>(results), uid);
  }

  template<typename functor>
  unsigned int
  for_each_observer(const functor & apply, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_observers->for_each(apply, gsid);
  }

  template<typename container_type>
  unsigned int
  find_observers(container_type & results, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return for_each_observer(AppendToContainer<container_type>(results), gsid);
  }

  unsigned int remove_observer_by_uid(const uid_type observer) {
    return remove_member_by_uid(*_remove_observer_by_uid, observer);
  }

  template<typename iterator_type>
  unsigned int remove_observers_by_uid(const iterator_type & begin,
                                       const iterator_type & end)
  {
    return remove_members_by_uid(*_remove_observer_by_uid, begin, end);
  }

  template<typename functor>
  unsigned int
  for_each_member_uid(const functor & apply, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_member_uids->for_each(apply, gsid);
  }

  template<typename container_type>
  unsigned int
  get_member_uids(container_type & results, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_member_uid(AppendToContainer<container_type>(results), gsid);
  }

  template<typename functor>
  unsigned int
  for_each_member_uid_discard(const functor & apply,
                              const gsid_type gsid,
                              const uid_type discard) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_member_uids_discard->for_each(apply, gsid, discard);
  }

  template<typename container_type>
  unsigned int
  get_member_uids_discard(container_type & results,
                      const gsid_type gsid, const uid_type discard) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_member_uid_discard(AppendToContainer<container_type>(results),
                                  gsid, discard);
  }

  template<typename functor>
  unsigned int
  for_each_expired_gsid(const functor & apply, const sec_type expires) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_expired_gsids->for_each(apply, expires);
  }

  template<typename container_type>
  unsigned int
  find_expired_gsids(container_type & results, const sec_type expires) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_expired_gsid(AppendToContainer<container_type>(results), expires);
  }

  template<typename functor>
  unsigned int
  for_each_session_by_type(const functor & apply,
                           const string & type) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_sessions_by_type->for_each(apply, type);
  }

  template<typename container_type>
  unsigned int
  get_sessions_by_type(container_type & results,
                       const string & type) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_session_by_type(AppendToContainer<container_type>(results), type);
  }

  unsigned int remove_expired_sessions(const sec_type expires)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _remove_expired_sessions->execute(expires).changes;
  }

  unsigned int remove_reservation(const gsid_type gsid, const uid_type creator)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _remove_reservation->execute(gsid, creator).changes;
  }

  template<typename functor>
  unsigned int
  for_each_reservation_participant(const functor & apply,
                                   const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_reservation_participants->for_each(apply, gsid);
  }

  template<typename container_type>
  unsigned int
  get_reservation_participants(container_type & results,
                               const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_reservation_participant(AppendToContainer<container_type>(results), gsid);
  }

  unsigned int remove_expired_reservations(const sec_type expires)
    SSRC_DECL_THROW(DatabaseException)
  {
    return _remove_expired_reservations->execute(expires).changes;
  }

  template<typename functor>
  unsigned int
  for_each_participant_reservation(const functor & apply,
                                   const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _get_participant_reservations->for_each(apply, uid);
  }

  template<typename container_type>
  unsigned int
  get_participant_reservations(container_type & results,
                               const uid_type uid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_participant_reservation(AppendToContainer<container_type>(results), uid);
  }

  template<typename functor>
  unsigned int for_each_session(const functor & apply,
                                     const db_limit_type limit = -1,
                                     const db_offset_type offset = 0) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _find_sessions->for_each(apply, limit, offset);
  }
  
  template<typename container_type>
  unsigned int find_sessions(container_type & results,
                             const db_limit_type limit = -1,
                             const db_offset_type offset = 0) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return
      for_each_session(AppendToContainer<container_type>(results), limit, offset);
  }

  bool is_member(const uid_type member, const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    bool result = _is_member->execute(member, gsid).result_set;
    _is_member->reset();
    return result;
  }

  unsigned int count_observers(const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    unsigned int result =
      _count_observers->execute(gsid).result_set->value<unsigned int>();
    _count_observers->reset();
    return result;
  }

  unsigned int activate_reservation_participants(const gsid_type gsid) const
    SSRC_DECL_THROW(DatabaseException)
  {
    return _activate_reservation_participants->execute(gsid).changes;
  }
};

__END_NS_SSRC_WSPR_GROUP_SESSION

#endif