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>
  
  // sp.h includes stddef.h, so we need to include it before sp.h in
  // order to ensure it gets skipped while inside the Spread namespace.
  #include <cstddef>
  
  __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