singly_linked_list.h

//
// Copyright (c) 2014 Limit Point Systems, Inc. 
//
// 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.apache.org/licenses/LICENSE-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 SINGLY_LINKED_LIST_H
#define SINGLY_LINKED_LIST_H

#define HAVE_FORWARD_LIST 1

#ifndef SHEAF_DLL_SPEC_H
#include "sheaf_dll_spec.h"
#endif

// Include the appropriate header file.

#ifdef HAVE_FORWARD_LIST
#include <forward_list>
namespace list_ns = std;
#else
#include <ext/slist>
namespace list_ns = __gnu_cxx;
#endif

namespace sheaf
{

// Forward declarations to enable friend declaration.

template< class T, class Alloc > class singly_linked_list;

template< class T, class Alloc >
bool operator==(const singly_linked_list<T,Alloc>& lhs,
                const singly_linked_list<T,Alloc>& rhs);

template< class T, class Alloc >
bool operator<( const singly_linked_list<T,Alloc>& lhs,
                const singly_linked_list<T,Alloc>& rhs);

template <typename T, class A = list_ns::allocator<T> >
class SHEAF_DLL_SPEC singly_linked_list
{

  friend bool operator==<T, A>(const singly_linked_list<T,A>& lhs,
                               const singly_linked_list<T,A>& rhs);
  friend bool operator< <T, A>(const singly_linked_list<T,A>& lhs,
                               const singly_linked_list<T,A>& rhs);

public:

#ifdef HAVE_FORWARD_LIST
  typedef typename list_ns::forward_list<T, A>::value_type value_type;
  typedef typename list_ns::forward_list<T, A>::size_type size_type;
  typedef typename list_ns::forward_list<T, A>::difference_type difference_type;
  typedef typename list_ns::forward_list<T, A>::reference reference;
  typedef typename list_ns::forward_list<T, A>::const_reference const_reference;
  typedef typename list_ns::forward_list<T, A>::pointer pointer;
  typedef typename list_ns::forward_list<T, A>::iterator iterator;
  typedef typename list_ns::forward_list<T, A>::const_iterator const_iterator;
#else
  typedef typename list_ns::slist<T, A>::value_type value_type;
  typedef typename list_ns::slist<T, A>::size_type size_type;
  typedef typename list_ns::slist<T, A>::difference_type difference_type;
  typedef typename list_ns::slist<T, A>::reference reference;
  typedef typename list_ns::slist<T, A>::const_reference const_reference;
  typedef typename list_ns::slist<T, A>::pointer pointer;
  typedef typename list_ns::slist<T, A>::iterator iterator;
  typedef typename list_ns::slist<T, A>::const_iterator const_iterator;
#endif

  singly_linked_list()
  {
  };

  singly_linked_list(size_type count)
    : _list(count)
  {
  };

  singly_linked_list(size_type count, const T& value)
    : _list(count, value)
  {
  };

  singly_linked_list(const singly_linked_list& other)
    : _list(other._list)
  {
  };

  ~singly_linked_list()
  {
  };

  singly_linked_list& operator=(const singly_linked_list& other)
  {
    _list = other._list;

    return *this;
  };

  singly_linked_list& operator=(singly_linked_list& other)
  {
    _list = other._list;

    return *this;
  };

  void swap(singly_linked_list& other)
  {
    _list.swap(other._list);
  };

  reference front()
  {
    return _list.front();
  };

  const_reference front() const
  {
    return _list.front();
  };

  iterator begin()
  {
    return _list.begin();
  };

  const_iterator begin() const
  {
    return _list.begin();
  };
  
  iterator end()
  {
    return _list.end();
  };

  const_iterator end() const
  {
    return _list.end();
  };

  bool empty() const
  {
    return _list.empty();
  };

  size_type max_size() const
  {
    return _list.max_size();
  };

  void clear()
  {
    _list.clear();
  };

#ifdef HAVE_FORWARD_LIST

  //
  // Forward_list signatures for insert_after on Windows.  Use the Windows
  // signature because two of the insert_after after signatures have a
  // void return time.  The standard states that all insert_after signatures
  // should return an iterator but we need this code to compile on Windows.
  //

  iterator insert_after(const_iterator pos, const T& value)
  {
    return _list.insert_after(pos, value);
  };

  iterator insert_after(const_iterator pos, T&& value)
  {
    return _list.insert_after(pos, value);
  };

  void insert_after(const_iterator pos, size_type count, const T& value)
  {
    _list.insert_after(pos, count, value);
  };

  template<class InputIt>
  void insert_after(const_iterator pos, InputIt first, InputIt last)
  {
    _list.insert_after(pos, first, last);
  };

  //
  // Forward_list standard and Windows signatures for erase_after.
  //

  iterator erase_after(const_iterator position)
  {
    return _list.erase_after(position);
  };

#else // HAVE_FORWARD_LIST

  //
  // Slist signatures for insert_after and erase_after.
  //

  iterator insert_after(iterator pos, const T& value)
  {
    return _list.insert_after(pos, value);
  };

  iterator insert_after(iterator pos, T& value)
  {
    return _list.insert_after(pos, value);
  };

  void insert_after(iterator pos, size_type count, const T& value)
  {
    _list.insert_after(pos, count, value);
  };

  template<class InputIt>
  void insert_after(iterator pos, InputIt first, InputIt last)
  {
    _list.insert_after(pos, first, last);
  };

  iterator erase_after(iterator position)
  {
    return _list.erase_after(position);
  };

#endif // HAVE_FORWARD_LIST

  void push_front(const T& value)
  {
    _list.push_front(value);
  };

  void push_front(T& value)
  {
    _list.push_front(value);
  };

  template<class InputIt>
  void push_front(InputIt first, InputIt last)
  {
#ifdef HAVE_FORWARD_LIST
    _list.insert_after(_list.before_begin(), first, last);
#else
    _list.insert(_list.begin(), first, last);
#endif
  };

  void pop_front()
  {
    _list.pop_front();
  };

  void resize(size_type count)
  {
    _list.resize(count);
  };

  void resize(size_type count, const value_type& value)
  {
    _list.resize(count, value);
  };

  void merge(singly_linked_list& other)
  {
    _list.merge(other._list);
  };


  void remove(const T& value)
  {
     _list.remove(value);
  };

  void reverse()
  {
    _list.reverse();
  };

  void unique()
  {
    _list.unique();
  };

  void sort()
  {
    _list.sort();
  };

private:

#ifdef HAVE_FORWARD_LIST
  list_ns::forward_list<T, A> _list;
#else
  list_ns::slist<T, A> _list;
#endif

};

template< class T, class Alloc >
bool operator==(const singly_linked_list<T,Alloc>& lhs,
                const singly_linked_list<T,Alloc>& rhs)
{
  return (lhs._list == rhs._list);
};

template< class T, class Alloc >
bool operator<( const singly_linked_list<T,Alloc>& lhs,
                const singly_linked_list<T,Alloc>& rhs)
{
  return (lhs._list < rhs._list);
};

} // namespace sheaf

#endif // SINGLY_LINKED_LIST_H