--- /dev/null
+// Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
+//
+// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef MED_Vector_HeaderFile
+#define MED_Vector_HeaderFile
+
+#include <vector>
+#include <stdexcept>
+
+//#if defined(_DEBUG_)
+# define MED_TVECTOR_CHECK_RANGE
+//#endif
+
+namespace MED
+{
+ //! Main purpose to introduce the class was to customize operator []
+ template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
+ class TVector : public std::vector<_Tp, _Alloc>
+ {
+ public:
+ typedef size_t size_type;
+
+ typedef std::vector<_Tp, _Alloc> superclass;
+ typedef typename superclass::allocator_type allocator_type;
+
+ typedef _Tp value_type;
+ typedef value_type& reference;
+ typedef const value_type& const_reference;
+
+ protected:
+ void
+ check_range(size_type __n) const
+ {
+ if (__n >= this->size())
+ throw std::out_of_range("TVector [] access out of range");
+ }
+
+ const_reference
+ get_value(size_type __n) const
+ {
+ return superclass::operator[](__n);
+ }
+
+ reference
+ get_value(size_type __n)
+ {
+ return superclass::operator[](__n);
+ }
+
+ public:
+ explicit
+ TVector(const allocator_type& __a = allocator_type()):
+ superclass(__a)
+ {}
+
+ TVector(size_type __n, const value_type& __val,
+ const allocator_type& __a = allocator_type()):
+ superclass(__n, __val, __a)
+ {}
+
+ explicit
+ TVector(size_type __n):
+ superclass(__n)
+ {}
+
+ TVector(const TVector& __x):
+ superclass(__x)
+ {}
+
+ template<typename _InputIterator>
+ TVector(_InputIterator __first, _InputIterator __last,
+ const allocator_type& __a = allocator_type()):
+ superclass(__first, __last, __a)
+ {}
+
+ template<typename _Yp, typename _Al>
+ TVector(TVector<_Yp, _Al> __y):
+ superclass(__y.begin(), __y.end())
+ {}
+
+ TVector&
+ operator=(const TVector& __x)
+ {
+ superclass::operator=(__x);
+ return *this;
+ }
+
+ template<typename _Yp, typename _Al>
+ TVector&
+ operator=(TVector<_Yp, _Al> __y)
+ {
+ this->assign(__y.begin(), __y.end());
+ return *this;
+ }
+
+ reference
+ operator[](size_type __n)
+ {
+#if defined(MED_TVECTOR_CHECK_RANGE)
+ check_range(__n);
+#endif
+ return get_value(__n);
+ }
+
+ const_reference
+ operator[](size_type __n) const
+ {
+#if defined(MED_TVECTOR_CHECK_RANGE)
+ check_range(__n);
+#endif
+ return get_value(__n);
+ }
+
+ reference
+ at(size_type __n)
+ {
+ check_range(__n);
+ return get_value(__n);
+ }
+
+ const_reference
+ at(size_type __n) const
+ {
+ check_range(__n);
+ return get_value(__n);
+ }
+ };
+}
+
+#undef MED_TVECTOR_CHECK_RANGE
+
+#endif // MED_Vector_HeaderFile