AppendToContainer.h

Go to the documentation of this file.

/*
 * Copyright 2006-2009 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
 *
 *     https://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_WSPR_UTILITY_APPEND_TO_CONTAINER_H
#define __SSRC_WSPR_UTILITY_APPEND_TO_CONTAINER_H

#include <ssrc/wispers-packages.h>

#include <utility>

__BEGIN_NS_SSRC_WSPR_UTILITY

template<typename container_type>
struct has_pushback {
  // Common case is to use sequences, so we use a default value of true.
  // That way, we'll get a compile-time error for any container that
  // does not implement push_back alerting the user to define a specialization.
  static const bool value = true;
};

#define WSPR_HAS_NOT_PUSHBACK(container) \
  __BEGIN_NS_SSRC_WSPR_UTILITY \
  template<> struct has_pushback<container >{static const bool value = false;}; \
  __END_NS_SSRC_WSPR_UTILITY

// TODO: Instead of AppendToContainer, we should really be using an insertion
// iterator in calling functions instead of the container (e.g., in
// database query for_each functions).  We can't use back_inserter
// because it is implemented only with push_back and we want to use
// push_back when available, falling back to insert(container.end(), value).

template<typename container_type,
         bool has_pushback = has_pushback<container_type>::value>
class AppendToContainer;

template<typename container_type>
class AppendToContainer<container_type, false> {
  container_type & _container;

public:
  typedef typename container_type::value_type value_type;

  AppendToContainer(container_type & container) : _container(container) { }

  void operator()(const value_type & value) const {
    _container.insert(_container.end(), value);
  }

  void operator()(value_type && value) const {
    _container.insert(_container.end(), std::forward<value_type>(value));
  }
};

template<typename container_type>
class AppendToContainer<container_type, true> {
  container_type & _container;

public:
  typedef typename container_type::value_type value_type;

  AppendToContainer(container_type & container) : _container(container) { }

  void operator()(const value_type & value) const {
    _container.push_back(value);
  }

  void operator()(value_type && value) const {
    _container.push_back(std::forward<value_type>(value));
  }
};

template<typename container_type>
class InsertToContainer {
  container_type & _container;

public:
  typedef typename container_type::value_type value_type;

  InsertToContainer(container_type & container) : _container(container) { }

  void operator()(const value_type & value) const {
    _container.insert(value);
  }

  void operator()(value_type && value) const {
    _container.insert(std::forward<value_type>(value));
  }
};

__END_NS_SSRC_WSPR_UTILITY

#endif