// Copyright 2002 The Trustees of Indiana University.

// Use, modification and distribution is subject to the Boost Software 

// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at

// http://www.boost.org/LICENSE_1_0.txt)

//  Boost.MultiArray Library

//  Authors: Ronald Garcia

//           Jeremy Siek

//           Andrew Lumsdaine

//  See http://www.boost.org/libs/multi_array for documentation.

/*

 * © Portions copyright (c) 2006-2007 Nokia Corporation.  All rights reserved.

*/

//

// Trying to diagnose problems under visual

#include "boost/config.hpp"

#include "boost/array.hpp"

#include "boost/limits.hpp"

#include <algorithm>

#include <utility>

#include <iostream>

#ifdef __SYMBIAN32__

#include "std_log_result.h"

#define LOG_FILENAME_LINE __FILE__, __LINE__

#endif

namespace dimtest

{

  typedef int index;		

}

typedef std::size_t size_type;

  template <typename Index,typename SizeType>

  class index_range {

  public:

    index_range()

    {

      start_ = from_start();

      finish_ = to_end();

      stride_ = 1;

      degenerate_ = false;

    }

    explicit index_range(Index pos)

    {

      start_ = pos;

      finish_ = pos;

      stride_ = 1;

      degenerate_ = true;

    }

    explicit index_range(Index start, Index finish, Index stride=1)

      : start_(start), finish_(finish), stride_(stride),

        degenerate_(start_ == finish_)

    { }

    // These are for chaining assignments to an index_range

    index_range& start(Index s) {

      start_ = s;

      degenerate_ = (start_ == finish_);

      return *this;

    }

    index_range& finish(Index f) {

      finish_ = f;

      degenerate_ = (start_ == finish_);

      return *this;

    }

    index_range& stride(Index s) { stride_ = s; return *this; }

    Index start() const

    { 

      return start_; 

    }

    Index get_start(Index low_index_range = 0) const

    { 

      if (start_ == from_start())

        return low_index_range;

      return start_; 

    }

    Index finish() const

    {

      return finish_;

    }

    Index get_finish(Index high_index_range = 0) const

    {

      if (finish_ == to_end())

        return high_index_range;

      return finish_;

    }

    unsigned int size(Index recommended_length = 0) const

    {

      if ((start_ == from_start()) || (finish_ == to_end()))

        return recommended_length;

      else 

        return (finish_ - start_) / stride_;

    }

    Index stride() const { return stride_; }

    bool is_ascending_contiguous() const

    {

      return (start_ < finish_) && is_unit_stride();

    }

    void set_index_range(Index start, Index finish, Index stride=1)

    {

      start_ = start;

      finish_ = finish;

      stride_ = stride;

    }

    static index_range all() 

    { return index_range(from_start(), to_end(), 1); }

    bool is_unit_stride() const

    { return stride_ == 1; }

    bool is_degenerate() const { return degenerate_; }

    index_range operator-(Index shift) const

    { 

      return index_range(start_ - shift, finish_ - shift, stride_); 

    }

    index_range operator+(Index shift) const

    { 

      return index_range(start_ + shift, finish_ + shift, stride_); 

    }

    Index operator[](unsigned i) const

    {

      return start_ + i * stride_;

    }

    Index operator()(unsigned i) const

    {

      return start_ + i * stride_;

    }

    // add conversion to std::slice?

  private:

    static Index from_start()

      { return (std::numeric_limits<Index>::min)(); }

    static Index to_end()

      { return (std::numeric_limits<Index>::max)(); }

  public:

    Index start_, finish_, stride_;

    bool degenerate_;

  };

  // Express open and closed interval end-points using the comparison

  // operators.

  // left closed

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<=(Index s, const index_range<Index,SizeType>& r)

  {

    return index_range<Index,SizeType>(s, r.finish(), r.stride());

  }

  // left open

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<(Index s, const index_range<Index,SizeType>& r)

  {

    return index_range<Index,SizeType>(s + 1, r.finish(), r.stride());

  }

  // right open

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<(const index_range<Index,SizeType>& r, Index f)

  {

    return index_range<Index,SizeType>(r.start(), f, r.stride());

  }

  // right closed

  template <typename Index, typename SizeType>

  inline index_range<Index,SizeType>

  operator<=(const index_range<Index,SizeType>& r, Index f)

  {

    return index_range<Index,SizeType>(r.start(), f + 1, r.stride());

  }

//

// range_list.hpp - helper to build boost::arrays for *_set types

//

/////////////////////////////////////////////////////////////////////////

// choose range list begins

//

struct choose_range_list_n {

  template <typename T, std::size_t NumRanges>

  struct bind {

    typedef boost::array<T,NumRanges> type;

  };

};

struct choose_range_list_zero {

  template <typename T, std::size_t NumRanges>

  struct bind {

    typedef boost::array<T,1> type;

  };

};

template <std::size_t NumRanges>

struct range_list_gen_helper {

  typedef choose_range_list_n choice;

};

template <>

struct range_list_gen_helper<0> {

  typedef choose_range_list_zero choice;

};

template <typename T, std::size_t NumRanges>

struct range_list_generator {

private:

  typedef typename range_list_gen_helper<NumRanges>::choice Choice;

public:

  typedef typename Choice::template bind<T,NumRanges>::type type;

};

//

// choose range list ends

/////////////////////////////////////////////////////////////////////////

//

// Index_gen.hpp stuff

//

template <int NumRanges, int NumDims>

struct index_gen {

private:

  typedef dimtest::index Index;

  typedef size_type SizeType;

  typedef index_range<Index,SizeType> range;

public:

  typedef typename range_list_generator<range,NumRanges>::type range_list;

  range_list ranges_;

  index_gen() { }

  template <int ND>

  explicit index_gen(const index_gen<NumRanges-1,ND>& rhs,

            const index_range<Index,SizeType>& range)

  {

    std::copy(rhs.ranges_.begin(),rhs.ranges_.end(),ranges_.begin());

    *ranges_.rbegin() = range;

  }

  index_gen<NumRanges+1,NumDims+1>

  operator[](const index_range<Index,SizeType>& range) const

  {

    index_gen<NumRanges+1,NumDims+1> tmp;

    std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());

    *tmp.ranges_.rbegin() = range;

    return tmp;

  }

  index_gen<NumRanges+1,NumDims>

  operator[](Index idx) const

  {

    index_gen<NumRanges+1,NumDims> tmp;

    std::copy(ranges_.begin(),ranges_.end(),tmp.ranges_.begin());

    *tmp.ranges_.rbegin() = index_range<Index,SizeType>(idx);

    return tmp;

  }    

};

template <int NDims, int NRanges>

void accept_gen(index_gen<NRanges,NDims>& indices) {

  // do nothing

}

template <typename X, typename Y, int A, int B>

class foo { };

class boo {

public:

  template <int NDims, int NRanges>

  void operator[](index_gen<NRanges,NDims>& indices) {

  }

};

template <typename X, typename Y, int A1, int A2>

void take_foo(foo<X,Y,A1,A2>& f) { }

using namespace std;

int main() {

  index_gen<0,0> indices;

  typedef index_range<dimtest::index,size_type> range;

  foo<int,std::size_t,1,2> f;

  take_foo(f);

  indices[range()][range()][range()];  

  accept_gen(indices);

  index_gen<0,0> index_g;

  accept_gen(index_g);

  index_gen<3,3> indices_3;

  accept_gen(indices_3);

  boo b;

  b[indices_3];

  #ifdef __SYMBIAN32__

   	testResultXml("dimtest");

	close_log_file();

#endif

  return 0;

}