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>

__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