BaseMessage.h

Go to the documentation of this file.

/*
 *
 * Copyright 2006 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
 *
 *     http://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_SPREAD_BASE_MESSAGE_H
#define __SSRC_SPREAD_BASE_MESSAGE_H

#include <string>

#include <ssrc/libssrcspread-packages.h>

__BEGIN_NS_SPREAD_INCLUDE
# include <sp.h>

  // Convert define to typedef.
# if defined(int16)
  typedef int16 foo_int16;
# undef int16
  typedef foo_int16 int16;
# endif
__END_NS_SPREAD_INCLUDE

#include <ssrc/spread/Error.h>
#include <ssrc/spread/GroupList.h>

__BEGIN_NS_SSRC_SPREAD

#ifdef LIBSSRCSPREAD_ENABLE_MEMBERSHIP_INFO

// Forward declaration
class MembershipInfo;

#endif

class BaseMessage {
public:
  typedef Spread::int16 message_type;

  typedef Spread::service service_type;

  enum Service {
    Unreliable  = UNRELIABLE_MESS,
    Reliable    = RELIABLE_MESS,
    FIFO        = FIFO_MESS,
    Causal      = CAUSAL_MESS,
    Agreed      = AGREED_MESS,
    Safe        = SAFE_MESS,
    SelfDiscard = SELF_DISCARD,
    DropReceive = DROP_RECV,
#define SERVICE_TYPE_DISCARD(s) s ## SelfDiscard = s | SelfDiscard

    SERVICE_TYPE_DISCARD(Unreliable),
    SERVICE_TYPE_DISCARD(Reliable),
    SERVICE_TYPE_DISCARD(FIFO),
    SERVICE_TYPE_DISCARD(Causal),
    SERVICE_TYPE_DISCARD(Agreed),
    SERVICE_TYPE_DISCARD(Safe)

#undef SERVICE_TYPE_DISCARD
  };

private:

#ifdef LIBSSRCSPREAD_ENABLE_MEMBERSHIP_INFO

  void get_vs_set_members(const Spread::vs_set_info *vs_set,
                          GroupList *members, unsigned int offset = 0) const;

#endif

protected:

  message_type _type;
  service_type _service_type;
  bool _endian_mismatch;
  string _sender;

  BaseMessage() :
    _type(0), _service_type(Safe), _endian_mismatch(false), _sender("")
  { }

#ifdef LIBSSRCSPREAD_ENABLE_MEMBERSHIP_INFO

  virtual int sp_get_membership_info(Spread::membership_info *info) const = 0;

  virtual int sp_get_vs_set_members(const Spread::vs_set_info *vs_set,
                                    Spread::group_type member_names[],
                                    unsigned int member_names_count) const = 0;

  virtual int sp_get_vs_sets_info(Spread::vs_set_info *vs_sets,
                                  unsigned int num_vs_sets,
                                  unsigned int *index) const = 0;

#endif

public:

  virtual ~BaseMessage() { }

  virtual unsigned int size() const = 0;

  virtual void clear() = 0;

#ifdef LIBSSRCSPREAD_ENABLE_MEMBERSHIP_INFO

  void get_membership_info(MembershipInfo & info) const SSRC_DECL_THROW(Error);

#endif

  void set_service(const service_type service) {
    _service_type = service;
  }

  service_type service() const {
    return _service_type;
  }

  void set_type(const message_type type) {
    _type = type;
  }

  message_type type() const {
    return _type;
  }

  void set_sender(const string & sender) {
    _sender = sender;
  }

  const string & sender() const {
    return _sender;
  }

  void set_endian_mismatch(const bool mismatch = true) {
    _endian_mismatch = mismatch;
  }

  bool endian_mismatch() const {
    return _endian_mismatch;
  }

  void set_agreed() {
    set_service(Agreed);
  }

  bool is_agreed() const {
    return Is_agreed_mess(service());
  }

  void set_causal() {
    set_service(Causal);
  }

  bool is_causal() const {
    return Is_causal_mess(service());
  }

  void set_fifo() {
    set_service(FIFO);
  }

  bool is_fifo() const {
    return Is_fifo_mess(service());
  }

  void set_reliable() {
    set_service(Reliable);
  }

  bool is_reliable() const {
    return Is_reliable_mess(service());
  }

  void set_unreliable() {
    set_service(Unreliable);
  }

  bool is_unreliable() const {
    return Is_unreliable_mess(service());
  }

  void set_safe() {
    set_service(Safe);
  }

  bool is_safe() const {
    return Is_safe_mess(service());
  }

  void set_self_discard(const bool discard = true) {
    _service_type |= SelfDiscard;
    if(!discard)
      _service_type ^= SelfDiscard;
  }

  bool is_self_discard() const {
    return Is_self_discard(service());
  }

  bool is_regular() const {
    return Is_regular_mess(service());
  }

  bool is_membership() const {
    return Is_membership_mess(service());
  }
};

__END_NS_SSRC_SPREAD

#endif