BaseMessage.h

Go to the documentation of this file.

/*
 * $Id: BaseMessage.h 1125 2007-11-24 06:42:46Z dfs $
 *
 * 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 __SAVA_SPREAD_BASE_MESSAGE_H
#define __SAVA_SPREAD_BASE_MESSAGE_H

#include <string>

#include <sava/libsavaspread-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 <sava/spread/Error.h>
#include <sava/spread/GroupList.h>

__BEGIN_NS_SAVA_SPREAD

#ifdef LIBSAVASPREAD_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 LIBSAVASPREAD_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 LIBSAVASPREAD_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 throw() = 0;

  virtual void clear() = 0;

#ifdef LIBSAVASPREAD_ENABLE_MEMBERSHIP_INFO

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

#endif

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

  service_type service() const throw() {
    return _service_type;
  }

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

  message_type type() const throw() {
    return _type;
  }

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

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

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

  bool endian_mismatch() const throw() {
    return _endian_mismatch;
  }

  void set_agreed() throw() {
    set_service(Agreed);
  }

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

  void set_causal() throw() {
    set_service(Causal);
  }

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

  void set_fifo() throw() {
    set_service(FIFO);
  }

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

  void set_reliable() throw() {
    set_service(Reliable);
  }

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

  void set_unreliable() throw() {
    set_service(Unreliable);
  }

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

  void set_safe() throw() {
    set_service(Safe);
  }

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

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

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

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

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

__END_NS_SAVA_SPREAD

#endif

---

Copyright © 2006-2008 Savarese Software Research Corporation. All rights reserved.