diff -r 000000000000 -r bde4ae8d615e os/ossrv/stdcpp/tsrc/Boost_test/multi_array/src/dimtest.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/ossrv/stdcpp/tsrc/Boost_test/multi_array/src/dimtest.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,334 @@
+// 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;
+}