GroupList.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_GROUP_LIST_H
  #define __SSRC_SPREAD_GROUP_LIST_H
  
  #include <string>
  #include <ostream>
  
  #include <ssrc/spread/detail/Buffer.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>
   typedef char group_type[MAX_GROUP_NAME];
  __END_NS_SPREAD_INCLUDE
  
  __BEGIN_NS_SSRC_SPREAD
  
  using std::string;
  
  enum {
   MaxSizePrivateName = MAX_PRIVATE_NAME,
   MaxSizeProcessName = MAX_PROC_NAME,
   MaxSizeGroupName = MAX_GROUP_NAME,
   MinValidGroupNameChar = 36,
   MaxValidGroupNameChar = 126,
   GroupNameSeparatorChar = 35
  };
  
  
  inline
  std::pair<string,string> split_private_group(const string & private_group) {
   string::size_type length = private_group.find(GroupNameSeparatorChar, 1) - 1;
   return std::pair<string,string>(string(private_group, 1, length),
   string(private_group, length + 2,
   private_group.size() - length - 2));
  }
  
  class GroupList {
  private:
   struct group_type {
   Spread::group_type group;
   };
  
   typedef detail::Buffer<group_type> group_vector;
  
   group_vector _groups;
  
   const Spread::group_type *groups() const {
   return reinterpret_cast<const Spread::group_type *>(&_groups[0]);
   }
  
   Spread::group_type *groups() {
   return
   const_cast<Spread::group_type *>(reinterpret_cast<const Spread::group_type *>(&_groups[0]));
   }
  
   unsigned int capacity() const {
   return _groups.capacity();
   }
  
   void resize(const unsigned int size) {
   _groups.resize(size);
   }
  
  public:
  
   explicit GroupList(const unsigned int capacity = 10) : _groups(capacity) { }
  
   void add(const string & group) {
   int size;
   group_type gname;
   size = group.copy(gname.group, sizeof(Spread::group_type) - 1);
   gname.group[size] = 0;
   _groups.add(gname);
   }
  
   void add(const GroupList & groups) {
   if(&groups != this) {
   unsigned int offset = size();
   resize(size() + groups.size());
   std::memcpy(GroupList::groups() + offset, groups.groups(),
   groups.size()*sizeof(group_type));
   }
   }
  
   string group(const unsigned int index) const {
   return _groups[index].group;
   }
  
   string operator[](const unsigned int index) const {
   return group(index);
   }
  
   GroupList & operator=(const GroupList & groups) {
   if(&groups != this) {
   resize(groups.size());
   std::memcpy(GroupList::groups(), groups.groups(),
   size()*sizeof(group_type));
   }
   return *this;
   }
  
   void clear() {
   _groups.clear();
   }
  
   unsigned int size() const {
   return _groups.size();
   }
  
  private:
   friend class Mailbox;
   friend class BaseMessage;
  
   friend bool operator==(const GroupList & groups1,
   const GroupList & groups2)
   {
   unsigned int size = groups1.size();
  
   if(size != groups2.size())
   return false;
   else
   while(size-- > 0) {
   if(std::strncmp(groups1.groups()[size], groups2.groups()[size],
   MaxSizeGroupName))
   return false;
   }
  
   return true;
   }
  
   friend std::ostream & operator<<(std::ostream & output,
   const GroupList & groups)
   {
   for(unsigned int i = 0; i < groups.size(); ++i)
   output << groups._groups[i].group << std::endl;
   return output;
   }
  };
  
  __END_NS_SSRC_SPREAD
  
  #endif