copy count (non-compliant) count (compliant) count_if (non-compliant) count_if (compliant) find

for_each generate replace remove_copy remove_copy_if transform

namespace Digipen
{
#ifdef COMPLIANT

  template<typename Input, typename T> 
  typename iterator_traits<Input>::difference_type 
  count(Input first, Input last, const T& val)
  {
    typename iterator_traits<Input>::difference_type result = 0;
    while (first != last) 
    {
      if (*first == val)
        ++result;
      ++first;
    }
    return result;
  }


  template<typename Input, typename Pred> 
  typename iterator_traits<Input>::difference_type 
  count_if(Input first, Input last, Pred pred)
  {
    typename iterator_traits<Input>::difference_type result = 0;
    while (first != last) 
    {
      if (pred(*first))
        ++result;
     ++first;
    }
    return result;
  }
#else


  template<typename InputIt, typename T> 
  int count(InputIt first, InputIt last, const T& val)
  {
    int result = 0;
    while (first != last) 
    {
      if (*first == val)
        ++result;
      ++first;
    }
    return result;
  }


  template<typename InputIt, typename Pred> 
  int count_if(InputIt first, InputIt last, Pred pred)
  {
    int result = 0;
    while (first != last) 
    {
      if (pred(*first))
        ++result;
      ++first;
    }
    return result;
  }
#endif


  template<typename InputIt, typename T> 
  InputIt find(InputIt first, InputIt last, const T& val)
  {
    while (first != last) 
    {
      if (*first == val)
        return first;
      ++first;
    }
    return first;
  }


  template<typename ForwardIt, typename T> 
  void replace(ForwardIt first, ForwardIt last, const T& val, const T& new_val)
  {
    while (first != last) 
    {
      if (*first == val)
        *first = new_val;
      ++first;
    }
  }


  template<typename InputIt, typename OutputIt> 
  OutputIt copy(InputIt first, InputIt last, OutputIt result)
  {
    while (first != last) 
    {
      *result = *first;
      ++result;
      ++first;
    }
    return result;
  }


  template<typename InputIt, typename OutputIt, typename Pred> 
  OutputIt copy_if(InputIt first, InputIt last, OutputIt result, Pred pred)
  {
    while (first != last) 
    {
      if (pred(*first))
      {
        *result = *first;
        ++result;
      }
      ++first;
    }
    return result;
  }


  template<typename InputIt, typename Op> 
  Op for_each(InputIt first, InputIt last, Op op)
  {
    while (first != last)
    {
      op(*first);
      ++first;
    }
    return op;
  }


  template<typename InputIt, typename OutputIt, typename Op> 
  OutputIt transform(InputIt first, InputIt last, OutputIt result, Op op)
  {
    while (first != last) 
    {
      *result = op(*first);
      ++result;
      ++first;
    }
    return result;
  }


  template<typename ForwardIt, typename Gen> 
  void generate(ForwardIt first, ForwardIt last, Gen gen)
  {
    while (first != last) 
    {
      *first = gen();
      ++first;
    }
  }


  template<typename InputIt, typename OutputIt, typename T> 
  OutputIt remove_copy(InputIt first, InputIt last, OutputIt result, const T& val)
  {
    while (first != last) 
    {
      if (!(*first == val))
      {
        *result = *first;
        ++result;
      }
      ++first;
    }
    return result;
  }


  template<typename InputIt, typename OutputIt, typename Pred> 
  OutputIt remove_copy_if(InputIt first, InputIt last, OutputIt result, Pred pred)
  {
    while (first != last) 
    {
      if (!pred(*first))
      {
        *result = *first;
        ++result;
      }
      ++first;
    }
    return result;
  }

}