PrependToContainer.h

Go to the documentation of this file.

/*
 * Copyright 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_PREPEND_TO_CONTAINER_H
#define __SSRC_WSPR_UTILITY_PREPEND_TO_CONTAINER_H

#include <ssrc/wispers-packages.h>

__BEGIN_NS_SSRC_WSPR_UTILITY

template<typename container_type>
struct has_pushfront {
  // 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_front alerting the user to define a specialization.
  static const bool value = true;
};

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

// TODO: Instead of PrependToContainer, we should really be using an insertion
// iterator in calling functions instead of the container (e.g., in
// database query for_each functions).

template<typename container_type,
         bool has_pushfront = has_pushfront<container_type>::value>
class PrependToContainer;

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

public:
  typedef typename container_type::value_type value_type;

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

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

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

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

public:
  typedef typename container_type::value_type value_type;

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

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

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

__END_NS_SSRC_WSPR_UTILITY

#endif